Daily bump.
[official-gcc.git] / gcc / cgraph.h
blob4cdb3738b4de0c3dbaaa0059fe0c1e4ff345ce2d
1 /* Callgraph handling code.
2 Copyright (C) 2003-2021 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.length ();
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 () const
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 /* Return DECL that alias is aliasing. */
323 inline tree get_alias_target_tree ();
325 /* Set section for symbol and its aliases. */
326 void set_section (const char *section);
328 /* Like set_section, but copying the section name from another node. */
329 void set_section (const symtab_node &other);
331 /* Set section, do not recurse into aliases.
332 When one wants to change section of symbol and its aliases,
333 use set_section. */
334 void set_section_for_node (const char *section);
336 /* Like set_section_for_node, but copying the section name from another
337 node. */
338 void set_section_for_node (const symtab_node &other);
340 /* Set initialization priority to PRIORITY. */
341 void set_init_priority (priority_type priority);
343 /* Return the initialization priority. */
344 priority_type get_init_priority ();
346 /* Return availability of NODE when referenced from REF. */
347 enum availability get_availability (symtab_node *ref = NULL);
349 /* During LTO stream-in this predicate can be used to check whether node
350 in question prevails in the linking to save some memory usage. */
351 bool prevailing_p (void);
353 /* Return true if NODE binds to current definition in final executable
354 when referenced from REF. If REF is NULL return conservative value
355 for any reference. */
356 bool binds_to_current_def_p (symtab_node *ref = NULL);
358 /* Make DECL local. */
359 void make_decl_local (void);
361 /* Copy visibility from N. */
362 void copy_visibility_from (symtab_node *n);
364 /* Return desired alignment of the definition. This is NOT alignment useful
365 to access THIS, because THIS may be interposable and DECL_ALIGN should
366 be used instead. It however must be guaranteed when output definition
367 of THIS. */
368 unsigned int definition_alignment ();
370 /* Return true if alignment can be increased. */
371 bool can_increase_alignment_p ();
373 /* Increase alignment of symbol to ALIGN. */
374 void increase_alignment (unsigned int align);
376 /* Return true if list contains an alias. */
377 bool has_aliases_p (void);
379 /* Return true when the symbol is real symbol, i.e. it is not inline clone
380 or abstract function kept for debug info purposes only. */
381 bool real_symbol_p (void);
383 /* Return true when the symbol needs to be output to the LTO symbol table. */
384 bool output_to_lto_symbol_table_p (void);
386 /* Determine if symbol declaration is needed. That is, visible to something
387 either outside this translation unit, something magic in the system
388 configury. This function is used just during symbol creation. */
389 bool needed_p (void);
391 /* Return true if this symbol is a function from the C frontend specified
392 directly in RTL form (with "__RTL"). */
393 bool native_rtl_p () const;
395 /* Return true when there are references to the node. */
396 bool referred_to_p (bool include_self = true);
398 /* Return true if symbol can be discarded by linker from the binary.
399 Assume that symbol is used (so there is no need to take into account
400 garbage collecting linkers)
402 This can happen for comdats, commons and weaks when they are prevailed
403 by other definition at static linking time. */
404 inline bool
405 can_be_discarded_p (void)
407 return (DECL_EXTERNAL (decl)
408 || ((get_comdat_group ()
409 || DECL_COMMON (decl)
410 || (DECL_SECTION_NAME (decl) && DECL_WEAK (decl)))
411 && ((resolution != LDPR_PREVAILING_DEF
412 && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
413 || flag_incremental_link)
414 && resolution != LDPR_PREVAILING_DEF_IRONLY));
417 /* Return true if NODE is local to a particular COMDAT group, and must not
418 be named from outside the COMDAT. This is used for C++ decloned
419 constructors. */
420 inline bool comdat_local_p (void)
422 return (same_comdat_group && !TREE_PUBLIC (decl));
425 /* Return true if ONE and TWO are part of the same COMDAT group. */
426 inline bool in_same_comdat_group_p (symtab_node *target);
428 /* Return true if symbol is known to be nonzero. */
429 bool nonzero_address ();
431 /* Return 0 if symbol is known to have different address than S2,
432 Return 1 if symbol is known to have same address as S2,
433 return 2 otherwise.
435 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
436 and S2 is going to be accessed. This eliminates the situations when
437 either THIS or S2 is NULL and is useful for comparing bases when deciding
438 about memory aliasing. */
439 int equal_address_to (symtab_node *s2, bool memory_accessed = false);
441 /* Return true if symbol's address may possibly be compared to other
442 symbol's address. */
443 bool address_matters_p ();
445 /* Return true if NODE's address can be compared. This use properties
446 of NODE only and does not look if the address is actually taken in
447 interesting way. For that use ADDRESS_MATTERS_P instead. */
448 bool address_can_be_compared_p (void);
450 /* Return symbol table node associated with DECL, if any,
451 and NULL otherwise. */
452 static inline symtab_node *get (const_tree decl)
454 /* Check that we are called for sane type of object - functions
455 and static or external variables. */
456 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
457 || (TREE_CODE (decl) == VAR_DECL
458 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
459 || in_lto_p)));
460 /* Check that the mapping is sane - perhaps this check can go away,
461 but at the moment frontends tends to corrupt the mapping by calling
462 memcpy/memset on the tree nodes. */
463 gcc_checking_assert (!decl->decl_with_vis.symtab_node
464 || decl->decl_with_vis.symtab_node->decl == decl);
465 return decl->decl_with_vis.symtab_node;
468 /* Try to find a symtab node for declaration DECL and if it does not
469 exist or if it corresponds to an inline clone, create a new one. */
470 static inline symtab_node * get_create (tree node);
472 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
473 Return NULL if there's no such node. */
474 static symtab_node *get_for_asmname (const_tree asmname);
476 /* Verify symbol table for internal consistency. */
477 static DEBUG_FUNCTION void verify_symtab_nodes (void);
479 /* Perform internal consistency checks, if they are enabled. */
480 static inline void checking_verify_symtab_nodes (void);
482 /* Type of the symbol. */
483 ENUM_BITFIELD (symtab_type) type : 8;
485 /* The symbols resolution. */
486 ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
488 /*** Flags representing the symbol type. ***/
490 /* True when symbol corresponds to a definition in current unit.
491 set via finalize_function or finalize_decl */
492 unsigned definition : 1;
493 /* True when symbol is an alias.
494 Set by assemble_alias. */
495 unsigned alias : 1;
496 /* When true the alias is translated into its target symbol either by GCC
497 or assembler (it also may just be a duplicate declaration of the same
498 linker name).
500 Currently transparent aliases come in three different flavors
501 - aliases having the same assembler name as their target (aka duplicated
502 declarations). In this case the assembler names compare via
503 assembler_names_equal_p and weakref is false
504 - aliases that are renamed at a time being output to final file
505 by varasm.c. For those DECL_ASSEMBLER_NAME have
506 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
507 name must be unique.
508 Weakrefs belong to this category when we target assembler without
509 .weakref directive.
510 - weakrefs that are renamed by assembler via .weakref directive.
511 In this case the alias may or may not be definition (depending if
512 target declaration was seen by the compiler), weakref is set.
513 Unless we are before renaming statics, assembler names are different.
515 Given that we now support duplicate declarations, the second option is
516 redundant and will be removed. */
517 unsigned transparent_alias : 1;
518 /* True when alias is a weakref. */
519 unsigned weakref : 1;
520 /* C++ frontend produce same body aliases and extra name aliases for
521 virtual functions and vtables that are obviously equivalent.
522 Those aliases are bit special, especially because C++ frontend
523 visibility code is so ugly it cannot get them right at first time
524 and their visibility needs to be copied from their "masters" at
525 the end of parsing. */
526 unsigned cpp_implicit_alias : 1;
527 /* The alias is a symbol version. */
528 unsigned symver : 1;
529 /* Set once the definition was analyzed. The list of references and
530 other properties are built during analysis. */
531 unsigned analyzed : 1;
532 /* Set for write-only variables. */
533 unsigned writeonly : 1;
534 /* Visibility of symbol was used for further optimization; do not
535 permit further changes. */
536 unsigned refuse_visibility_changes : 1;
538 /*** Visibility and linkage flags. ***/
540 /* Set when function is visible by other units. */
541 unsigned externally_visible : 1;
542 /* Don't reorder to other symbols having this set. */
543 unsigned no_reorder : 1;
544 /* The symbol will be assumed to be used in an invisible way (like
545 by an toplevel asm statement). */
546 unsigned force_output : 1;
547 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
548 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
549 to static and it does not inhibit optimization. */
550 unsigned forced_by_abi : 1;
551 /* True when the name is known to be unique and thus it does not need mangling. */
552 unsigned unique_name : 1;
553 /* Specify whether the section was set by user or by
554 compiler via -ffunction-sections. */
555 unsigned implicit_section : 1;
556 /* True when body and other characteristics have been removed by
557 symtab_remove_unreachable_nodes. */
558 unsigned body_removed : 1;
560 /*** WHOPR Partitioning flags.
561 These flags are used at ltrans stage when only part of the callgraph is
562 available. ***/
564 /* Set when variable is used from other LTRANS partition. */
565 unsigned used_from_other_partition : 1;
566 /* Set when function is available in the other LTRANS partition.
567 During WPA output it is used to mark nodes that are present in
568 multiple partitions. */
569 unsigned in_other_partition : 1;
573 /*** other flags. ***/
575 /* Set when symbol has address taken. */
576 unsigned address_taken : 1;
577 /* Set when init priority is set. */
578 unsigned in_init_priority_hash : 1;
580 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
581 of offloading, for separate compilation for a different target. */
582 unsigned need_lto_streaming : 1;
584 /* Set when symbol can be streamed into bytecode for offloading. */
585 unsigned offloadable : 1;
587 /* Set when symbol is an IFUNC resolver. */
588 unsigned ifunc_resolver : 1;
591 /* Ordering of all symtab entries. */
592 int order;
594 /* Declaration representing the symbol. */
595 tree decl;
597 /* Linked list of symbol table entries starting with symtab_nodes. */
598 symtab_node *next;
599 symtab_node *previous;
601 /* Linked list of symbols with the same asm name. There may be multiple
602 entries for single symbol name during LTO, because symbols are renamed
603 only after partitioning.
605 Because inline clones are kept in the assembler name has, they also produce
606 duplicate entries.
608 There are also several long standing bugs where frontends and builtin
609 code produce duplicated decls. */
610 symtab_node *next_sharing_asm_name;
611 symtab_node *previous_sharing_asm_name;
613 /* Circular list of nodes in the same comdat group if non-NULL. */
614 symtab_node *same_comdat_group;
616 /* Vectors of referring and referenced entities. */
617 ipa_ref_list GTY((skip)) ref_list;
619 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
620 depending to what was known to frontend on the creation time.
621 Once alias is resolved, this pointer become NULL. */
622 tree alias_target;
624 /* File stream where this node is being written to. */
625 struct lto_file_decl_data * lto_file_data;
627 PTR GTY ((skip)) aux;
629 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
630 tree x_comdat_group;
632 /* Section name. Again can be private, if allowed. */
633 section_hash_entry *x_section;
635 protected:
636 /* Dump base fields of symtab nodes to F. Not to be used directly. */
637 void dump_base (FILE *);
639 /* Verify common part of symtab node. */
640 bool DEBUG_FUNCTION verify_base (void);
642 /* Remove node from symbol table. This function is not used directly, but via
643 cgraph/varpool node removal routines. */
644 void unregister (struct clone_info *);
646 /* Return the initialization and finalization priority information for
647 DECL. If there is no previous priority information, a freshly
648 allocated structure is returned. */
649 struct symbol_priority_map *priority_info (void);
651 /* Worker for call_for_symbol_and_aliases_1. */
652 bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
653 void *data,
654 bool include_overwrite);
655 private:
656 /* Workers for set_section. */
657 static bool set_section_from_string (symtab_node *n, void *s);
658 static bool set_section_from_node (symtab_node *n, void *o);
660 /* Worker for symtab_resolve_alias. */
661 static bool set_implicit_section (symtab_node *n, void *);
663 /* Worker searching noninterposable alias. */
664 static bool noninterposable_alias (symtab_node *node, void *data);
666 /* Worker for ultimate_alias_target. */
667 symtab_node *ultimate_alias_target_1 (enum availability *avail = NULL,
668 symtab_node *ref = NULL);
670 /* Get dump name with normal or assembly name. */
671 const char *get_dump_name (bool asm_name_p) const;
674 inline void
675 symtab_node::checking_verify_symtab_nodes (void)
677 if (flag_checking)
678 symtab_node::verify_symtab_nodes ();
681 /* Walk all aliases for NODE. */
682 #define FOR_EACH_ALIAS(NODE, ALIAS) \
683 for (unsigned ALIAS##_iter_ = 0; \
684 (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS); \
685 ALIAS##_iter_++)
687 /* This is the information that is put into the cgraph local structure
688 to recover a function. */
689 struct lto_file_decl_data;
691 extern const char * const cgraph_availability_names[];
692 extern const char * const ld_plugin_symbol_resolution_names[];
693 extern const char * const tls_model_names[];
695 /* Represent which DECL tree (or reference to such tree)
696 will be replaced by another tree while versioning. */
697 struct GTY(()) ipa_replace_map
699 /* The new (replacing) tree. */
700 tree new_tree;
701 /* Parameter number to replace, when old_tree is NULL. */
702 int parm_num;
703 /* Set if the newly added reference should not be an address one, but a load
704 one from the operand of the ADDR_EXPR in NEW_TREE. This is for cases when
705 the corresponding parameter p is used only as *p. */
706 unsigned force_load_ref : 1;
709 enum cgraph_simd_clone_arg_type
711 SIMD_CLONE_ARG_TYPE_VECTOR,
712 SIMD_CLONE_ARG_TYPE_UNIFORM,
713 /* These are only for integer/pointer arguments passed by value. */
714 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
715 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
716 /* These 6 are only for reference type arguments or arguments passed
717 by reference. */
718 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
719 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP,
720 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
721 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP,
722 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
723 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP,
724 SIMD_CLONE_ARG_TYPE_MASK
727 /* Function arguments in the original function of a SIMD clone.
728 Supplementary data for `struct simd_clone'. */
730 struct GTY(()) cgraph_simd_clone_arg {
731 /* Original function argument as it originally existed in
732 DECL_ARGUMENTS. */
733 tree orig_arg;
735 /* orig_arg's function (or for extern functions type from
736 TYPE_ARG_TYPES). */
737 tree orig_type;
739 /* If argument is a vector, this holds the vector version of
740 orig_arg that after adjusting the argument types will live in
741 DECL_ARGUMENTS. Otherwise, this is NULL.
743 This basically holds:
744 vector(simdlen) __typeof__(orig_arg) new_arg. */
745 tree vector_arg;
747 /* vector_arg's type (or for extern functions new vector type. */
748 tree vector_type;
750 /* If argument is a vector, this holds the array where the simd
751 argument is held while executing the simd clone function. This
752 is a local variable in the cloned function. Its content is
753 copied from vector_arg upon entry to the clone.
755 This basically holds:
756 __typeof__(orig_arg) simd_array[simdlen]. */
757 tree simd_array;
759 /* A SIMD clone's argument can be either linear (constant or
760 variable), uniform, or vector. */
761 enum cgraph_simd_clone_arg_type arg_type;
763 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
764 the constant linear step, if arg_type is
765 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
766 the uniform argument holding the step, otherwise 0. */
767 HOST_WIDE_INT linear_step;
769 /* Variable alignment if available, otherwise 0. */
770 unsigned int alignment;
773 /* Specific data for a SIMD function clone. */
775 struct GTY(()) cgraph_simd_clone {
776 /* Number of words in the SIMD lane associated with this clone. */
777 poly_uint64 simdlen;
779 /* Number of annotated function arguments in `args'. This is
780 usually the number of named arguments in FNDECL. */
781 unsigned int nargs;
783 /* Max hardware vector size in bits for integral vectors. */
784 poly_uint64 vecsize_int;
786 /* Max hardware vector size in bits for floating point vectors. */
787 poly_uint64 vecsize_float;
789 /* Machine mode of the mask argument(s), if they are to be passed
790 as bitmasks in integer argument(s). VOIDmode if masks are passed
791 as vectors of characteristic type. */
792 machine_mode mask_mode;
794 /* The mangling character for a given vector size. This is used
795 to determine the ISA mangling bit as specified in the Intel
796 Vector ABI. */
797 unsigned char vecsize_mangle;
799 /* True if this is the masked, in-branch version of the clone,
800 otherwise false. */
801 unsigned int inbranch : 1;
803 /* Doubly linked list of SIMD clones. */
804 cgraph_node *prev_clone, *next_clone;
806 /* Original cgraph node the SIMD clones were created for. */
807 cgraph_node *origin;
809 /* Annotated function arguments for the original function. */
810 cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
813 /* Function Multiversioning info. */
814 struct GTY((for_user)) cgraph_function_version_info {
815 /* The cgraph_node for which the function version info is stored. */
816 cgraph_node *this_node;
817 /* Chains all the semantically identical function versions. The
818 first function in this chain is the version_info node of the
819 default function. */
820 cgraph_function_version_info *prev;
821 /* If this version node corresponds to a dispatcher for function
822 versions, this points to the version info node of the default
823 function, the first node in the chain. */
824 cgraph_function_version_info *next;
825 /* If this node corresponds to a function version, this points
826 to the dispatcher function decl, which is the function that must
827 be called to execute the right function version at run-time.
829 If this cgraph node is a dispatcher (if dispatcher_function is
830 true, in the cgraph_node struct) for function versions, this
831 points to resolver function, which holds the function body of the
832 dispatcher. The dispatcher decl is an alias to the resolver
833 function decl. */
834 tree dispatcher_resolver;
837 #define DEFCIFCODE(code, type, string) CIF_ ## code,
838 /* Reasons for inlining failures. */
840 enum cgraph_inline_failed_t {
841 #include "cif-code.def"
842 CIF_N_REASONS
845 enum cgraph_inline_failed_type_t
847 CIF_FINAL_NORMAL = 0,
848 CIF_FINAL_ERROR
851 struct cgraph_edge;
853 struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
855 typedef gimple *compare_type;
857 static hashval_t hash (cgraph_edge *);
858 static hashval_t hash (gimple *);
859 static bool equal (cgraph_edge *, gimple *);
862 /* The cgraph data structure.
863 Each function decl has assigned cgraph_node listing callees and callers. */
865 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
867 friend class symbol_table;
869 /* Constructor. */
870 explicit cgraph_node (int uid)
871 : symtab_node (SYMTAB_FUNCTION), callees (NULL), callers (NULL),
872 indirect_calls (NULL),
873 next_sibling_clone (NULL), prev_sibling_clone (NULL), clones (NULL),
874 clone_of (NULL), call_site_hash (NULL), former_clone_of (NULL),
875 simdclone (NULL), simd_clones (NULL), ipa_transforms_to_apply (vNULL),
876 inlined_to (NULL), rtl (NULL),
877 count (profile_count::uninitialized ()),
878 count_materialization_scale (REG_BR_PROB_BASE), profile_id (0),
879 unit_id (0), tp_first_run (0), thunk (false),
880 used_as_abstract_origin (false),
881 lowered (false), process (false), frequency (NODE_FREQUENCY_NORMAL),
882 only_called_at_startup (false), only_called_at_exit (false),
883 tm_clone (false), dispatcher_function (false), calls_comdat_local (false),
884 icf_merged (false), nonfreeing_fn (false), merged_comdat (false),
885 merged_extern_inline (false), parallelized_function (false),
886 split_part (false), indirect_call_target (false), local (false),
887 versionable (false), can_change_signature (false),
888 redefined_extern_inline (false), tm_may_enter_irr (false),
889 ipcp_clone (false), declare_variant_alt (false),
890 calls_declare_variant_alt (false), m_uid (uid), m_summary_id (-1)
893 /* Remove the node from cgraph and all inline clones inlined into it.
894 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
895 removed. This allows to call the function from outer loop walking clone
896 tree. */
897 bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
899 /* Record all references from cgraph_node that are taken
900 in statement STMT. */
901 void record_stmt_references (gimple *stmt);
903 /* Like cgraph_set_call_stmt but walk the clone tree and update all
904 clones sharing the same function body.
905 When WHOLE_SPECULATIVE_EDGES is true, all three components of
906 speculative edge gets updated. Otherwise we update only direct
907 call. */
908 void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
909 bool update_speculative = true);
911 /* Walk the alias chain to return the function cgraph_node is alias of.
912 Walk through thunk, too.
913 When AVAILABILITY is non-NULL, get minimal availability in the chain.
914 When REF is non-NULL, assume that reference happens in symbol REF
915 when determining the availability. */
916 cgraph_node *function_symbol (enum availability *avail = NULL,
917 struct symtab_node *ref = NULL);
919 /* Walk the alias chain to return the function cgraph_node is alias of.
920 Walk through non virtual thunks, too. Thus we return either a function
921 or a virtual thunk node.
922 When AVAILABILITY is non-NULL, get minimal availability in the chain.
923 When REF is non-NULL, assume that reference happens in symbol REF
924 when determining the availability. */
925 cgraph_node *function_or_virtual_thunk_symbol
926 (enum availability *avail = NULL,
927 struct symtab_node *ref = NULL);
929 /* Create node representing clone of N executed COUNT times. Decrease
930 the execution counts from original node too.
931 The new clone will have decl set to DECL that may or may not be the same
932 as decl of N.
934 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
935 function's profile to reflect the fact that part of execution is handled
936 by node.
937 When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about
938 the new clone. Otherwise the caller is responsible for doing so later.
940 If the new node is being inlined into another one, NEW_INLINED_TO should be
941 the outline function the new one is (even indirectly) inlined to.
942 All hooks will see this in node's inlined_to, when invoked.
943 Can be NULL if the node is not inlined. SUFFIX is string that is appended
944 to the original name. */
945 cgraph_node *create_clone (tree decl, profile_count count,
946 bool update_original,
947 vec<cgraph_edge *> redirect_callers,
948 bool call_duplication_hook,
949 cgraph_node *new_inlined_to,
950 ipa_param_adjustments *param_adjustments,
951 const char *suffix = NULL);
953 /* Create callgraph node clone with new declaration. The actual body will be
954 copied later at compilation stage. The name of the new clone will be
955 constructed from the name of the original node, SUFFIX and NUM_SUFFIX. */
956 cgraph_node *create_virtual_clone (const vec<cgraph_edge *> &redirect_callers,
957 vec<ipa_replace_map *, va_gc> *tree_map,
958 ipa_param_adjustments *param_adjustments,
959 const char * suffix, unsigned num_suffix);
961 /* Remove the node from the tree of virtual and inline clones and make it a
962 standalone node - not a clone any more. */
963 void remove_from_clone_tree ();
965 /* cgraph node being removed from symbol table; see if its entry can be
966 replaced by other inline clone. */
967 cgraph_node *find_replacement (struct clone_info *);
969 /* Create a new cgraph node which is the new version of
970 callgraph node. REDIRECT_CALLERS holds the callers
971 edges which should be redirected to point to
972 NEW_VERSION. ALL the callees edges of the node
973 are cloned to the new version node. Return the new
974 version node.
976 If non-NULL BLOCK_TO_COPY determine what basic blocks
977 was copied to prevent duplications of calls that are dead
978 in the clone.
980 SUFFIX is string that is appended to the original name. */
982 cgraph_node *create_version_clone (tree new_decl,
983 vec<cgraph_edge *> redirect_callers,
984 bitmap bbs_to_copy,
985 const char *suffix = NULL);
987 /* Perform function versioning.
988 Function versioning includes copying of the tree and
989 a callgraph update (creating a new cgraph node and updating
990 its callees and callers).
992 REDIRECT_CALLERS varray includes the edges to be redirected
993 to the new version.
995 TREE_MAP is a mapping of tree nodes we want to replace with
996 new ones (according to results of prior analysis).
998 If non-NULL ARGS_TO_SKIP determine function parameters to remove
999 from new version.
1000 If SKIP_RETURN is true, the new version will return void.
1001 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
1002 If non_NULL NEW_ENTRY determine new entry BB of the clone.
1004 If TARGET_ATTRIBUTES is non-null, when creating a new declaration,
1005 add the attributes to DECL_ATTRIBUTES. And call valid_attribute_p
1006 that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET
1007 of the declaration.
1009 If VERSION_DECL is set true, use clone_function_name_numbered for the
1010 function clone. Otherwise, use clone_function_name.
1012 Return the new version's cgraph node. */
1013 cgraph_node *create_version_clone_with_body
1014 (vec<cgraph_edge *> redirect_callers,
1015 vec<ipa_replace_map *, va_gc> *tree_map,
1016 ipa_param_adjustments *param_adjustments,
1017 bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name,
1018 tree target_attributes = NULL_TREE, bool version_decl = true);
1020 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
1021 corresponding to cgraph_node. */
1022 cgraph_function_version_info *insert_new_function_version (void);
1024 /* Get the cgraph_function_version_info node corresponding to node. */
1025 cgraph_function_version_info *function_version (void);
1027 /* Discover all functions and variables that are trivially needed, analyze
1028 them as well as all functions and variables referred by them */
1029 void analyze (void);
1031 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
1032 aliases DECL with an adjustments made into the first parameter.
1033 See comments in struct symtab-thunks.h for detail on the parameters. */
1034 cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
1035 HOST_WIDE_INT fixed_offset,
1036 HOST_WIDE_INT virtual_value,
1037 HOST_WIDE_INT indirect_offset,
1038 tree virtual_offset,
1039 tree real_alias);
1042 /* Return node that alias is aliasing. */
1043 inline cgraph_node *get_alias_target (void);
1045 /* Given function symbol, walk the alias chain to return the function node
1046 is alias of. Do not walk through thunks.
1047 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1048 When REF is non-NULL, assume that reference happens in symbol REF
1049 when determining the availability. */
1051 cgraph_node *ultimate_alias_target (availability *availability = NULL,
1052 symtab_node *ref = NULL);
1054 /* Call expand_thunk on all callers that are thunks and analyze those
1055 nodes that were expanded. */
1056 void expand_all_artificial_thunks ();
1058 /* Assemble thunks and aliases associated to node. */
1059 void assemble_thunks_and_aliases (void);
1061 /* Expand function specified by node. */
1062 void expand (void);
1064 /* As an GCC extension we allow redefinition of the function. The
1065 semantics when both copies of bodies differ is not well defined.
1066 We replace the old body with new body so in unit at a time mode
1067 we always use new body, while in normal mode we may end up with
1068 old body inlined into some functions and new body expanded and
1069 inlined in others. */
1070 void reset (void);
1072 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1073 kind of wrapper method. */
1074 void create_wrapper (cgraph_node *target);
1076 /* Verify cgraph nodes of the cgraph node. */
1077 void DEBUG_FUNCTION verify_node (void);
1079 /* Remove function from symbol table. */
1080 void remove (void);
1082 /* Dump call graph node to file F. */
1083 void dump (FILE *f);
1085 /* Dump call graph node to file F. */
1086 void dump_graphviz (FILE *f);
1088 /* Dump call graph node to stderr. */
1089 void DEBUG_FUNCTION debug (void);
1091 /* When doing LTO, read cgraph_node's body from disk if it is not already
1092 present. */
1093 bool get_untransformed_body ();
1095 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1096 if it is not already present. When some IPA transformations are scheduled,
1097 apply them. */
1098 bool get_body ();
1100 void materialize_clone (void);
1102 /* Release memory used to represent body of function.
1103 Use this only for functions that are released before being translated to
1104 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1105 are free'd in final.c via free_after_compilation(). */
1106 void release_body (bool keep_arguments = false);
1108 /* Return the DECL_STRUCT_FUNCTION of the function. */
1109 struct function *get_fun () const;
1111 /* Bring cgraph node local. */
1112 void make_local (void);
1114 /* Likewise indicate that a node is having address taken. */
1115 void mark_address_taken (void);
1117 /* Set finalization priority to PRIORITY. */
1118 void set_fini_priority (priority_type priority);
1120 /* Return the finalization priority. */
1121 priority_type get_fini_priority (void);
1123 /* Create edge from a given function to CALLEE in the cgraph. */
1124 cgraph_edge *create_edge (cgraph_node *callee,
1125 gcall *call_stmt, profile_count count,
1126 bool cloning_p = false);
1128 /* Create an indirect edge with a yet-undetermined callee where the call
1129 statement destination is a formal parameter of the caller with index
1130 PARAM_INDEX. */
1131 cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
1132 profile_count count,
1133 bool cloning_p = false);
1135 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1136 same function body. If clones already have edge for OLD_STMT; only
1137 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1138 void create_edge_including_clones (cgraph_node *callee,
1139 gimple *old_stmt, gcall *stmt,
1140 profile_count count,
1141 cgraph_inline_failed_t reason);
1143 /* Return the callgraph edge representing the GIMPLE_CALL statement
1144 CALL_STMT. */
1145 cgraph_edge *get_edge (gimple *call_stmt);
1147 /* Collect all callers of cgraph_node and its aliases that are known to lead
1148 to NODE (i.e. are not overwritable) and that are not thunks. */
1149 auto_vec<cgraph_edge *> collect_callers (void);
1151 /* Remove all callers from the node. */
1152 void remove_callers (void);
1154 /* Remove all callees from the node. */
1155 void remove_callees (void);
1157 /* Return function availability. See cgraph.h for description of individual
1158 return values. */
1159 enum availability get_availability (symtab_node *ref = NULL);
1161 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1162 if any to NOTHROW. */
1163 bool set_nothrow_flag (bool nothrow);
1165 /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
1166 if any. */
1167 bool set_malloc_flag (bool malloc_p);
1169 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1170 If SET_CONST if false, clear the flag.
1172 When setting the flag be careful about possible interposition and
1173 do not set the flag for functions that can be interposed and set pure
1174 flag for functions that can bind to other definition.
1176 Return true if any change was done. */
1178 bool set_const_flag (bool set_const, bool looping);
1180 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1181 if any to PURE.
1183 When setting the flag, be careful about possible interposition.
1184 Return true if any change was done. */
1186 bool set_pure_flag (bool pure, bool looping);
1188 /* Call callback on function and aliases associated to the function.
1189 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1190 skipped. */
1192 bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
1193 void *),
1194 void *data, bool include_overwritable);
1196 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1197 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1198 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1199 skipped. */
1200 bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
1201 void *data),
1202 void *data,
1203 bool include_overwritable,
1204 bool exclude_virtual_thunks = false);
1206 /* Likewise indicate that a node is needed, i.e. reachable via some
1207 external means. */
1208 inline void mark_force_output (void);
1210 /* Return true when function can be marked local. */
1211 bool local_p (void);
1213 /* Return true if cgraph_node can be made local for API change.
1214 Extern inline functions and C++ COMDAT functions can be made local
1215 at the expense of possible code size growth if function is used in multiple
1216 compilation units. */
1217 bool can_be_local_p (void);
1219 /* Return true when cgraph_node cannot return or throw and thus
1220 it is safe to ignore its side effects for IPA analysis. */
1221 bool cannot_return_p (void);
1223 /* Return true when function cgraph_node and all its aliases are only called
1224 directly.
1225 i.e. it is not externally visible, address was not taken and
1226 it is not used in any other non-standard way. */
1227 bool only_called_directly_p (void);
1229 /* Return true when function is only called directly or it has alias.
1230 i.e. it is not externally visible, address was not taken and
1231 it is not used in any other non-standard way. */
1232 inline bool only_called_directly_or_aliased_p (void);
1234 /* Return true when function cgraph_node can be expected to be removed
1235 from program when direct calls in this compilation unit are removed.
1237 As a special case COMDAT functions are
1238 cgraph_can_remove_if_no_direct_calls_p while the are not
1239 cgraph_only_called_directly_p (it is possible they are called from other
1240 unit)
1242 This function behaves as cgraph_only_called_directly_p because eliminating
1243 all uses of COMDAT function does not make it necessarily disappear from
1244 the program unless we are compiling whole program or we do LTO. In this
1245 case we know we win since dynamic linking will not really discard the
1246 linkonce section.
1248 If WILL_INLINE is true, assume that function will be inlined into all the
1249 direct calls. */
1250 bool will_be_removed_from_program_if_no_direct_calls_p
1251 (bool will_inline = false);
1253 /* Return true when function can be removed from callgraph
1254 if all direct calls and references are eliminated. The function does
1255 not take into account comdat groups. */
1256 bool can_remove_if_no_direct_calls_and_refs_p (void);
1258 /* Return true when function cgraph_node and its aliases can be removed from
1259 callgraph if all direct calls are eliminated.
1260 If WILL_INLINE is true, assume that function will be inlined into all the
1261 direct calls. */
1262 bool can_remove_if_no_direct_calls_p (bool will_inline = false);
1264 /* Return true when callgraph node is a function with Gimple body defined
1265 in current unit. Functions can also be define externally or they
1266 can be thunks with no Gimple representation.
1268 Note that at WPA stage, the function body may not be present in memory. */
1269 inline bool has_gimple_body_p (void);
1271 /* Return true if this node represents a former, i.e. an expanded, thunk. */
1272 bool former_thunk_p (void);
1274 /* Check if function calls comdat local. This is used to recompute
1275 calls_comdat_local flag after function transformations. */
1276 bool check_calls_comdat_local_p ();
1278 /* Return true if function should be optimized for size. */
1279 enum optimize_size_level optimize_for_size_p (void);
1281 /* Dump the callgraph to file F. */
1282 static void dump_cgraph (FILE *f);
1284 /* Dump the call graph to stderr. */
1285 static inline
1286 void debug_cgraph (void)
1288 dump_cgraph (stderr);
1291 /* Get unique identifier of the node. */
1292 inline int get_uid ()
1294 return m_uid;
1297 /* Get summary id of the node. */
1298 inline int get_summary_id ()
1300 return m_summary_id;
1303 /* Record that DECL1 and DECL2 are semantically identical function
1304 versions. */
1305 static void record_function_versions (tree decl1, tree decl2);
1307 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1308 DECL is a duplicate declaration. */
1309 static void delete_function_version_by_decl (tree decl);
1311 /* Add the function FNDECL to the call graph.
1312 Unlike finalize_function, this function is intended to be used
1313 by middle end and allows insertion of new function at arbitrary point
1314 of compilation. The function can be either in high, low or SSA form
1315 GIMPLE.
1317 The function is assumed to be reachable and have address taken (so no
1318 API breaking optimizations are performed on it).
1320 Main work done by this function is to enqueue the function for later
1321 processing to avoid need the passes to be re-entrant. */
1322 static void add_new_function (tree fndecl, bool lowered);
1324 /* Return callgraph node for given symbol and check it is a function. */
1325 static inline cgraph_node *get (const_tree decl)
1327 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
1328 return dyn_cast <cgraph_node *> (symtab_node::get (decl));
1331 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1332 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1333 have the garbage collector run at the moment. We would need to either
1334 create a new GC context, or just not compile right now. */
1335 static void finalize_function (tree, bool);
1337 /* Return cgraph node assigned to DECL. Create new one when needed. */
1338 static cgraph_node * create (tree decl);
1340 /* Try to find a call graph node for declaration DECL and if it does not
1341 exist or if it corresponds to an inline clone, create a new one. */
1342 static cgraph_node * get_create (tree);
1344 /* Return local info for the compiled function. */
1345 static cgraph_node *local_info_node (tree decl);
1347 /* Return RTL info for the compiled function. */
1348 static struct cgraph_rtl_info *rtl_info (const_tree);
1350 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1351 Return NULL if there's no such node. */
1352 static cgraph_node *get_for_asmname (tree asmname);
1354 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1355 successful and NULL otherwise.
1356 Same body aliases are output whenever the body of DECL is output,
1357 and cgraph_node::get (ALIAS) transparently
1358 returns cgraph_node::get (DECL). */
1359 static cgraph_node * create_same_body_alias (tree alias, tree decl);
1361 /* Verify whole cgraph structure. */
1362 static void DEBUG_FUNCTION verify_cgraph_nodes (void);
1364 /* Verify cgraph, if consistency checking is enabled. */
1365 static inline void checking_verify_cgraph_nodes (void);
1367 /* Worker to bring NODE local. */
1368 static bool make_local (cgraph_node *node, void *);
1370 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1371 the function body is associated
1372 with (not necessarily cgraph_node (DECL). */
1373 static cgraph_node *create_alias (tree alias, tree target);
1375 /* Return true if NODE has thunk. */
1376 static bool has_thunk_p (cgraph_node *node, void *);
1378 cgraph_edge *callees;
1379 cgraph_edge *callers;
1380 /* List of edges representing indirect calls with a yet undetermined
1381 callee. */
1382 cgraph_edge *indirect_calls;
1383 cgraph_node *next_sibling_clone;
1384 cgraph_node *prev_sibling_clone;
1385 cgraph_node *clones;
1386 cgraph_node *clone_of;
1387 /* For functions with many calls sites it holds map from call expression
1388 to the edge to speed up cgraph_edge function. */
1389 hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
1390 /* Declaration node used to be clone of. */
1391 tree former_clone_of;
1393 /* If this is a SIMD clone, this points to the SIMD specific
1394 information for it. */
1395 cgraph_simd_clone *simdclone;
1396 /* If this function has SIMD clones, this points to the first clone. */
1397 cgraph_node *simd_clones;
1399 /* Interprocedural passes scheduled to have their transform functions
1400 applied next time we execute local pass on them. We maintain it
1401 per-function in order to allow IPA passes to introduce new functions. */
1402 vec<ipa_opt_pass, va_heap, vl_ptr> GTY((skip)) ipa_transforms_to_apply;
1404 /* For inline clones this points to the function they will be
1405 inlined into. */
1406 cgraph_node *inlined_to;
1408 struct cgraph_rtl_info *rtl;
1410 /* Expected number of executions: calculated in profile.c. */
1411 profile_count count;
1412 /* How to scale counts at materialization time; used to merge
1413 LTO units with different number of profile runs. */
1414 int count_materialization_scale;
1415 /* ID assigned by the profiling. */
1416 unsigned int profile_id;
1417 /* ID of the translation unit. */
1418 int unit_id;
1419 /* Time profiler: first run of function. */
1420 int tp_first_run;
1422 /* True when symbol is a thunk. */
1423 unsigned thunk : 1;
1424 /* Set when decl is an abstract function pointed to by the
1425 ABSTRACT_DECL_ORIGIN of a reachable function. */
1426 unsigned used_as_abstract_origin : 1;
1427 /* Set once the function is lowered (i.e. its CFG is built). */
1428 unsigned lowered : 1;
1429 /* Set once the function has been instantiated and its callee
1430 lists created. */
1431 unsigned process : 1;
1432 /* How commonly executed the node is. Initialized during branch
1433 probabilities pass. */
1434 ENUM_BITFIELD (node_frequency) frequency : 2;
1435 /* True when function can only be called at startup (from static ctor). */
1436 unsigned only_called_at_startup : 1;
1437 /* True when function can only be called at startup (from static dtor). */
1438 unsigned only_called_at_exit : 1;
1439 /* True when function is the transactional clone of a function which
1440 is called only from inside transactions. */
1441 /* ?? We should be able to remove this. We have enough bits in
1442 cgraph to calculate it. */
1443 unsigned tm_clone : 1;
1444 /* True if this decl is a dispatcher for function versions. */
1445 unsigned dispatcher_function : 1;
1446 /* True if this decl calls a COMDAT-local function. This is set up in
1447 compute_fn_summary and inline_call. */
1448 unsigned calls_comdat_local : 1;
1449 /* True if node has been created by merge operation in IPA-ICF. */
1450 unsigned icf_merged: 1;
1451 /* True if call to node can't result in a call to free, munmap or
1452 other operation that could make previously non-trapping memory
1453 accesses trapping. */
1454 unsigned nonfreeing_fn : 1;
1455 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1456 unsigned merged_comdat : 1;
1457 /* True if this def was merged with extern inlines. */
1458 unsigned merged_extern_inline : 1;
1459 /* True if function was created to be executed in parallel. */
1460 unsigned parallelized_function : 1;
1461 /* True if function is part split out by ipa-split. */
1462 unsigned split_part : 1;
1463 /* True if the function appears as possible target of indirect call. */
1464 unsigned indirect_call_target : 1;
1465 /* Set when function is visible in current compilation unit only and
1466 its address is never taken. */
1467 unsigned local : 1;
1468 /* False when there is something makes versioning impossible. */
1469 unsigned versionable : 1;
1470 /* False when function calling convention and signature cannot be changed.
1471 This is the case when __builtin_apply_args is used. */
1472 unsigned can_change_signature : 1;
1473 /* True when the function has been originally extern inline, but it is
1474 redefined now. */
1475 unsigned redefined_extern_inline : 1;
1476 /* True if the function may enter serial irrevocable mode. */
1477 unsigned tm_may_enter_irr : 1;
1478 /* True if this was a clone created by ipa-cp. */
1479 unsigned ipcp_clone : 1;
1480 /* True if this is the deferred declare variant resolution artificial
1481 function. */
1482 unsigned declare_variant_alt : 1;
1483 /* True if the function calls declare_variant_alt functions. */
1484 unsigned calls_declare_variant_alt : 1;
1486 private:
1487 /* Unique id of the node. */
1488 int m_uid;
1490 /* Summary id that is recycled. */
1491 int m_summary_id;
1493 /* Worker for call_for_symbol_and_aliases. */
1494 bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
1495 void *),
1496 void *data, bool include_overwritable);
1499 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1500 can appear in multiple sets. */
1501 struct cgraph_node_set_def
1503 hash_map<cgraph_node *, size_t> *map;
1504 vec<cgraph_node *> nodes;
1507 typedef cgraph_node_set_def *cgraph_node_set;
1508 typedef struct varpool_node_set_def *varpool_node_set;
1510 struct varpool_node;
1512 /* A varpool node set is a collection of varpool nodes. A varpool node
1513 can appear in multiple sets. */
1514 struct varpool_node_set_def
1516 hash_map<varpool_node *, size_t> * map;
1517 vec<varpool_node *> nodes;
1520 /* Iterator structure for cgraph node sets. */
1521 struct cgraph_node_set_iterator
1523 cgraph_node_set set;
1524 unsigned index;
1527 /* Iterator structure for varpool node sets. */
1528 struct varpool_node_set_iterator
1530 varpool_node_set set;
1531 unsigned index;
1534 /* Context of polymorphic call. It represent information about the type of
1535 instance that may reach the call. This is used by ipa-devirt walkers of the
1536 type inheritance graph. */
1538 class GTY(()) ipa_polymorphic_call_context {
1539 public:
1540 /* The called object appears in an object of type OUTER_TYPE
1541 at offset OFFSET. When information is not 100% reliable, we
1542 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1543 HOST_WIDE_INT offset;
1544 HOST_WIDE_INT speculative_offset;
1545 tree outer_type;
1546 tree speculative_outer_type;
1547 /* True if outer object may be in construction or destruction. */
1548 unsigned maybe_in_construction : 1;
1549 /* True if outer object may be of derived type. */
1550 unsigned maybe_derived_type : 1;
1551 /* True if speculative outer object may be of derived type. We always
1552 speculate that construction does not happen. */
1553 unsigned speculative_maybe_derived_type : 1;
1554 /* True if the context is invalid and all calls should be redirected
1555 to BUILTIN_UNREACHABLE. */
1556 unsigned invalid : 1;
1557 /* True if the outer type is dynamic. */
1558 unsigned dynamic : 1;
1560 /* Build empty "I know nothing" context. */
1561 ipa_polymorphic_call_context ();
1562 /* Build polymorphic call context for indirect call E. */
1563 ipa_polymorphic_call_context (cgraph_edge *e);
1564 /* Build polymorphic call context for IP invariant CST.
1565 If specified, OTR_TYPE specify the type of polymorphic call
1566 that takes CST+OFFSET as a parameter. */
1567 ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
1568 HOST_WIDE_INT offset = 0);
1569 /* Build context for pointer REF contained in FNDECL at statement STMT.
1570 if INSTANCE is non-NULL, return pointer to the object described by
1571 the context. */
1572 ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
1573 tree *instance = NULL);
1575 /* Look for vtable stores or constructor calls to work out dynamic type
1576 of memory location. */
1577 bool get_dynamic_type (tree, tree, tree, gimple *, unsigned *);
1579 /* Make context non-speculative. */
1580 void clear_speculation ();
1582 /* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is
1583 NULL, the context is set to dummy "I know nothing" setting. */
1584 void clear_outer_type (tree otr_type = NULL);
1586 /* Walk container types and modify context to point to actual class
1587 containing OTR_TYPE (if non-NULL) as base class.
1588 Return true if resulting context is valid.
1590 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1591 valid only via allocation of new polymorphic type inside by means
1592 of placement new.
1594 When CONSIDER_BASES is false, only look for actual fields, not base types
1595 of TYPE. */
1596 bool restrict_to_inner_class (tree otr_type,
1597 bool consider_placement_new = true,
1598 bool consider_bases = true);
1600 /* Adjust all offsets in contexts by given number of bits. */
1601 void offset_by (HOST_WIDE_INT);
1602 /* Use when we cannot track dynamic type change. This speculatively assume
1603 type change is not happening. */
1604 void possible_dynamic_type_change (bool, tree otr_type = NULL);
1605 /* Assume that both THIS and a given context is valid and strengthen THIS
1606 if possible. Return true if any strengthening was made.
1607 If actual type the context is being used in is known, OTR_TYPE should be
1608 set accordingly. This improves quality of combined result. */
1609 bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1610 bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1612 /* Return TRUE if context is fully useless. */
1613 bool useless_p () const;
1614 /* Return TRUE if this context conveys the same information as X. */
1615 bool equal_to (const ipa_polymorphic_call_context &x) const;
1617 /* Dump human readable context to F. If NEWLINE is true, it will be
1618 terminated by a newline. */
1619 void dump (FILE *f, bool newline = true) const;
1620 void DEBUG_FUNCTION debug () const;
1622 /* LTO streaming. */
1623 void stream_out (struct output_block *) const;
1624 void stream_in (class lto_input_block *, class data_in *data_in);
1626 private:
1627 bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1628 bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1629 void set_by_decl (tree, HOST_WIDE_INT);
1630 bool set_by_invariant (tree, tree, HOST_WIDE_INT);
1631 bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
1632 void make_speculative (tree otr_type = NULL);
1635 /* Structure containing additional information about an indirect call. */
1637 class GTY(()) cgraph_indirect_call_info
1639 public:
1640 /* When agg_content is set, an offset where the call pointer is located
1641 within the aggregate. */
1642 HOST_WIDE_INT offset;
1643 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1644 ipa_polymorphic_call_context context;
1645 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1646 HOST_WIDE_INT otr_token;
1647 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1648 tree otr_type;
1649 /* Index of the parameter that is called. */
1650 int param_index;
1651 /* ECF flags determined from the caller. */
1652 int ecf_flags;
1654 /* Number of speculative call targets, it's less than GCOV_TOPN_VALUES. */
1655 unsigned num_speculative_call_targets : 16;
1657 /* Set when the call is a virtual call with the parameter being the
1658 associated object pointer rather than a simple direct call. */
1659 unsigned polymorphic : 1;
1660 /* Set when the call is a call of a pointer loaded from contents of an
1661 aggregate at offset. */
1662 unsigned agg_contents : 1;
1663 /* Set when this is a call through a member pointer. */
1664 unsigned member_ptr : 1;
1665 /* When the agg_contents bit is set, this one determines whether the
1666 destination is loaded from a parameter passed by reference. */
1667 unsigned by_ref : 1;
1668 /* When the agg_contents bit is set, this one determines whether we can
1669 deduce from the function body that the loaded value from the reference is
1670 never modified between the invocation of the function and the load
1671 point. */
1672 unsigned guaranteed_unmodified : 1;
1673 /* For polymorphic calls this specify whether the virtual table pointer
1674 may have changed in between function entry and the call. */
1675 unsigned vptr_changed : 1;
1678 class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1679 for_user)) cgraph_edge
1681 public:
1682 friend struct cgraph_node;
1683 friend class symbol_table;
1685 /* Remove EDGE from the cgraph. */
1686 static void remove (cgraph_edge *edge);
1688 /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E
1689 is any component of speculative edge, then update all components.
1690 Speculations can be resolved in the process and EDGE can be removed and
1691 deallocated. Return the edge that now represents the call. */
1692 static cgraph_edge *set_call_stmt (cgraph_edge *e, gcall *new_stmt,
1693 bool update_speculative = true);
1695 /* Redirect callee of the edge to N. The function does not update underlying
1696 call expression. */
1697 void redirect_callee (cgraph_node *n);
1699 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1700 create one or more equivalent thunks for N and redirect E to the first in
1701 the chain. Note that it is then necessary to call
1702 n->expand_all_artificial_thunks once all callers are redirected. */
1703 void redirect_callee_duplicating_thunks (cgraph_node *n);
1705 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1706 CALLEE. Speculations can be resolved in the process and EDGE can be
1707 removed and deallocated. Return the edge that now represents the
1708 call. */
1709 static cgraph_edge *make_direct (cgraph_edge *edge, cgraph_node *callee);
1711 /* Turn edge into speculative call calling N2. Update
1712 the profile so the direct call is taken COUNT times
1713 with FREQUENCY. speculative_id is used to link direct calls with their
1714 corresponding IPA_REF_ADDR references when representing speculative calls.
1716 cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count,
1717 unsigned int speculative_id = 0);
1719 /* Speculative call consists of an indirect edge and one or more
1720 direct edge+ref pairs. Speculative will expand to the following sequence:
1722 if (call_dest == target1) // reference to target1
1723 target1 (); // direct call to target1
1724 else if (call_dest == target2) // reference to targt2
1725 target2 (); // direct call to target2
1726 else
1727 call_dest (); // indirect call
1729 Before the expansion we will have indirect call and the direct call+ref
1730 pairs all linked to single statement.
1732 Note that ref may point to different symbol than the corresponding call
1733 becuase the speculated edge may have been optimized (redirected to
1734 a clone) or inlined.
1736 Given an edge which is part of speculative call, return the first
1737 direct call edge in the speculative call sequence.
1739 In the example above called on any cgraph edge in the sequence it will
1740 return direct call to target1. */
1741 cgraph_edge *first_speculative_call_target ();
1743 /* Return next speculative call target or NULL if there is none.
1744 All targets are required to form an interval in the callee list.
1746 In example above, if called on call to target1 it will return call to
1747 target2. */
1748 cgraph_edge *next_speculative_call_target ()
1750 cgraph_edge *e = this;
1751 gcc_checking_assert (speculative && callee);
1753 if (e->next_callee && e->next_callee->speculative
1754 && e->next_callee->call_stmt == e->call_stmt
1755 && e->next_callee->lto_stmt_uid == e->lto_stmt_uid)
1756 return e->next_callee;
1757 return NULL;
1760 /* When called on any edge in the speculative call return the (unique)
1761 indirect call edge in the speculative call sequence. */
1762 cgraph_edge *speculative_call_indirect_edge ()
1764 gcc_checking_assert (speculative);
1765 if (!callee)
1766 return this;
1767 for (cgraph_edge *e2 = caller->indirect_calls;
1768 true; e2 = e2->next_callee)
1769 if (e2->speculative
1770 && call_stmt == e2->call_stmt
1771 && lto_stmt_uid == e2->lto_stmt_uid)
1772 return e2;
1775 /* When called on any edge in speculative call and when given any target
1776 of ref which is speculated to it returns the corresponding direct call.
1778 In example above if called on function target2 it will return call to
1779 target2. */
1780 cgraph_edge *speculative_call_for_target (cgraph_node *);
1782 /* Return REF corresponding to direct call in the specualtive call
1783 sequence. */
1784 ipa_ref *speculative_call_target_ref ()
1786 ipa_ref *ref;
1788 gcc_checking_assert (speculative);
1789 for (unsigned int i = 0; caller->iterate_reference (i, ref); i++)
1790 if (ref->speculative && ref->speculative_id == speculative_id
1791 && ref->stmt == (gimple *)call_stmt
1792 && ref->lto_stmt_uid == lto_stmt_uid)
1793 return ref;
1794 gcc_unreachable ();
1797 /* Speculative call edge turned out to be direct call to CALLEE_DECL. Remove
1798 the speculative call sequence and return edge representing the call, the
1799 original EDGE can be removed and deallocated. It is up to caller to
1800 redirect the call as appropriate. Return the edge that now represents the
1801 call.
1803 For "speculative" indirect call that contains multiple "speculative"
1804 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1805 decrease the count and only remove current direct edge.
1807 If no speculative direct call left to the speculative indirect call, remove
1808 the speculative of both the indirect call and corresponding direct edge.
1810 It is up to caller to iteratively resolve each "speculative" direct call
1811 and redirect the call as appropriate. */
1812 static cgraph_edge *resolve_speculation (cgraph_edge *edge,
1813 tree callee_decl = NULL);
1815 /* If necessary, change the function declaration in the call statement
1816 associated with edge E so that it corresponds to the edge callee.
1817 Speculations can be resolved in the process and EDGE can be removed and
1818 deallocated.
1820 The edge could be one of speculative direct call generated from speculative
1821 indirect call. In this circumstance, decrease the speculative targets
1822 count (i.e. num_speculative_call_targets) and redirect call stmt to the
1823 corresponding i-th target. If no speculative direct call left to the
1824 speculative indirect call, remove "speculative" of the indirect call and
1825 also redirect stmt to it's final direct target.
1827 It is up to caller to iteratively transform each "speculative"
1828 direct call as appropriate. */
1829 static gimple *redirect_call_stmt_to_callee (cgraph_edge *e);
1831 /* Create clone of edge in the node N represented
1832 by CALL_EXPR the callgraph. */
1833 cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
1834 profile_count num, profile_count den,
1835 bool update_original);
1837 /* Verify edge count and frequency. */
1838 bool verify_count ();
1840 /* Return true when call of edge cannot lead to return from caller
1841 and thus it is safe to ignore its side effects for IPA analysis
1842 when computing side effects of the caller. */
1843 bool cannot_lead_to_return_p (void);
1845 /* Return true when the edge represents a direct recursion. */
1846 bool recursive_p (void);
1848 /* Return true if the edge may be considered hot. */
1849 bool maybe_hot_p (void);
1851 /* Get unique identifier of the edge. */
1852 inline int get_uid ()
1854 return m_uid;
1857 /* Get summary id of the edge. */
1858 inline int get_summary_id ()
1860 return m_summary_id;
1863 /* Rebuild cgraph edges for current function node. This needs to be run after
1864 passes that don't update the cgraph. */
1865 static unsigned int rebuild_edges (void);
1867 /* Rebuild cgraph references for current function node. This needs to be run
1868 after passes that don't update the cgraph. */
1869 static void rebuild_references (void);
1871 /* During LTO stream in this can be used to check whether call can possibly
1872 be internal to the current translation unit. */
1873 bool possibly_call_in_translation_unit_p (void);
1875 /* Return num_speculative_targets of this edge. */
1876 int num_speculative_call_targets_p (void);
1878 /* Expected number of executions: calculated in profile.c. */
1879 profile_count count;
1880 cgraph_node *caller;
1881 cgraph_node *callee;
1882 cgraph_edge *prev_caller;
1883 cgraph_edge *next_caller;
1884 cgraph_edge *prev_callee;
1885 cgraph_edge *next_callee;
1886 gcall *call_stmt;
1887 /* Additional information about an indirect call. Not cleared when an edge
1888 becomes direct. */
1889 cgraph_indirect_call_info *indirect_info;
1890 PTR GTY ((skip (""))) aux;
1891 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1892 explanation why function was not inlined. */
1893 enum cgraph_inline_failed_t inline_failed;
1894 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1895 when the function is serialized in. */
1896 unsigned int lto_stmt_uid;
1897 /* speculative id is used to link direct calls with their corresponding
1898 IPA_REF_ADDR references when representing speculative calls. */
1899 unsigned int speculative_id : 16;
1900 /* Whether this edge was made direct by indirect inlining. */
1901 unsigned int indirect_inlining_edge : 1;
1902 /* Whether this edge describes an indirect call with an undetermined
1903 callee. */
1904 unsigned int indirect_unknown_callee : 1;
1905 /* Whether this edge is still a dangling */
1906 /* True if the corresponding CALL stmt cannot be inlined. */
1907 unsigned int call_stmt_cannot_inline_p : 1;
1908 /* Can this call throw externally? */
1909 unsigned int can_throw_external : 1;
1910 /* Edges with SPECULATIVE flag represents indirect calls that was
1911 speculatively turned into direct (i.e. by profile feedback).
1912 The final code sequence will have form:
1914 if (call_target == expected_fn)
1915 expected_fn ();
1916 else
1917 call_target ();
1919 Every speculative call is represented by three components attached
1920 to a same call statement:
1921 1) a direct call (to expected_fn)
1922 2) an indirect call (to call_target)
1923 3) a IPA_REF_ADDR reference to expected_fn.
1925 Optimizers may later redirect direct call to clone, so 1) and 3)
1926 do not need to necessarily agree with destination. */
1927 unsigned int speculative : 1;
1928 /* Set to true when caller is a constructor or destructor of polymorphic
1929 type. */
1930 unsigned in_polymorphic_cdtor : 1;
1932 /* Return true if call must bind to current definition. */
1933 bool binds_to_current_def_p ();
1935 /* Expected frequency of executions within the function.
1936 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1937 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1938 int frequency ();
1940 /* Expected frequency of executions within the function. */
1941 sreal sreal_frequency ();
1942 private:
1943 /* Unique id of the edge. */
1944 int m_uid;
1946 /* Summary id that is recycled. */
1947 int m_summary_id;
1949 /* Remove the edge from the list of the callers of the callee. */
1950 void remove_caller (void);
1952 /* Remove the edge from the list of the callees of the caller. */
1953 void remove_callee (void);
1955 /* Set callee N of call graph edge and add it to the corresponding set of
1956 callers. */
1957 void set_callee (cgraph_node *n);
1959 /* Output flags of edge to a file F. */
1960 void dump_edge_flags (FILE *f);
1962 /* Dump edge to stderr. */
1963 void DEBUG_FUNCTION debug (void);
1965 /* Verify that call graph edge corresponds to DECL from the associated
1966 statement. Return true if the verification should fail. */
1967 bool verify_corresponds_to_fndecl (tree decl);
1970 #define CGRAPH_FREQ_BASE 1000
1971 #define CGRAPH_FREQ_MAX 100000
1973 /* The varpool data structure.
1974 Each static variable decl has assigned varpool_node. */
1976 struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node
1978 /* Constructor. */
1979 explicit varpool_node ()
1980 : symtab_node (SYMTAB_VARIABLE), output (0), dynamically_initialized (0),
1981 tls_model (TLS_MODEL_NONE), used_by_single_function (0)
1984 /* Dump given varpool node to F. */
1985 void dump (FILE *f);
1987 /* Dump given varpool node to stderr. */
1988 void DEBUG_FUNCTION debug (void);
1990 /* Remove variable from symbol table. */
1991 void remove (void);
1993 /* Remove node initializer when it is no longer needed. */
1994 void remove_initializer (void);
1996 void analyze (void);
1998 /* Return variable availability. */
1999 availability get_availability (symtab_node *ref = NULL);
2001 /* When doing LTO, read variable's constructor from disk if
2002 it is not already present. */
2003 tree get_constructor (void);
2005 /* Return true if variable has constructor that can be used for folding. */
2006 bool ctor_useable_for_folding_p (void);
2008 /* For given variable pool node, walk the alias chain to return the function
2009 the variable is alias of. Do not walk through thunks.
2010 When AVAILABILITY is non-NULL, get minimal availability in the chain.
2011 When REF is non-NULL, assume that reference happens in symbol REF
2012 when determining the availability. */
2013 inline varpool_node *ultimate_alias_target
2014 (availability *availability = NULL, symtab_node *ref = NULL);
2016 /* Return node that alias is aliasing. */
2017 inline varpool_node *get_alias_target (void);
2019 /* Output one variable, if necessary. Return whether we output it. */
2020 bool assemble_decl (void);
2022 /* For variables in named sections make sure get_variable_section
2023 is called before we switch to those sections. Then section
2024 conflicts between read-only and read-only requiring relocations
2025 sections can be resolved. */
2026 void finalize_named_section_flags (void);
2028 /* Call callback on varpool symbol and aliases associated to varpool symbol.
2029 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2030 skipped. */
2031 bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
2032 void *data,
2033 bool include_overwritable);
2035 /* Return true when variable should be considered externally visible. */
2036 bool externally_visible_p (void);
2038 /* Return true when all references to variable must be visible
2039 in ipa_ref_list.
2040 i.e. if the variable is not externally visible or not used in some magic
2041 way (asm statement or such).
2042 The magic uses are all summarized in force_output flag. */
2043 inline bool all_refs_explicit_p ();
2045 /* Return true when variable can be removed from variable pool
2046 if all direct calls are eliminated. */
2047 inline bool can_remove_if_no_refs_p (void);
2049 /* Add the variable DECL to the varpool.
2050 Unlike finalize_decl function is intended to be used
2051 by middle end and allows insertion of new variable at arbitrary point
2052 of compilation. */
2053 static void add (tree decl);
2055 /* Return varpool node for given symbol and check it is a function. */
2056 static inline varpool_node *get (const_tree decl);
2058 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
2059 the middle end to output the variable to asm file, if needed or externally
2060 visible. */
2061 static void finalize_decl (tree decl);
2063 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
2064 Extra name aliases are output whenever DECL is output. */
2065 static varpool_node * create_extra_name_alias (tree alias, tree decl);
2067 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
2068 Extra name aliases are output whenever DECL is output. */
2069 static varpool_node * create_alias (tree, tree);
2071 /* Dump the variable pool to F. */
2072 static void dump_varpool (FILE *f);
2074 /* Dump the variable pool to stderr. */
2075 static void DEBUG_FUNCTION debug_varpool (void);
2077 /* Allocate new callgraph node and insert it into basic data structures. */
2078 static varpool_node *create_empty (void);
2080 /* Return varpool node assigned to DECL. Create new one when needed. */
2081 static varpool_node *get_create (tree decl);
2083 /* Given an assembler name, lookup node. */
2084 static varpool_node *get_for_asmname (tree asmname);
2086 /* Set when variable is scheduled to be assembled. */
2087 unsigned output : 1;
2089 /* Set if the variable is dynamically initialized, except for
2090 function local statics. */
2091 unsigned dynamically_initialized : 1;
2093 ENUM_BITFIELD(tls_model) tls_model : 3;
2095 /* Set if the variable is known to be used by single function only.
2096 This is computed by ipa_single_use pass and used by late optimizations
2097 in places where optimization would be valid for local static variable
2098 if we did not do any inter-procedural code movement. */
2099 unsigned used_by_single_function : 1;
2101 private:
2102 /* Assemble thunks and aliases associated to varpool node. */
2103 void assemble_aliases (void);
2105 /* Worker for call_for_node_and_aliases. */
2106 bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
2107 void *data,
2108 bool include_overwritable);
2111 /* Every top level asm statement is put into a asm_node. */
2113 struct GTY(()) asm_node {
2114 /* Next asm node. */
2115 asm_node *next;
2116 /* String for this asm node. */
2117 tree asm_str;
2118 /* Ordering of all cgraph nodes. */
2119 int order;
2122 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
2124 template <>
2125 template <>
2126 inline bool
2127 is_a_helper <cgraph_node *>::test (symtab_node *p)
2129 return p && p->type == SYMTAB_FUNCTION;
2132 /* Report whether or not THIS symtab node is a variable, aka varpool_node. */
2134 template <>
2135 template <>
2136 inline bool
2137 is_a_helper <varpool_node *>::test (symtab_node *p)
2139 return p && p->type == SYMTAB_VARIABLE;
2142 typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
2143 typedef void (*cgraph_node_hook)(cgraph_node *, void *);
2144 typedef void (*varpool_node_hook)(varpool_node *, void *);
2145 typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
2146 typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
2148 struct cgraph_edge_hook_list;
2149 struct cgraph_node_hook_list;
2150 struct varpool_node_hook_list;
2151 struct cgraph_2edge_hook_list;
2152 struct cgraph_2node_hook_list;
2154 /* Map from a symbol to initialization/finalization priorities. */
2155 struct GTY(()) symbol_priority_map {
2156 priority_type init;
2157 priority_type fini;
2160 enum symtab_state
2162 /* Frontend is parsing and finalizing functions. */
2163 PARSING,
2164 /* Callgraph is being constructed. It is safe to add new functions. */
2165 CONSTRUCTION,
2166 /* Callgraph is being streamed-in at LTO time. */
2167 LTO_STREAMING,
2168 /* Callgraph is built and early IPA passes are being run. */
2169 IPA,
2170 /* Callgraph is built and all functions are transformed to SSA form. */
2171 IPA_SSA,
2172 /* All inline decisions are done; it is now possible to remove extern inline
2173 functions and virtual call targets. */
2174 IPA_SSA_AFTER_INLINING,
2175 /* Functions are now ordered and being passed to RTL expanders. */
2176 EXPANSION,
2177 /* All cgraph expansion is done. */
2178 FINISHED
2181 struct asmname_hasher : ggc_ptr_hash <symtab_node>
2183 typedef const_tree compare_type;
2185 static hashval_t hash (symtab_node *n);
2186 static bool equal (symtab_node *n, const_tree t);
2189 /* Core summaries maintained about symbols. */
2191 struct thunk_info;
2192 template <class T> class function_summary;
2193 typedef function_summary <thunk_info *> thunk_summary;
2195 struct clone_info;
2196 template <class T> class function_summary;
2197 typedef function_summary <clone_info *> clone_summary;
2199 class GTY((tag ("SYMTAB"))) symbol_table
2201 public:
2202 friend struct symtab_node;
2203 friend struct cgraph_node;
2204 friend struct cgraph_edge;
2206 symbol_table ():
2207 cgraph_count (0), cgraph_max_uid (1), cgraph_max_summary_id (0),
2208 edges_count (0), edges_max_uid (1), edges_max_summary_id (0),
2209 cgraph_released_summary_ids (), edge_released_summary_ids (),
2210 nodes (NULL), asmnodes (NULL), asm_last_node (NULL),
2211 order (0), max_unit (0), global_info_ready (false), state (PARSING),
2212 function_flags_ready (false), cpp_implicit_aliases_done (false),
2213 section_hash (NULL), assembler_name_hash (NULL), init_priority_hash (NULL),
2214 dump_file (NULL), ipa_clones_dump_file (NULL), cloned_nodes (),
2215 m_thunks (NULL), m_clones (NULL),
2216 m_first_edge_removal_hook (NULL), m_first_cgraph_removal_hook (NULL),
2217 m_first_edge_duplicated_hook (NULL), m_first_cgraph_duplicated_hook (NULL),
2218 m_first_cgraph_insertion_hook (NULL), m_first_varpool_insertion_hook (NULL),
2219 m_first_varpool_removal_hook (NULL)
2223 /* Initialize callgraph dump file. */
2224 void initialize (void);
2226 /* Register a top-level asm statement ASM_STR. */
2227 inline asm_node *finalize_toplevel_asm (tree asm_str);
2229 /* Analyze the whole compilation unit once it is parsed completely. */
2230 void finalize_compilation_unit (void);
2232 /* C++ frontend produce same body aliases all over the place, even before PCH
2233 gets streamed out. It relies on us linking the aliases with their function
2234 in order to do the fixups, but ipa-ref is not PCH safe. Consequently we
2235 first produce aliases without links, but once C++ FE is sure it won't
2236 stream PCH we build the links via this function. */
2237 void process_same_body_aliases (void);
2239 /* Perform simple optimizations based on callgraph. */
2240 void compile (void);
2242 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2243 functions into callgraph in a way so they look like ordinary reachable
2244 functions inserted into callgraph already at construction time. */
2245 void process_new_functions (void);
2247 /* Register a symbol NODE. */
2248 inline void register_symbol (symtab_node *node);
2250 inline void
2251 clear_asm_symbols (void)
2253 asmnodes = NULL;
2254 asm_last_node = NULL;
2257 /* Perform reachability analysis and reclaim all unreachable nodes. */
2258 bool remove_unreachable_nodes (FILE *file);
2260 /* Optimization of function bodies might've rendered some variables as
2261 unnecessary so we want to avoid these from being compiled. Re-do
2262 reachability starting from variables that are either externally visible
2263 or was referred from the asm output routines. */
2264 void remove_unreferenced_decls (void);
2266 /* Unregister a symbol NODE. */
2267 inline void unregister (symtab_node *node);
2269 /* Allocate new callgraph node and insert it into basic data structures. */
2270 cgraph_node *create_empty (void);
2272 /* Release a callgraph NODE. */
2273 void release_symbol (cgraph_node *node);
2275 /* Output all variables enqueued to be assembled. */
2276 bool output_variables (void);
2278 /* Weakrefs may be associated to external decls and thus not output
2279 at expansion time. Emit all necessary aliases. */
2280 void output_weakrefs (void);
2282 /* Return first static symbol with definition. */
2283 inline symtab_node *first_symbol (void);
2285 /* Return first assembler symbol. */
2286 inline asm_node *
2287 first_asm_symbol (void)
2289 return asmnodes;
2292 /* Return first static symbol with definition. */
2293 inline symtab_node *first_defined_symbol (void);
2295 /* Return first variable. */
2296 inline varpool_node *first_variable (void);
2298 /* Return next variable after NODE. */
2299 inline varpool_node *next_variable (varpool_node *node);
2301 /* Return first static variable with initializer. */
2302 inline varpool_node *first_static_initializer (void);
2304 /* Return next static variable with initializer after NODE. */
2305 inline varpool_node *next_static_initializer (varpool_node *node);
2307 /* Return first static variable with definition. */
2308 inline varpool_node *first_defined_variable (void);
2310 /* Return next static variable with definition after NODE. */
2311 inline varpool_node *next_defined_variable (varpool_node *node);
2313 /* Return first function with body defined. */
2314 inline cgraph_node *first_defined_function (void);
2316 /* Return next function with body defined after NODE. */
2317 inline cgraph_node *next_defined_function (cgraph_node *node);
2319 /* Return first function. */
2320 inline cgraph_node *first_function (void);
2322 /* Return next function. */
2323 inline cgraph_node *next_function (cgraph_node *node);
2325 /* Return first function with body defined. */
2326 cgraph_node *first_function_with_gimple_body (void);
2328 /* Return next reachable static variable with initializer after NODE. */
2329 inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
2331 /* Register HOOK to be called with DATA on each removed edge. */
2332 cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
2333 void *data);
2335 /* Remove ENTRY from the list of hooks called on removing edges. */
2336 void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
2338 /* Register HOOK to be called with DATA on each removed node. */
2339 cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
2340 void *data);
2342 /* Remove ENTRY from the list of hooks called on removing nodes. */
2343 void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
2345 /* Register HOOK to be called with DATA on each removed node. */
2346 varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
2347 void *data);
2349 /* Remove ENTRY from the list of hooks called on removing nodes. */
2350 void remove_varpool_removal_hook (varpool_node_hook_list *entry);
2352 /* Register HOOK to be called with DATA on each inserted node. */
2353 cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
2354 void *data);
2356 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2357 void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
2359 /* Register HOOK to be called with DATA on each inserted node. */
2360 varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
2361 void *data);
2363 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2364 void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
2366 /* Register HOOK to be called with DATA on each duplicated edge. */
2367 cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
2368 void *data);
2369 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2370 void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
2372 /* Register HOOK to be called with DATA on each duplicated node. */
2373 cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
2374 void *data);
2376 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2377 void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
2379 /* Call all edge removal hooks. */
2380 void call_edge_removal_hooks (cgraph_edge *e);
2382 /* Call all node insertion hooks. */
2383 void call_cgraph_insertion_hooks (cgraph_node *node);
2385 /* Call all node removal hooks. */
2386 void call_cgraph_removal_hooks (cgraph_node *node);
2388 /* Call all node duplication hooks. */
2389 void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
2391 /* Call all edge duplication hooks. */
2392 void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
2394 /* Call all node removal hooks. */
2395 void call_varpool_removal_hooks (varpool_node *node);
2397 /* Call all node insertion hooks. */
2398 void call_varpool_insertion_hooks (varpool_node *node);
2400 /* Arrange node to be first in its entry of assembler_name_hash. */
2401 void symtab_prevail_in_asm_name_hash (symtab_node *node);
2403 /* Initialize asm name hash unless. */
2404 void symtab_initialize_asm_name_hash (void);
2406 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2407 void change_decl_assembler_name (tree decl, tree name);
2409 /* Dump symbol table to F. */
2410 void dump (FILE *f);
2412 /* Dump symbol table to F in graphviz format. */
2413 void dump_graphviz (FILE *f);
2415 /* Dump symbol table to stderr. */
2416 void DEBUG_FUNCTION debug (void);
2418 /* Assign a new summary ID for the callgraph NODE. */
2419 inline int assign_summary_id (cgraph_node *node)
2421 if (!cgraph_released_summary_ids.is_empty ())
2422 node->m_summary_id = cgraph_released_summary_ids.pop ();
2423 else
2424 node->m_summary_id = cgraph_max_summary_id++;
2426 return node->m_summary_id;
2429 /* Assign a new summary ID for the callgraph EDGE. */
2430 inline int assign_summary_id (cgraph_edge *edge)
2432 if (!edge_released_summary_ids.is_empty ())
2433 edge->m_summary_id = edge_released_summary_ids.pop ();
2434 else
2435 edge->m_summary_id = edges_max_summary_id++;
2437 return edge->m_summary_id;
2440 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2441 name. */
2442 static bool assembler_names_equal_p (const char *name1, const char *name2);
2444 int cgraph_count;
2445 int cgraph_max_uid;
2446 int cgraph_max_summary_id;
2448 int edges_count;
2449 int edges_max_uid;
2450 int edges_max_summary_id;
2452 /* Vector of released summary IDS for cgraph nodes. */
2453 vec<int> GTY ((skip)) cgraph_released_summary_ids;
2455 /* Vector of released summary IDS for cgraph nodes. */
2456 vec<int> GTY ((skip)) edge_released_summary_ids;
2458 /* Return symbol used to separate symbol name from suffix. */
2459 static char symbol_suffix_separator ();
2461 symtab_node* GTY(()) nodes;
2462 asm_node* GTY(()) asmnodes;
2463 asm_node* GTY(()) asm_last_node;
2465 /* The order index of the next symtab node to be created. This is
2466 used so that we can sort the cgraph nodes in order by when we saw
2467 them, to support -fno-toplevel-reorder. */
2468 int order;
2470 /* Maximal unit ID used. */
2471 int max_unit;
2473 /* Set when whole unit has been analyzed so we can access global info. */
2474 bool global_info_ready;
2475 /* What state callgraph is in right now. */
2476 enum symtab_state state;
2477 /* Set when the cgraph is fully build and the basic flags are computed. */
2478 bool function_flags_ready;
2480 bool cpp_implicit_aliases_done;
2482 /* Hash table used to hold sections. */
2483 hash_table<section_name_hasher> *GTY(()) section_hash;
2485 /* Hash table used to convert assembler names into nodes. */
2486 hash_table<asmname_hasher> *assembler_name_hash;
2488 /* Hash table used to hold init priorities. */
2489 hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
2491 FILE* GTY ((skip)) dump_file;
2493 FILE* GTY ((skip)) ipa_clones_dump_file;
2495 hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;
2497 /* Thunk annotations. */
2498 thunk_summary *m_thunks;
2500 /* Virtual clone annotations. */
2501 clone_summary *m_clones;
2503 private:
2504 /* Allocate a cgraph_edge structure and fill it with data according to the
2505 parameters of which only CALLEE can be NULL (when creating an indirect
2506 call edge). CLONING_P should be set if properties that are copied from an
2507 original edge should not be calculated. */
2508 cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
2509 gcall *call_stmt, profile_count count,
2510 bool indir_unknown_callee, bool cloning_p);
2512 /* Put the edge onto the free list. */
2513 void free_edge (cgraph_edge *e);
2515 /* Insert NODE to assembler name hash. */
2516 void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
2518 /* Remove NODE from assembler name hash. */
2519 void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
2521 /* Hash asmnames ignoring the user specified marks. */
2522 static hashval_t decl_assembler_name_hash (const_tree asmname);
2524 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2525 static bool decl_assembler_name_equal (tree decl, const_tree asmname);
2527 friend struct asmname_hasher;
2529 /* List of hooks triggered when an edge is removed. */
2530 cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
2531 /* List of hooks trigger_red when a cgraph node is removed. */
2532 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
2533 /* List of hooks triggered when an edge is duplicated. */
2534 cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
2535 /* List of hooks triggered when a node is duplicated. */
2536 cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
2537 /* List of hooks triggered when an function is inserted. */
2538 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
2539 /* List of hooks triggered when an variable is inserted. */
2540 varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
2541 /* List of hooks triggered when a node is removed. */
2542 varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
2545 extern GTY(()) symbol_table *symtab;
2547 extern vec<cgraph_node *> cgraph_new_nodes;
2549 inline hashval_t
2550 asmname_hasher::hash (symtab_node *n)
2552 return symbol_table::decl_assembler_name_hash
2553 (DECL_ASSEMBLER_NAME (n->decl));
2556 inline bool
2557 asmname_hasher::equal (symtab_node *n, const_tree t)
2559 return symbol_table::decl_assembler_name_equal (n->decl, t);
2562 /* In cgraph.c */
2563 void cgraph_c_finalize (void);
2564 void release_function_body (tree);
2565 cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
2567 void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
2568 bool cgraph_function_possibly_inlined_p (tree);
2570 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
2571 cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
2573 /* In cgraphunit.c */
2574 void cgraphunit_c_finalize (void);
2575 int tp_first_run_node_cmp (const void *pa, const void *pb);
2577 /* In symtab-thunks.cc */
2578 void symtab_thunks_cc_finalize (void);
2580 /* Initialize datastructures so DECL is a function in lowered gimple form.
2581 IN_SSA is true if the gimple is in SSA. */
2582 basic_block init_lowered_empty_function (tree, bool, profile_count);
2584 tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree,
2585 HOST_WIDE_INT);
2586 /* In cgraphclones.c */
2588 tree clone_function_name_numbered (const char *name, const char *suffix);
2589 tree clone_function_name_numbered (tree decl, const char *suffix);
2590 tree clone_function_name (const char *name, const char *suffix,
2591 unsigned long number);
2592 tree clone_function_name (tree decl, const char *suffix,
2593 unsigned long number);
2594 tree clone_function_name (tree decl, const char *suffix);
2596 void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
2597 ipa_param_adjustments *,
2598 bool, bitmap, basic_block);
2600 void dump_callgraph_transformation (const cgraph_node *original,
2601 const cgraph_node *clone,
2602 const char *suffix);
2603 /* In cgraphbuild.c */
2604 int compute_call_stmt_bb_frequency (tree, basic_block bb);
2605 void record_references_in_initializer (tree, bool);
2607 /* In ipa.c */
2608 void cgraph_build_static_cdtor (char which, tree body, int priority);
2609 bool ipa_discover_variable_flags (void);
2611 /* In varpool.c */
2612 tree ctor_for_folding (tree);
2614 /* In ipa-inline-analysis.c */
2615 void initialize_inline_failed (struct cgraph_edge *);
2616 bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);
2618 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2619 or abstract function kept for debug info purposes only. */
2620 inline bool
2621 symtab_node::real_symbol_p (void)
2623 cgraph_node *cnode;
2625 if (DECL_ABSTRACT_P (decl))
2626 return false;
2627 if (transparent_alias && definition)
2628 return false;
2629 if (!is_a <cgraph_node *> (this))
2630 return true;
2631 cnode = dyn_cast <cgraph_node *> (this);
2632 if (cnode->inlined_to)
2633 return false;
2634 return true;
2637 /* Return true if DECL should have entry in symbol table if used.
2638 Those are functions and static & external variables. */
2640 static inline bool
2641 decl_in_symtab_p (const_tree decl)
2643 return (TREE_CODE (decl) == FUNCTION_DECL
2644 || (TREE_CODE (decl) == VAR_DECL
2645 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
2648 inline bool
2649 symtab_node::in_same_comdat_group_p (symtab_node *target)
2651 symtab_node *source = this;
2653 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2655 if (cn->inlined_to)
2656 source = cn->inlined_to;
2658 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2660 if (cn->inlined_to)
2661 target = cn->inlined_to;
2664 return source->get_comdat_group () == target->get_comdat_group ();
2667 /* Return node that alias is aliasing. */
2669 inline symtab_node *
2670 symtab_node::get_alias_target (void)
2672 ipa_ref *ref = NULL;
2673 iterate_reference (0, ref);
2674 gcc_checking_assert (ref->use == IPA_REF_ALIAS);
2675 return ref->referred;
2678 /* Return the DECL (or identifier) that alias is aliasing. Unlike the above,
2679 this works whether or not the alias has been analyzed already. */
2681 inline tree
2682 symtab_node::get_alias_target_tree ()
2684 if (alias_target)
2685 return alias_target;
2686 return get_alias_target ()->decl;
2689 /* Return next reachable static symbol with initializer after the node. */
2691 inline symtab_node *
2692 symtab_node::next_defined_symbol (void)
2694 symtab_node *node1 = next;
2696 for (; node1; node1 = node1->next)
2697 if (node1->definition)
2698 return node1;
2700 return NULL;
2703 /* Iterates I-th reference in the list, REF is also set. */
2705 inline ipa_ref *
2706 symtab_node::iterate_reference (unsigned i, ipa_ref *&ref)
2708 ref_list.references.iterate (i, &ref);
2710 return ref;
2713 /* Iterates I-th referring item in the list, REF is also set. */
2715 inline ipa_ref *
2716 symtab_node::iterate_referring (unsigned i, ipa_ref *&ref)
2718 ref_list.referring.iterate (i, &ref);
2720 return ref;
2723 /* Iterates I-th referring alias item in the list, REF is also set. */
2725 inline ipa_ref *
2726 symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref)
2728 ref_list.referring.iterate (i, &ref);
2730 if (ref && ref->use != IPA_REF_ALIAS)
2731 return NULL;
2733 return ref;
2736 /* Return true if list contains an alias. */
2738 inline bool
2739 symtab_node::has_aliases_p (void)
2741 ipa_ref *ref = NULL;
2743 return (iterate_direct_aliases (0, ref) != NULL);
2746 /* Return true when RESOLUTION indicate that linker will use
2747 the symbol from non-LTO object files. */
2749 inline bool
2750 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2752 return (resolution == LDPR_PREVAILING_DEF
2753 || resolution == LDPR_PREEMPTED_REG
2754 || resolution == LDPR_RESOLVED_EXEC
2755 || resolution == LDPR_RESOLVED_DYN);
2758 /* Return true when symtab_node is known to be used from other (non-LTO)
2759 object file. Known only when doing LTO via linker plugin. */
2761 inline bool
2762 symtab_node::used_from_object_file_p (void)
2764 if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
2765 return false;
2766 if (resolution_used_from_other_file_p (resolution))
2767 return true;
2768 return false;
2771 /* Return varpool node for given symbol and check it is a function. */
2773 inline varpool_node *
2774 varpool_node::get (const_tree decl)
2776 gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
2777 return dyn_cast<varpool_node *> (symtab_node::get (decl));
2780 /* Register a symbol NODE. */
2782 inline void
2783 symbol_table::register_symbol (symtab_node *node)
2785 node->next = nodes;
2786 node->previous = NULL;
2788 if (nodes)
2789 nodes->previous = node;
2790 nodes = node;
2792 node->order = order++;
2795 /* Register a top-level asm statement ASM_STR. */
2797 asm_node *
2798 symbol_table::finalize_toplevel_asm (tree asm_str)
2800 asm_node *node;
2802 node = ggc_cleared_alloc<asm_node> ();
2803 node->asm_str = asm_str;
2804 node->order = order++;
2805 node->next = NULL;
2807 if (asmnodes == NULL)
2808 asmnodes = node;
2809 else
2810 asm_last_node->next = node;
2812 asm_last_node = node;
2813 return node;
2816 /* Unregister a symbol NODE. */
2817 inline void
2818 symbol_table::unregister (symtab_node *node)
2820 if (node->previous)
2821 node->previous->next = node->next;
2822 else
2823 nodes = node->next;
2825 if (node->next)
2826 node->next->previous = node->previous;
2828 node->next = NULL;
2829 node->previous = NULL;
2832 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2834 inline void
2835 symbol_table::release_symbol (cgraph_node *node)
2837 cgraph_count--;
2838 if (node->m_summary_id != -1)
2839 cgraph_released_summary_ids.safe_push (node->m_summary_id);
2840 ggc_free (node);
2843 /* Return first static symbol with definition. */
2844 inline symtab_node *
2845 symbol_table::first_symbol (void)
2847 return nodes;
2850 /* Walk all symbols. */
2851 #define FOR_EACH_SYMBOL(node) \
2852 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2854 /* Return first static symbol with definition. */
2855 inline symtab_node *
2856 symbol_table::first_defined_symbol (void)
2858 symtab_node *node;
2860 for (node = nodes; node; node = node->next)
2861 if (node->definition)
2862 return node;
2864 return NULL;
2867 /* Walk all symbols with definitions in current unit. */
2868 #define FOR_EACH_DEFINED_SYMBOL(node) \
2869 for ((node) = symtab->first_defined_symbol (); (node); \
2870 (node) = node->next_defined_symbol ())
2872 /* Return first variable. */
2873 inline varpool_node *
2874 symbol_table::first_variable (void)
2876 symtab_node *node;
2877 for (node = nodes; node; node = node->next)
2878 if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
2879 return vnode;
2880 return NULL;
2883 /* Return next variable after NODE. */
2884 inline varpool_node *
2885 symbol_table::next_variable (varpool_node *node)
2887 symtab_node *node1 = node->next;
2888 for (; node1; node1 = node1->next)
2889 if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
2890 return vnode1;
2891 return NULL;
2893 /* Walk all variables. */
2894 #define FOR_EACH_VARIABLE(node) \
2895 for ((node) = symtab->first_variable (); \
2896 (node); \
2897 (node) = symtab->next_variable ((node)))
2899 /* Return first static variable with initializer. */
2900 inline varpool_node *
2901 symbol_table::first_static_initializer (void)
2903 symtab_node *node;
2904 for (node = nodes; node; node = node->next)
2906 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2907 if (vnode && DECL_INITIAL (node->decl))
2908 return vnode;
2910 return NULL;
2913 /* Return next static variable with initializer after NODE. */
2914 inline varpool_node *
2915 symbol_table::next_static_initializer (varpool_node *node)
2917 symtab_node *node1 = node->next;
2918 for (; node1; node1 = node1->next)
2920 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2921 if (vnode1 && DECL_INITIAL (node1->decl))
2922 return vnode1;
2924 return NULL;
2927 /* Walk all static variables with initializer set. */
2928 #define FOR_EACH_STATIC_INITIALIZER(node) \
2929 for ((node) = symtab->first_static_initializer (); (node); \
2930 (node) = symtab->next_static_initializer (node))
2932 /* Return first static variable with definition. */
2933 inline varpool_node *
2934 symbol_table::first_defined_variable (void)
2936 symtab_node *node;
2937 for (node = nodes; node; node = node->next)
2939 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2940 if (vnode && vnode->definition)
2941 return vnode;
2943 return NULL;
2946 /* Return next static variable with definition after NODE. */
2947 inline varpool_node *
2948 symbol_table::next_defined_variable (varpool_node *node)
2950 symtab_node *node1 = node->next;
2951 for (; node1; node1 = node1->next)
2953 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2954 if (vnode1 && vnode1->definition)
2955 return vnode1;
2957 return NULL;
2959 /* Walk all variables with definitions in current unit. */
2960 #define FOR_EACH_DEFINED_VARIABLE(node) \
2961 for ((node) = symtab->first_defined_variable (); (node); \
2962 (node) = symtab->next_defined_variable (node))
2964 /* Return first function with body defined. */
2965 inline cgraph_node *
2966 symbol_table::first_defined_function (void)
2968 symtab_node *node;
2969 for (node = nodes; node; node = node->next)
2971 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2972 if (cn && cn->definition)
2973 return cn;
2975 return NULL;
2978 /* Return next function with body defined after NODE. */
2979 inline cgraph_node *
2980 symbol_table::next_defined_function (cgraph_node *node)
2982 symtab_node *node1 = node->next;
2983 for (; node1; node1 = node1->next)
2985 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2986 if (cn1 && cn1->definition)
2987 return cn1;
2989 return NULL;
2992 /* Walk all functions with body defined. */
2993 #define FOR_EACH_DEFINED_FUNCTION(node) \
2994 for ((node) = symtab->first_defined_function (); (node); \
2995 (node) = symtab->next_defined_function ((node)))
2997 /* Return first function. */
2998 inline cgraph_node *
2999 symbol_table::first_function (void)
3001 symtab_node *node;
3002 for (node = nodes; node; node = node->next)
3003 if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
3004 return cn;
3005 return NULL;
3008 /* Return next function. */
3009 inline cgraph_node *
3010 symbol_table::next_function (cgraph_node *node)
3012 symtab_node *node1 = node->next;
3013 for (; node1; node1 = node1->next)
3014 if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
3015 return cn1;
3016 return NULL;
3019 /* Return first function with body defined. */
3020 inline cgraph_node *
3021 symbol_table::first_function_with_gimple_body (void)
3023 symtab_node *node;
3024 for (node = nodes; node; node = node->next)
3026 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
3027 if (cn && cn->has_gimple_body_p ())
3028 return cn;
3030 return NULL;
3033 /* Return next reachable static variable with initializer after NODE. */
3034 inline cgraph_node *
3035 symbol_table::next_function_with_gimple_body (cgraph_node *node)
3037 symtab_node *node1 = node->next;
3038 for (; node1; node1 = node1->next)
3040 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
3041 if (cn1 && cn1->has_gimple_body_p ())
3042 return cn1;
3044 return NULL;
3047 /* Walk all functions. */
3048 #define FOR_EACH_FUNCTION(node) \
3049 for ((node) = symtab->first_function (); (node); \
3050 (node) = symtab->next_function ((node)))
3052 /* Return true when callgraph node is a function with Gimple body defined
3053 in current unit. Functions can also be define externally or they
3054 can be thunks with no Gimple representation.
3056 Note that at WPA stage, the function body may not be present in memory. */
3058 inline bool
3059 cgraph_node::has_gimple_body_p (void)
3061 return definition && !thunk && !alias;
3064 /* Walk all functions with body defined. */
3065 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
3066 for ((node) = symtab->first_function_with_gimple_body (); (node); \
3067 (node) = symtab->next_function_with_gimple_body (node))
3069 /* Uniquize all constants that appear in memory.
3070 Each constant in memory thus far output is recorded
3071 in `const_desc_table'. */
3073 struct GTY((for_user)) constant_descriptor_tree {
3074 /* A MEM for the constant. */
3075 rtx rtl;
3077 /* The value of the constant. */
3078 tree value;
3080 /* Hash of value. Computing the hash from value each time
3081 hashfn is called can't work properly, as that means recursive
3082 use of the hash table during hash table expansion. */
3083 hashval_t hash;
3086 /* Return true when function is only called directly or it has alias.
3087 i.e. it is not externally visible, address was not taken and
3088 it is not used in any other non-standard way. */
3090 inline bool
3091 cgraph_node::only_called_directly_or_aliased_p (void)
3093 gcc_assert (!inlined_to);
3094 return (!force_output && !address_taken
3095 && !ifunc_resolver
3096 && !used_from_other_partition
3097 && !DECL_VIRTUAL_P (decl)
3098 && !DECL_STATIC_CONSTRUCTOR (decl)
3099 && !DECL_STATIC_DESTRUCTOR (decl)
3100 && !used_from_object_file_p ()
3101 && !externally_visible);
3104 /* Return true when function can be removed from callgraph
3105 if all direct calls are eliminated. */
3107 inline bool
3108 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
3110 gcc_checking_assert (!inlined_to);
3111 /* Extern inlines can always go, we will use the external definition. */
3112 if (DECL_EXTERNAL (decl))
3113 return true;
3114 /* When function is needed, we cannot remove it. */
3115 if (force_output || used_from_other_partition)
3116 return false;
3117 if (DECL_STATIC_CONSTRUCTOR (decl)
3118 || DECL_STATIC_DESTRUCTOR (decl))
3119 return false;
3120 /* Only COMDAT functions can be removed if externally visible. */
3121 if (externally_visible
3122 && ((!DECL_COMDAT (decl) || ifunc_resolver)
3123 || forced_by_abi
3124 || used_from_object_file_p ()))
3125 return false;
3126 return true;
3129 /* Verify cgraph, if consistency checking is enabled. */
3131 inline void
3132 cgraph_node::checking_verify_cgraph_nodes (void)
3134 if (flag_checking)
3135 cgraph_node::verify_cgraph_nodes ();
3138 /* Return true when variable can be removed from variable pool
3139 if all direct calls are eliminated. */
3141 inline bool
3142 varpool_node::can_remove_if_no_refs_p (void)
3144 if (DECL_EXTERNAL (decl))
3145 return true;
3146 return (!force_output && !used_from_other_partition
3147 && ((DECL_COMDAT (decl)
3148 && !forced_by_abi
3149 && !used_from_object_file_p ())
3150 || !externally_visible
3151 || DECL_HAS_VALUE_EXPR_P (decl)));
3154 /* Return true when all references to variable must be visible in ipa_ref_list.
3155 i.e. if the variable is not externally visible or not used in some magic
3156 way (asm statement or such).
3157 The magic uses are all summarized in force_output flag. */
3159 inline bool
3160 varpool_node::all_refs_explicit_p ()
3162 return (definition
3163 && !externally_visible
3164 && !used_from_other_partition
3165 && !force_output);
3168 struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
3170 static hashval_t hash (constant_descriptor_tree *);
3171 static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
3174 /* Constant pool accessor function. */
3175 hash_table<tree_descriptor_hasher> *constant_pool_htab (void);
3177 /* Return node that alias is aliasing. */
3179 inline cgraph_node *
3180 cgraph_node::get_alias_target (void)
3182 return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
3185 /* Return node that alias is aliasing. */
3187 inline varpool_node *
3188 varpool_node::get_alias_target (void)
3190 return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
3193 /* Walk the alias chain to return the symbol NODE is alias of.
3194 If NODE is not an alias, return NODE.
3195 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3196 When REF is non-NULL, assume that reference happens in symbol REF
3197 when determining the availability. */
3199 inline symtab_node *
3200 symtab_node::ultimate_alias_target (enum availability *availability,
3201 symtab_node *ref)
3203 if (!alias)
3205 if (availability)
3206 *availability = get_availability (ref);
3207 return this;
3210 return ultimate_alias_target_1 (availability, ref);
3213 /* Given function symbol, walk the alias chain to return the function node
3214 is alias of. Do not walk through thunks.
3215 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3216 When REF is non-NULL, assume that reference happens in symbol REF
3217 when determining the availability. */
3219 inline cgraph_node *
3220 cgraph_node::ultimate_alias_target (enum availability *availability,
3221 symtab_node *ref)
3223 cgraph_node *n = dyn_cast <cgraph_node *>
3224 (symtab_node::ultimate_alias_target (availability, ref));
3225 if (!n && availability)
3226 *availability = AVAIL_NOT_AVAILABLE;
3227 return n;
3230 /* For given variable pool node, walk the alias chain to return the function
3231 the variable is alias of. Do not walk through thunks.
3232 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3233 When REF is non-NULL, assume that reference happens in symbol REF
3234 when determining the availability. */
3236 inline varpool_node *
3237 varpool_node::ultimate_alias_target (availability *availability,
3238 symtab_node *ref)
3240 varpool_node *n = dyn_cast <varpool_node *>
3241 (symtab_node::ultimate_alias_target (availability, ref));
3243 if (!n && availability)
3244 *availability = AVAIL_NOT_AVAILABLE;
3245 return n;
3248 /* Set callee N of call graph edge and add it to the corresponding set of
3249 callers. */
3251 inline void
3252 cgraph_edge::set_callee (cgraph_node *n)
3254 prev_caller = NULL;
3255 if (n->callers)
3256 n->callers->prev_caller = this;
3257 next_caller = n->callers;
3258 n->callers = this;
3259 callee = n;
3262 /* Return true when the edge represents a direct recursion. */
3264 inline bool
3265 cgraph_edge::recursive_p (void)
3267 cgraph_node *c = callee->ultimate_alias_target ();
3268 if (caller->inlined_to)
3269 return caller->inlined_to->decl == c->decl;
3270 else
3271 return caller->decl == c->decl;
3274 /* Remove the edge from the list of the callers of the callee. */
3276 inline void
3277 cgraph_edge::remove_callee (void)
3279 gcc_assert (!indirect_unknown_callee);
3280 if (prev_caller)
3281 prev_caller->next_caller = next_caller;
3282 if (next_caller)
3283 next_caller->prev_caller = prev_caller;
3284 if (!prev_caller)
3285 callee->callers = next_caller;
3288 /* Return true if call must bind to current definition. */
3290 inline bool
3291 cgraph_edge::binds_to_current_def_p ()
3293 if (callee)
3294 return callee->binds_to_current_def_p (caller);
3295 else
3296 return false;
3299 /* Expected frequency of executions within the function.
3300 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
3301 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
3303 inline int
3304 cgraph_edge::frequency ()
3306 return count.to_cgraph_frequency (caller->inlined_to
3307 ? caller->inlined_to->count
3308 : caller->count);
3312 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
3313 static inline bool
3314 decl_is_tm_clone (const_tree fndecl)
3316 cgraph_node *n = cgraph_node::get (fndecl);
3317 if (n)
3318 return n->tm_clone;
3319 return false;
3322 /* Likewise indicate that a node is needed, i.e. reachable via some
3323 external means. */
3325 inline void
3326 cgraph_node::mark_force_output (void)
3328 force_output = 1;
3329 gcc_checking_assert (!inlined_to);
3332 /* Return true if function should be optimized for size. */
3334 inline enum optimize_size_level
3335 cgraph_node::optimize_for_size_p (void)
3337 if (opt_for_fn (decl, optimize_size))
3338 return OPTIMIZE_SIZE_MAX;
3339 if (count == profile_count::zero ())
3340 return OPTIMIZE_SIZE_MAX;
3341 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
3342 return OPTIMIZE_SIZE_BALANCED;
3343 else
3344 return OPTIMIZE_SIZE_NO;
3347 /* Return symtab_node for NODE or create one if it is not present
3348 in symtab. */
3350 inline symtab_node *
3351 symtab_node::get_create (tree node)
3353 if (TREE_CODE (node) == VAR_DECL)
3354 return varpool_node::get_create (node);
3355 else
3356 return cgraph_node::get_create (node);
3359 /* Return availability of NODE when referenced from REF. */
3361 inline enum availability
3362 symtab_node::get_availability (symtab_node *ref)
3364 if (is_a <cgraph_node *> (this))
3365 return dyn_cast <cgraph_node *> (this)->get_availability (ref);
3366 else
3367 return dyn_cast <varpool_node *> (this)->get_availability (ref);
3370 /* Call callback on symtab node and aliases associated to this node.
3371 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3373 inline bool
3374 symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *,
3375 void *),
3376 void *data,
3377 bool include_overwritable)
3379 if (include_overwritable
3380 || get_availability () > AVAIL_INTERPOSABLE)
3382 if (callback (this, data))
3383 return true;
3385 if (has_aliases_p ())
3386 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3387 return false;
3390 /* Call callback on function and aliases associated to the function.
3391 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3392 skipped. */
3394 inline bool
3395 cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
3396 void *),
3397 void *data,
3398 bool include_overwritable)
3400 if (include_overwritable
3401 || get_availability () > AVAIL_INTERPOSABLE)
3403 if (callback (this, data))
3404 return true;
3406 if (has_aliases_p ())
3407 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3408 return false;
3411 /* Call callback on varpool symbol and aliases associated to varpool symbol.
3412 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3413 skipped. */
3415 inline bool
3416 varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
3417 void *),
3418 void *data,
3419 bool include_overwritable)
3421 if (include_overwritable
3422 || get_availability () > AVAIL_INTERPOSABLE)
3424 if (callback (this, data))
3425 return true;
3427 if (has_aliases_p ())
3428 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3429 return false;
3432 /* Return true if reference may be used in address compare. */
3434 inline bool
3435 ipa_ref::address_matters_p ()
3437 if (use != IPA_REF_ADDR)
3438 return false;
3439 /* Addresses taken from virtual tables are never compared. */
3440 if (is_a <varpool_node *> (referring)
3441 && DECL_VIRTUAL_P (referring->decl))
3442 return false;
3443 return referred->address_can_be_compared_p ();
3446 /* Build polymorphic call context for indirect call E. */
3448 inline
3449 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
3451 gcc_checking_assert (e->indirect_info->polymorphic);
3452 *this = e->indirect_info->context;
3455 /* Build empty "I know nothing" context. */
3457 inline
3458 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3460 clear_speculation ();
3461 clear_outer_type ();
3462 invalid = false;
3465 /* Make context non-speculative. */
3467 inline void
3468 ipa_polymorphic_call_context::clear_speculation ()
3470 speculative_outer_type = NULL;
3471 speculative_offset = 0;
3472 speculative_maybe_derived_type = false;
3475 /* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is
3476 NULL, the context is set to dummy "I know nothing" setting. */
3478 inline void
3479 ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
3481 outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
3482 offset = 0;
3483 maybe_derived_type = true;
3484 maybe_in_construction = true;
3485 dynamic = true;
3488 /* Adjust all offsets in contexts by OFF bits. */
3490 inline void
3491 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off)
3493 if (outer_type)
3494 offset += off;
3495 if (speculative_outer_type)
3496 speculative_offset += off;
3499 /* Return TRUE if context is fully useless. */
3501 inline bool
3502 ipa_polymorphic_call_context::useless_p () const
3504 return (!outer_type && !speculative_outer_type);
3507 /* When using fprintf (or similar), problems can arise with
3508 transient generated strings. Many string-generation APIs
3509 only support one result being alive at once (e.g. by
3510 returning a pointer to a statically-allocated buffer).
3512 If there is more than one generated string within one
3513 fprintf call: the first string gets evicted or overwritten
3514 by the second, before fprintf is fully evaluated.
3515 See e.g. PR/53136.
3517 This function provides a workaround for this, by providing
3518 a simple way to create copies of these transient strings,
3519 without the need to have explicit cleanup:
3521 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3522 xstrdup_for_dump (EXPR_1),
3523 xstrdup_for_dump (EXPR_2));
3525 This is actually a simple wrapper around ggc_strdup, but
3526 the name documents the intent. We require that no GC can occur
3527 within the fprintf call. */
3529 static inline const char *
3530 xstrdup_for_dump (const char *transient_str)
3532 return ggc_strdup (transient_str);
3535 /* During LTO stream-in this predicate can be used to check whether node
3536 in question prevails in the linking to save some memory usage. */
3537 inline bool
3538 symtab_node::prevailing_p (void)
3540 return definition && ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
3541 || previous_sharing_asm_name == NULL);
3544 extern GTY(()) symbol_table *saved_symtab;
3546 #if CHECKING_P
3548 namespace selftest {
3550 /* An RAII-style class for use in selftests for temporarily using a different
3551 symbol_table, so that such tests can be isolated from each other. */
3553 class symbol_table_test
3555 public:
3556 /* Constructor. Override "symtab". */
3557 symbol_table_test ();
3559 /* Destructor. Restore the saved_symtab. */
3560 ~symbol_table_test ();
3563 } // namespace selftest
3565 #endif /* CHECKING_P */
3567 #endif /* GCC_CGRAPH_H */