* dwarf2.def (DW_FORM_strx*, DW_FORM_addrx*): New.
[official-gcc.git] / gcc / cgraph.h
blobafb2745a841d598a507ef199c7bc4fba52637473
1 /* Callgraph handling code.
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
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"
28 class ipa_opt_pass_d;
29 typedef ipa_opt_pass_d *ipa_opt_pass;
31 /* Symbol table consists of functions and variables.
32 TODO: add labels and CONST_DECLs. */
33 enum symtab_type
35 SYMTAB_SYMBOL,
36 SYMTAB_FUNCTION,
37 SYMTAB_VARIABLE
40 /* Section names are stored as reference counted strings in GGC safe hashtable
41 (to make them survive through PCH). */
43 struct GTY((for_user)) section_hash_entry
45 int ref_count;
46 char *name; /* As long as this datastructure stays in GGC, we can not put
47 string at the tail of structure of GGC dies in horrible
48 way */
51 struct section_name_hasher : ggc_ptr_hash<section_hash_entry>
53 typedef const char *compare_type;
55 static hashval_t hash (section_hash_entry *);
56 static bool equal (section_hash_entry *, const char *);
59 enum availability
61 /* Not yet set by cgraph_function_body_availability. */
62 AVAIL_UNSET,
63 /* Function body/variable initializer is unknown. */
64 AVAIL_NOT_AVAILABLE,
65 /* Function body/variable initializer is known but might be replaced
66 by a different one from other compilation unit and thus needs to
67 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
68 arbitrary side effects on escaping variables and functions, while
69 like AVAILABLE it might access static variables. */
70 AVAIL_INTERPOSABLE,
71 /* Function body/variable initializer is known and will be used in final
72 program. */
73 AVAIL_AVAILABLE,
74 /* Function body/variable initializer is known and all it's uses are
75 explicitly visible within current unit (ie it's address is never taken and
76 it is not exported to other units). Currently used only for functions. */
77 AVAIL_LOCAL
80 /* Classification of symbols WRT partitioning. */
81 enum symbol_partitioning_class
83 /* External declarations are ignored by partitioning algorithms and they are
84 added into the boundary later via compute_ltrans_boundary. */
85 SYMBOL_EXTERNAL,
86 /* Partitioned symbols are pur into one of partitions. */
87 SYMBOL_PARTITION,
88 /* Duplicated symbols (such as comdat or constant pool references) are
89 copied into every node needing them via add_symbol_to_partition. */
90 SYMBOL_DUPLICATE
93 /* Base of all entries in the symbol table.
94 The symtab_node is inherited by cgraph and varpol nodes. */
95 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
96 chain_next ("%h.next"), chain_prev ("%h.previous")))
97 symtab_node
99 public:
100 /* Return name. */
101 const char *name () const;
103 /* Return dump name. */
104 const char *dump_name () const;
106 /* Return asm name. */
107 const char *asm_name () const;
109 /* Return dump name with assembler name. */
110 const char *dump_asm_name () const;
112 /* Add node into symbol table. This function is not used directly, but via
113 cgraph/varpool node creation routines. */
114 void register_symbol (void);
116 /* Remove symbol from symbol table. */
117 void remove (void);
119 /* Dump symtab node to F. */
120 void dump (FILE *f);
122 /* Dump symtab node to stderr. */
123 void DEBUG_FUNCTION debug (void);
125 /* Verify consistency of node. */
126 void DEBUG_FUNCTION verify (void);
128 /* Return ipa reference from this symtab_node to
129 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
130 of the use and STMT the statement (if it exists). */
131 ipa_ref *create_reference (symtab_node *referred_node,
132 enum ipa_ref_use use_type);
134 /* Return ipa reference from this symtab_node to
135 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
136 of the use and STMT the statement (if it exists). */
137 ipa_ref *create_reference (symtab_node *referred_node,
138 enum ipa_ref_use use_type, gimple *stmt);
140 /* If VAL is a reference to a function or a variable, add a reference from
141 this symtab_node to the corresponding symbol table node. Return the new
142 reference or NULL if none was created. */
143 ipa_ref *maybe_create_reference (tree val, gimple *stmt);
145 /* Clone all references from symtab NODE to this symtab_node. */
146 void clone_references (symtab_node *node);
148 /* Remove all stmt references in non-speculative references.
149 Those are not maintained during inlining & clonning.
150 The exception are speculative references that are updated along
151 with callgraph edges associated with them. */
152 void clone_referring (symtab_node *node);
154 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
155 ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt);
157 /* Find the structure describing a reference to REFERRED_NODE
158 and associated with statement STMT. */
159 ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt,
160 unsigned int lto_stmt_uid);
162 /* Remove all references that are associated with statement STMT. */
163 void remove_stmt_references (gimple *stmt);
165 /* Remove all stmt references in non-speculative references.
166 Those are not maintained during inlining & clonning.
167 The exception are speculative references that are updated along
168 with callgraph edges associated with them. */
169 void clear_stmts_in_references (void);
171 /* Remove all references in ref list. */
172 void remove_all_references (void);
174 /* Remove all referring items in ref list. */
175 void remove_all_referring (void);
177 /* Dump references in ref list to FILE. */
178 void dump_references (FILE *file);
180 /* Dump referring in list to FILE. */
181 void dump_referring (FILE *);
183 /* Get number of references for this node. */
184 inline unsigned num_references (void)
186 return ref_list.references ? ref_list.references->length () : 0;
189 /* Iterates I-th reference in the list, REF is also set. */
190 ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);
192 /* Iterates I-th referring item in the list, REF is also set. */
193 ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);
195 /* Iterates I-th referring alias item in the list, REF is also set. */
196 ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref);
198 /* Return true if symtab node and TARGET represents
199 semantically equivalent symbols. */
200 bool semantically_equivalent_p (symtab_node *target);
202 /* Classify symbol symtab node for partitioning. */
203 enum symbol_partitioning_class get_partitioning_class (void);
205 /* Return comdat group. */
206 tree get_comdat_group ()
208 return x_comdat_group;
211 /* Return comdat group as identifier_node. */
212 tree get_comdat_group_id ()
214 if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
215 x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
216 return x_comdat_group;
219 /* Set comdat group. */
220 void set_comdat_group (tree group)
222 gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
223 || DECL_P (group));
224 x_comdat_group = group;
227 /* Return section as string. */
228 const char * get_section ()
230 if (!x_section)
231 return NULL;
232 return x_section->name;
235 /* Remove node from same comdat group. */
236 void remove_from_same_comdat_group (void);
238 /* Add this symtab_node to the same comdat group that OLD is in. */
239 void add_to_same_comdat_group (symtab_node *old_node);
241 /* Dissolve the same_comdat_group list in which NODE resides. */
242 void dissolve_same_comdat_group_list (void);
244 /* Return true when symtab_node is known to be used from other (non-LTO)
245 object file. Known only when doing LTO via linker plugin. */
246 bool used_from_object_file_p (void);
248 /* Walk the alias chain to return the symbol NODE is alias of.
249 If NODE is not an alias, return NODE.
250 When AVAILABILITY is non-NULL, get minimal availability in the chain.
251 When REF is non-NULL, assume that reference happens in symbol REF
252 when determining the availability. */
253 symtab_node *ultimate_alias_target (enum availability *avail = NULL,
254 struct symtab_node *ref = NULL);
256 /* Return next reachable static symbol with initializer after NODE. */
257 inline symtab_node *next_defined_symbol (void);
259 /* Add reference recording that symtab node is alias of TARGET.
260 If TRANSPARENT is true make the alias to be transparent alias.
261 The function can fail in the case of aliasing cycles; in this case
262 it returns false. */
263 bool resolve_alias (symtab_node *target, bool transparent = false);
265 /* C++ FE sometimes change linkage flags after producing same
266 body aliases. */
267 void fixup_same_cpp_alias_visibility (symtab_node *target);
269 /* Call callback on symtab node and aliases associated to this node.
270 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
271 skipped. */
272 bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
273 void *data,
274 bool include_overwrite);
276 /* If node can not be interposable by static or dynamic linker to point to
277 different definition, return this symbol. Otherwise look for alias with
278 such property and if none exists, introduce new one. */
279 symtab_node *noninterposable_alias (void);
281 /* Return node that alias is aliasing. */
282 inline symtab_node *get_alias_target (void);
284 /* Set section for symbol and its aliases. */
285 void set_section (const char *section);
287 /* Set section, do not recurse into aliases.
288 When one wants to change section of symbol and its aliases,
289 use set_section. */
290 void set_section_for_node (const char *section);
292 /* Set initialization priority to PRIORITY. */
293 void set_init_priority (priority_type priority);
295 /* Return the initialization priority. */
296 priority_type get_init_priority ();
298 /* Return availability of NODE when referenced from REF. */
299 enum availability get_availability (symtab_node *ref = NULL);
301 /* Return true if NODE binds to current definition in final executable
302 when referenced from REF. If REF is NULL return conservative value
303 for any reference. */
304 bool binds_to_current_def_p (symtab_node *ref = NULL);
306 /* Make DECL local. */
307 void make_decl_local (void);
309 /* Copy visibility from N. */
310 void copy_visibility_from (symtab_node *n);
312 /* Return desired alignment of the definition. This is NOT alignment useful
313 to access THIS, because THIS may be interposable and DECL_ALIGN should
314 be used instead. It however must be guaranteed when output definition
315 of THIS. */
316 unsigned int definition_alignment ();
318 /* Return true if alignment can be increased. */
319 bool can_increase_alignment_p ();
321 /* Increase alignment of symbol to ALIGN. */
322 void increase_alignment (unsigned int align);
324 /* Return true if list contains an alias. */
325 bool has_aliases_p (void);
327 /* Return true when the symbol is real symbol, i.e. it is not inline clone
328 or abstract function kept for debug info purposes only. */
329 bool real_symbol_p (void);
331 /* Return true when the symbol needs to be output to the LTO symbol table. */
332 bool output_to_lto_symbol_table_p (void);
334 /* Determine if symbol declaration is needed. That is, visible to something
335 either outside this translation unit, something magic in the system
336 configury. This function is used just during symbol creation. */
337 bool needed_p (void);
339 /* Return true if this symbol is a function from the C frontend specified
340 directly in RTL form (with "__RTL"). */
341 bool native_rtl_p () const;
343 /* Return true when there are references to the node. */
344 bool referred_to_p (bool include_self = true);
346 /* Return true if symbol can be discarded by linker from the binary.
347 Assume that symbol is used (so there is no need to take into account
348 garbage collecting linkers)
350 This can happen for comdats, commons and weaks when they are previaled
351 by other definition at static linking time. */
352 inline bool
353 can_be_discarded_p (void)
355 return (DECL_EXTERNAL (decl)
356 || ((get_comdat_group ()
357 || DECL_COMMON (decl)
358 || (DECL_SECTION_NAME (decl) && DECL_WEAK (decl)))
359 && ((resolution != LDPR_PREVAILING_DEF
360 && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
361 || flag_incremental_link)
362 && resolution != LDPR_PREVAILING_DEF_IRONLY));
365 /* Return true if NODE is local to a particular COMDAT group, and must not
366 be named from outside the COMDAT. This is used for C++ decloned
367 constructors. */
368 inline bool comdat_local_p (void)
370 return (same_comdat_group && !TREE_PUBLIC (decl));
373 /* Return true if ONE and TWO are part of the same COMDAT group. */
374 inline bool in_same_comdat_group_p (symtab_node *target);
376 /* Return true if symbol is known to be nonzero. */
377 bool nonzero_address ();
379 /* Return 0 if symbol is known to have different address than S2,
380 Return 1 if symbol is known to have same address as S2,
381 return 2 otherwise.
383 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
384 and S2 is going to be accessed. This eliminates the situations when
385 either THIS or S2 is NULL and is seful for comparing bases when deciding
386 about memory aliasing. */
387 int equal_address_to (symtab_node *s2, bool memory_accessed = false);
389 /* Return true if symbol's address may possibly be compared to other
390 symbol's address. */
391 bool address_matters_p ();
393 /* Return true if NODE's address can be compared. This use properties
394 of NODE only and does not look if the address is actually taken in
395 interesting way. For that use ADDRESS_MATTERS_P instead. */
396 bool address_can_be_compared_p (void);
398 /* Return symbol table node associated with DECL, if any,
399 and NULL otherwise. */
400 static inline symtab_node *get (const_tree decl)
402 /* Check that we are called for sane type of object - functions
403 and static or external variables. */
404 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
405 || (TREE_CODE (decl) == VAR_DECL
406 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
407 || in_lto_p)));
408 /* Check that the mapping is sane - perhaps this check can go away,
409 but at the moment frontends tends to corrupt the mapping by calling
410 memcpy/memset on the tree nodes. */
411 gcc_checking_assert (!decl->decl_with_vis.symtab_node
412 || decl->decl_with_vis.symtab_node->decl == decl);
413 return decl->decl_with_vis.symtab_node;
416 /* Try to find a symtab node for declaration DECL and if it does not
417 exist or if it corresponds to an inline clone, create a new one. */
418 static inline symtab_node * get_create (tree node);
420 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
421 Return NULL if there's no such node. */
422 static symtab_node *get_for_asmname (const_tree asmname);
424 /* Verify symbol table for internal consistency. */
425 static DEBUG_FUNCTION void verify_symtab_nodes (void);
427 /* Perform internal consistency checks, if they are enabled. */
428 static inline void checking_verify_symtab_nodes (void);
430 /* Type of the symbol. */
431 ENUM_BITFIELD (symtab_type) type : 8;
433 /* The symbols resolution. */
434 ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
436 /*** Flags representing the symbol type. ***/
438 /* True when symbol corresponds to a definition in current unit.
439 set via finalize_function or finalize_decl */
440 unsigned definition : 1;
441 /* True when symbol is an alias.
442 Set by ssemble_alias. */
443 unsigned alias : 1;
444 /* When true the alias is translated into its target symbol either by GCC
445 or assembler (it also may just be a duplicate declaration of the same
446 linker name).
448 Currently transparent aliases come in three different flavors
449 - aliases having the same assembler name as their target (aka duplicated
450 declarations). In this case the assembler names compare via
451 assembler_names_equal_p and weakref is false
452 - aliases that are renamed at a time being output to final file
453 by varasm.c. For those DECL_ASSEMBLER_NAME have
454 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
455 name must be unique.
456 Weakrefs belong to this cateogry when we target assembler without
457 .weakref directive.
458 - weakrefs that are renamed by assembler via .weakref directive.
459 In this case the alias may or may not be definition (depending if
460 target declaration was seen by the compiler), weakref is set.
461 Unless we are before renaming statics, assembler names are different.
463 Given that we now support duplicate declarations, the second option is
464 redundant and will be removed. */
465 unsigned transparent_alias : 1;
466 /* True when alias is a weakref. */
467 unsigned weakref : 1;
468 /* C++ frontend produce same body aliases and extra name aliases for
469 virtual functions and vtables that are obviously equivalent.
470 Those aliases are bit special, especially because C++ frontend
471 visibility code is so ugly it can not get them right at first time
472 and their visibility needs to be copied from their "masters" at
473 the end of parsing. */
474 unsigned cpp_implicit_alias : 1;
475 /* Set once the definition was analyzed. The list of references and
476 other properties are built during analysis. */
477 unsigned analyzed : 1;
478 /* Set for write-only variables. */
479 unsigned writeonly : 1;
480 /* Visibility of symbol was used for further optimization; do not
481 permit further changes. */
482 unsigned refuse_visibility_changes : 1;
484 /*** Visibility and linkage flags. ***/
486 /* Set when function is visible by other units. */
487 unsigned externally_visible : 1;
488 /* Don't reorder to other symbols having this set. */
489 unsigned no_reorder : 1;
490 /* The symbol will be assumed to be used in an invisible way (like
491 by an toplevel asm statement). */
492 unsigned force_output : 1;
493 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
494 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
495 to static and it does not inhibit optimization. */
496 unsigned forced_by_abi : 1;
497 /* True when the name is known to be unique and thus it does not need mangling. */
498 unsigned unique_name : 1;
499 /* Specify whether the section was set by user or by
500 compiler via -ffunction-sections. */
501 unsigned implicit_section : 1;
502 /* True when body and other characteristics have been removed by
503 symtab_remove_unreachable_nodes. */
504 unsigned body_removed : 1;
506 /*** WHOPR Partitioning flags.
507 These flags are used at ltrans stage when only part of the callgraph is
508 available. ***/
510 /* Set when variable is used from other LTRANS partition. */
511 unsigned used_from_other_partition : 1;
512 /* Set when function is available in the other LTRANS partition.
513 During WPA output it is used to mark nodes that are present in
514 multiple partitions. */
515 unsigned in_other_partition : 1;
519 /*** other flags. ***/
521 /* Set when symbol has address taken. */
522 unsigned address_taken : 1;
523 /* Set when init priority is set. */
524 unsigned in_init_priority_hash : 1;
526 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
527 of offloading, for separate compilation for a different target. */
528 unsigned need_lto_streaming : 1;
530 /* Set when symbol can be streamed into bytecode for offloading. */
531 unsigned offloadable : 1;
533 /* Set when symbol is an IFUNC resolver. */
534 unsigned ifunc_resolver : 1;
537 /* Ordering of all symtab entries. */
538 int order;
540 /* Declaration representing the symbol. */
541 tree decl;
543 /* Linked list of symbol table entries starting with symtab_nodes. */
544 symtab_node *next;
545 symtab_node *previous;
547 /* Linked list of symbols with the same asm name. There may be multiple
548 entries for single symbol name during LTO, because symbols are renamed
549 only after partitioning.
551 Because inline clones are kept in the assembler name has, they also produce
552 duplicate entries.
554 There are also several long standing bugs where frontends and builtin
555 code produce duplicated decls. */
556 symtab_node *next_sharing_asm_name;
557 symtab_node *previous_sharing_asm_name;
559 /* Circular list of nodes in the same comdat group if non-NULL. */
560 symtab_node *same_comdat_group;
562 /* Vectors of referring and referenced entities. */
563 ipa_ref_list ref_list;
565 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
566 depending to what was known to frontend on the creation time.
567 Once alias is resolved, this pointer become NULL. */
568 tree alias_target;
570 /* File stream where this node is being written to. */
571 struct lto_file_decl_data * lto_file_data;
573 PTR GTY ((skip)) aux;
575 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
576 tree x_comdat_group;
578 /* Section name. Again can be private, if allowed. */
579 section_hash_entry *x_section;
581 protected:
582 /* Dump base fields of symtab nodes to F. Not to be used directly. */
583 void dump_base (FILE *);
585 /* Verify common part of symtab node. */
586 bool DEBUG_FUNCTION verify_base (void);
588 /* Remove node from symbol table. This function is not used directly, but via
589 cgraph/varpool node removal routines. */
590 void unregister (void);
592 /* Return the initialization and finalization priority information for
593 DECL. If there is no previous priority information, a freshly
594 allocated structure is returned. */
595 struct symbol_priority_map *priority_info (void);
597 /* Worker for call_for_symbol_and_aliases_1. */
598 bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
599 void *data,
600 bool include_overwrite);
601 private:
602 /* Worker for set_section. */
603 static bool set_section (symtab_node *n, void *s);
605 /* Worker for symtab_resolve_alias. */
606 static bool set_implicit_section (symtab_node *n, void *);
608 /* Worker searching noninterposable alias. */
609 static bool noninterposable_alias (symtab_node *node, void *data);
611 /* Worker for ultimate_alias_target. */
612 symtab_node *ultimate_alias_target_1 (enum availability *avail = NULL,
613 symtab_node *ref = NULL);
615 /* Get dump name with normal or assembly name. */
616 const char *get_dump_name (bool asm_name_p) const;
619 inline void
620 symtab_node::checking_verify_symtab_nodes (void)
622 if (flag_checking)
623 symtab_node::verify_symtab_nodes ();
626 /* Walk all aliases for NODE. */
627 #define FOR_EACH_ALIAS(node, alias) \
628 for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
630 /* This is the information that is put into the cgraph local structure
631 to recover a function. */
632 struct lto_file_decl_data;
634 extern const char * const cgraph_availability_names[];
635 extern const char * const ld_plugin_symbol_resolution_names[];
636 extern const char * const tls_model_names[];
638 /* Sub-structure of cgraph_node. Holds information about thunk, used only for
639 same body aliases.
641 Thunks are basically wrappers around methods which are introduced in case
642 of multiple inheritance in order to adjust the value of the "this" pointer
643 or of the returned value.
645 In the case of this-adjusting thunks, each back-end can override the
646 can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk
647 (with a tail call for instance) directly as assembly. For the default hook
648 or for the case where the can_output_mi_thunk hooks return false, the thunk
649 is gimplified and lowered using the regular machinery. */
651 struct GTY(()) cgraph_thunk_info {
652 /* Offset used to adjust "this". */
653 HOST_WIDE_INT fixed_offset;
655 /* Offset in the virtual table to get the offset to adjust "this". Valid iff
656 VIRTUAL_OFFSET_P is true. */
657 HOST_WIDE_INT virtual_value;
659 /* Thunk target, i.e. the method that this thunk wraps. Depending on the
660 TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias. */
661 tree alias;
663 /* Nonzero for a "this" adjusting thunk and zero for a result adjusting
664 thunk. */
665 bool this_adjusting;
667 /* If true, this thunk is what we call a virtual thunk. In this case:
668 * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is
669 done, add to the result the offset found in the vtable at:
670 vptr + VIRTUAL_VALUE
671 * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after
672 the virtual one. */
673 bool virtual_offset_p;
675 /* ??? True for special kind of thunks, seems related to instrumentation. */
676 bool add_pointer_bounds_args;
678 /* Set to true when alias node (the cgraph_node to which this struct belong)
679 is a thunk. Access to any other fields is invalid if this is false. */
680 bool thunk_p;
683 /* Information about the function collected locally.
684 Available after function is analyzed. */
686 struct GTY(()) cgraph_local_info {
687 /* Set when function is visible in current compilation unit only and
688 its address is never taken. */
689 unsigned local : 1;
691 /* False when there is something makes versioning impossible. */
692 unsigned versionable : 1;
694 /* False when function calling convention and signature can not be changed.
695 This is the case when __builtin_apply_args is used. */
696 unsigned can_change_signature : 1;
698 /* True when the function has been originally extern inline, but it is
699 redefined now. */
700 unsigned redefined_extern_inline : 1;
702 /* True if the function may enter serial irrevocable mode. */
703 unsigned tm_may_enter_irr : 1;
706 /* Information about the function that needs to be computed globally
707 once compilation is finished. Available only with -funit-at-a-time. */
709 struct GTY(()) cgraph_global_info {
710 /* For inline clones this points to the function they will be
711 inlined into. */
712 cgraph_node *inlined_to;
715 /* Represent which DECL tree (or reference to such tree)
716 will be replaced by another tree while versioning. */
717 struct GTY(()) ipa_replace_map
719 /* The tree that will be replaced. */
720 tree old_tree;
721 /* The new (replacing) tree. */
722 tree new_tree;
723 /* Parameter number to replace, when old_tree is NULL. */
724 int parm_num;
725 /* True when a substitution should be done, false otherwise. */
726 bool replace_p;
727 /* True when we replace a reference to old_tree. */
728 bool ref_p;
731 struct GTY(()) cgraph_clone_info
733 vec<ipa_replace_map *, va_gc> *tree_map;
734 bitmap args_to_skip;
735 bitmap combined_args_to_skip;
738 enum cgraph_simd_clone_arg_type
740 SIMD_CLONE_ARG_TYPE_VECTOR,
741 SIMD_CLONE_ARG_TYPE_UNIFORM,
742 /* These are only for integer/pointer arguments passed by value. */
743 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
744 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
745 /* These 6 are only for reference type arguments or arguments passed
746 by reference. */
747 SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
748 SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP,
749 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
750 SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP,
751 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
752 SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP,
753 SIMD_CLONE_ARG_TYPE_MASK
756 /* Function arguments in the original function of a SIMD clone.
757 Supplementary data for `struct simd_clone'. */
759 struct GTY(()) cgraph_simd_clone_arg {
760 /* Original function argument as it originally existed in
761 DECL_ARGUMENTS. */
762 tree orig_arg;
764 /* orig_arg's function (or for extern functions type from
765 TYPE_ARG_TYPES). */
766 tree orig_type;
768 /* If argument is a vector, this holds the vector version of
769 orig_arg that after adjusting the argument types will live in
770 DECL_ARGUMENTS. Otherwise, this is NULL.
772 This basically holds:
773 vector(simdlen) __typeof__(orig_arg) new_arg. */
774 tree vector_arg;
776 /* vector_arg's type (or for extern functions new vector type. */
777 tree vector_type;
779 /* If argument is a vector, this holds the array where the simd
780 argument is held while executing the simd clone function. This
781 is a local variable in the cloned function. Its content is
782 copied from vector_arg upon entry to the clone.
784 This basically holds:
785 __typeof__(orig_arg) simd_array[simdlen]. */
786 tree simd_array;
788 /* A SIMD clone's argument can be either linear (constant or
789 variable), uniform, or vector. */
790 enum cgraph_simd_clone_arg_type arg_type;
792 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
793 the constant linear step, if arg_type is
794 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
795 the uniform argument holding the step, otherwise 0. */
796 HOST_WIDE_INT linear_step;
798 /* Variable alignment if available, otherwise 0. */
799 unsigned int alignment;
802 /* Specific data for a SIMD function clone. */
804 struct GTY(()) cgraph_simd_clone {
805 /* Number of words in the SIMD lane associated with this clone. */
806 unsigned int simdlen;
808 /* Number of annotated function arguments in `args'. This is
809 usually the number of named arguments in FNDECL. */
810 unsigned int nargs;
812 /* Max hardware vector size in bits for integral vectors. */
813 unsigned int vecsize_int;
815 /* Max hardware vector size in bits for floating point vectors. */
816 unsigned int vecsize_float;
818 /* Machine mode of the mask argument(s), if they are to be passed
819 as bitmasks in integer argument(s). VOIDmode if masks are passed
820 as vectors of characteristic type. */
821 machine_mode mask_mode;
823 /* The mangling character for a given vector size. This is used
824 to determine the ISA mangling bit as specified in the Intel
825 Vector ABI. */
826 unsigned char vecsize_mangle;
828 /* True if this is the masked, in-branch version of the clone,
829 otherwise false. */
830 unsigned int inbranch : 1;
832 /* Doubly linked list of SIMD clones. */
833 cgraph_node *prev_clone, *next_clone;
835 /* Original cgraph node the SIMD clones were created for. */
836 cgraph_node *origin;
838 /* Annotated function arguments for the original function. */
839 cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
842 /* Function Multiversioning info. */
843 struct GTY((for_user)) cgraph_function_version_info {
844 /* The cgraph_node for which the function version info is stored. */
845 cgraph_node *this_node;
846 /* Chains all the semantically identical function versions. The
847 first function in this chain is the version_info node of the
848 default function. */
849 cgraph_function_version_info *prev;
850 /* If this version node corresponds to a dispatcher for function
851 versions, this points to the version info node of the default
852 function, the first node in the chain. */
853 cgraph_function_version_info *next;
854 /* If this node corresponds to a function version, this points
855 to the dispatcher function decl, which is the function that must
856 be called to execute the right function version at run-time.
858 If this cgraph node is a dispatcher (if dispatcher_function is
859 true, in the cgraph_node struct) for function versions, this
860 points to resolver function, which holds the function body of the
861 dispatcher. The dispatcher decl is an alias to the resolver
862 function decl. */
863 tree dispatcher_resolver;
866 #define DEFCIFCODE(code, type, string) CIF_ ## code,
867 /* Reasons for inlining failures. */
869 enum cgraph_inline_failed_t {
870 #include "cif-code.def"
871 CIF_N_REASONS
874 enum cgraph_inline_failed_type_t
876 CIF_FINAL_NORMAL = 0,
877 CIF_FINAL_ERROR
880 struct cgraph_edge;
882 struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
884 typedef gimple *compare_type;
886 static hashval_t hash (cgraph_edge *);
887 static hashval_t hash (gimple *);
888 static bool equal (cgraph_edge *, gimple *);
891 /* The cgraph data structure.
892 Each function decl has assigned cgraph_node listing callees and callers. */
894 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
895 public:
896 /* Remove the node from cgraph and all inline clones inlined into it.
897 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
898 removed. This allows to call the function from outer loop walking clone
899 tree. */
900 bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
902 /* Record all references from cgraph_node that are taken
903 in statement STMT. */
904 void record_stmt_references (gimple *stmt);
906 /* Like cgraph_set_call_stmt but walk the clone tree and update all
907 clones sharing the same function body.
908 When WHOLE_SPECULATIVE_EDGES is true, all three components of
909 speculative edge gets updated. Otherwise we update only direct
910 call. */
911 void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
912 bool update_speculative = true);
914 /* Walk the alias chain to return the function cgraph_node is alias of.
915 Walk through thunk, too.
916 When AVAILABILITY is non-NULL, get minimal availability in the chain.
917 When REF is non-NULL, assume that reference happens in symbol REF
918 when determining the availability. */
919 cgraph_node *function_symbol (enum availability *avail = NULL,
920 struct symtab_node *ref = NULL);
922 /* Walk the alias chain to return the function cgraph_node is alias of.
923 Walk through non virtual thunks, too. Thus we return either a function
924 or a virtual thunk node.
925 When AVAILABILITY is non-NULL, get minimal availability in the chain.
926 When REF is non-NULL, assume that reference happens in symbol REF
927 when determining the availability. */
928 cgraph_node *function_or_virtual_thunk_symbol
929 (enum availability *avail = NULL,
930 struct symtab_node *ref = NULL);
932 /* Create node representing clone of N executed COUNT times. Decrease
933 the execution counts from original node too.
934 The new clone will have decl set to DECL that may or may not be the same
935 as decl of N.
937 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
938 function's profile to reflect the fact that part of execution is handled
939 by node.
940 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
941 the new clone. Otherwise the caller is responsible for doing so later.
943 If the new node is being inlined into another one, NEW_INLINED_TO should be
944 the outline function the new one is (even indirectly) inlined to.
945 All hooks will see this in node's global.inlined_to, when invoked.
946 Can be NULL if the node is not inlined. SUFFIX is string that is appended
947 to the original name. */
948 cgraph_node *create_clone (tree decl, profile_count count,
949 bool update_original,
950 vec<cgraph_edge *> redirect_callers,
951 bool call_duplication_hook,
952 cgraph_node *new_inlined_to,
953 bitmap args_to_skip, const char *suffix = NULL);
955 /* Create callgraph node clone with new declaration. The actual body will
956 be copied later at compilation stage. */
957 cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
958 vec<ipa_replace_map *, va_gc> *tree_map,
959 bitmap args_to_skip, const char * suffix);
961 /* cgraph node being removed from symbol table; see if its entry can be
962 replaced by other inline clone. */
963 cgraph_node *find_replacement (void);
965 /* Create a new cgraph node which is the new version of
966 callgraph node. REDIRECT_CALLERS holds the callers
967 edges which should be redirected to point to
968 NEW_VERSION. ALL the callees edges of the node
969 are cloned to the new version node. Return the new
970 version node.
972 If non-NULL BLOCK_TO_COPY determine what basic blocks
973 was copied to prevent duplications of calls that are dead
974 in the clone.
976 SUFFIX is string that is appended to the original name. */
978 cgraph_node *create_version_clone (tree new_decl,
979 vec<cgraph_edge *> redirect_callers,
980 bitmap bbs_to_copy,
981 const char *suffix = NULL);
983 /* Perform function versioning.
984 Function versioning includes copying of the tree and
985 a callgraph update (creating a new cgraph node and updating
986 its callees and callers).
988 REDIRECT_CALLERS varray includes the edges to be redirected
989 to the new version.
991 TREE_MAP is a mapping of tree nodes we want to replace with
992 new ones (according to results of prior analysis).
994 If non-NULL ARGS_TO_SKIP determine function parameters to remove
995 from new version.
996 If SKIP_RETURN is true, the new version will return void.
997 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
998 If non_NULL NEW_ENTRY determine new entry BB of the clone.
1000 Return the new version's cgraph node. */
1001 cgraph_node *create_version_clone_with_body
1002 (vec<cgraph_edge *> redirect_callers,
1003 vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
1004 bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
1005 const char *clone_name);
1007 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
1008 corresponding to cgraph_node. */
1009 cgraph_function_version_info *insert_new_function_version (void);
1011 /* Get the cgraph_function_version_info node corresponding to node. */
1012 cgraph_function_version_info *function_version (void);
1014 /* Discover all functions and variables that are trivially needed, analyze
1015 them as well as all functions and variables referred by them */
1016 void analyze (void);
1018 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
1019 aliases DECL with an adjustments made into the first parameter.
1020 See comments in struct cgraph_thunk_info for detail on the parameters. */
1021 cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
1022 HOST_WIDE_INT fixed_offset,
1023 HOST_WIDE_INT virtual_value,
1024 tree virtual_offset,
1025 tree real_alias);
1028 /* Return node that alias is aliasing. */
1029 inline cgraph_node *get_alias_target (void);
1031 /* Given function symbol, walk the alias chain to return the function node
1032 is alias of. Do not walk through thunks.
1033 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1034 When REF is non-NULL, assume that reference happens in symbol REF
1035 when determining the availability. */
1037 cgraph_node *ultimate_alias_target (availability *availability = NULL,
1038 symtab_node *ref = NULL);
1040 /* Expand thunk NODE to gimple if possible.
1041 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1042 no assembler is produced.
1043 When OUTPUT_ASM_THUNK is true, also produce assembler for
1044 thunks that are not lowered. */
1045 bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
1047 /* Call expand_thunk on all callers that are thunks and analyze those
1048 nodes that were expanded. */
1049 void expand_all_artificial_thunks ();
1051 /* Assemble thunks and aliases associated to node. */
1052 void assemble_thunks_and_aliases (void);
1054 /* Expand function specified by node. */
1055 void expand (void);
1057 /* As an GCC extension we allow redefinition of the function. The
1058 semantics when both copies of bodies differ is not well defined.
1059 We replace the old body with new body so in unit at a time mode
1060 we always use new body, while in normal mode we may end up with
1061 old body inlined into some functions and new body expanded and
1062 inlined in others. */
1063 void reset (void);
1065 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1066 kind of wrapper method. */
1067 void create_wrapper (cgraph_node *target);
1069 /* Verify cgraph nodes of the cgraph node. */
1070 void DEBUG_FUNCTION verify_node (void);
1072 /* Remove function from symbol table. */
1073 void remove (void);
1075 /* Dump call graph node to file F. */
1076 void dump (FILE *f);
1078 /* Dump call graph node to stderr. */
1079 void DEBUG_FUNCTION debug (void);
1081 /* When doing LTO, read cgraph_node's body from disk if it is not already
1082 present. */
1083 bool get_untransformed_body (void);
1085 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1086 if it is not already present. When some IPA transformations are scheduled,
1087 apply them. */
1088 bool get_body (void);
1090 /* Release memory used to represent body of function.
1091 Use this only for functions that are released before being translated to
1092 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1093 are free'd in final.c via free_after_compilation(). */
1094 void release_body (bool keep_arguments = false);
1096 /* Return the DECL_STRUCT_FUNCTION of the function. */
1097 struct function *get_fun (void);
1099 /* cgraph_node is no longer nested function; update cgraph accordingly. */
1100 void unnest (void);
1102 /* Bring cgraph node local. */
1103 void make_local (void);
1105 /* Likewise indicate that a node is having address taken. */
1106 void mark_address_taken (void);
1108 /* Set fialization priority to PRIORITY. */
1109 void set_fini_priority (priority_type priority);
1111 /* Return the finalization priority. */
1112 priority_type get_fini_priority (void);
1114 /* Create edge from a given function to CALLEE in the cgraph. */
1115 cgraph_edge *create_edge (cgraph_node *callee,
1116 gcall *call_stmt, profile_count count);
1118 /* Create an indirect edge with a yet-undetermined callee where the call
1119 statement destination is a formal parameter of the caller with index
1120 PARAM_INDEX. */
1121 cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
1122 profile_count count,
1123 bool compute_indirect_info = true);
1125 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1126 same function body. If clones already have edge for OLD_STMT; only
1127 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1128 void create_edge_including_clones (cgraph_node *callee,
1129 gimple *old_stmt, gcall *stmt,
1130 profile_count count,
1131 cgraph_inline_failed_t reason);
1133 /* Return the callgraph edge representing the GIMPLE_CALL statement
1134 CALL_STMT. */
1135 cgraph_edge *get_edge (gimple *call_stmt);
1137 /* Collect all callers of cgraph_node and its aliases that are known to lead
1138 to NODE (i.e. are not overwritable) and that are not thunks. */
1139 vec<cgraph_edge *> collect_callers (void);
1141 /* Remove all callers from the node. */
1142 void remove_callers (void);
1144 /* Remove all callees from the node. */
1145 void remove_callees (void);
1147 /* Return function availability. See cgraph.h for description of individual
1148 return values. */
1149 enum availability get_availability (symtab_node *ref = NULL);
1151 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1152 if any to NOTHROW. */
1153 bool set_nothrow_flag (bool nothrow);
1155 /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
1156 if any. */
1157 bool set_malloc_flag (bool malloc_p);
1159 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1160 If SET_CONST if false, clear the flag.
1162 When setting the flag be careful about possible interposition and
1163 do not set the flag for functions that can be interposet and set pure
1164 flag for functions that can bind to other definition.
1166 Return true if any change was done. */
1168 bool set_const_flag (bool set_const, bool looping);
1170 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1171 if any to PURE.
1173 When setting the flag, be careful about possible interposition.
1174 Return true if any change was done. */
1176 bool set_pure_flag (bool pure, bool looping);
1178 /* Call callback on function and aliases associated to the function.
1179 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1180 skipped. */
1182 bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
1183 void *),
1184 void *data, bool include_overwritable);
1186 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1187 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1188 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1189 skipped. */
1190 bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
1191 void *data),
1192 void *data,
1193 bool include_overwritable,
1194 bool exclude_virtual_thunks = false);
1196 /* Likewise indicate that a node is needed, i.e. reachable via some
1197 external means. */
1198 inline void mark_force_output (void);
1200 /* Return true when function can be marked local. */
1201 bool local_p (void);
1203 /* Return true if cgraph_node can be made local for API change.
1204 Extern inline functions and C++ COMDAT functions can be made local
1205 at the expense of possible code size growth if function is used in multiple
1206 compilation units. */
1207 bool can_be_local_p (void);
1209 /* Return true when cgraph_node can not return or throw and thus
1210 it is safe to ignore its side effects for IPA analysis. */
1211 bool cannot_return_p (void);
1213 /* Return true when function cgraph_node and all its aliases are only called
1214 directly.
1215 i.e. it is not externally visible, address was not taken and
1216 it is not used in any other non-standard way. */
1217 bool only_called_directly_p (void);
1219 /* Return true when function is only called directly or it has alias.
1220 i.e. it is not externally visible, address was not taken and
1221 it is not used in any other non-standard way. */
1222 inline bool only_called_directly_or_aliased_p (void);
1224 /* Return true when function cgraph_node can be expected to be removed
1225 from program when direct calls in this compilation unit are removed.
1227 As a special case COMDAT functions are
1228 cgraph_can_remove_if_no_direct_calls_p while the are not
1229 cgraph_only_called_directly_p (it is possible they are called from other
1230 unit)
1232 This function behaves as cgraph_only_called_directly_p because eliminating
1233 all uses of COMDAT function does not make it necessarily disappear from
1234 the program unless we are compiling whole program or we do LTO. In this
1235 case we know we win since dynamic linking will not really discard the
1236 linkonce section.
1238 If WILL_INLINE is true, assume that function will be inlined into all the
1239 direct calls. */
1240 bool will_be_removed_from_program_if_no_direct_calls_p
1241 (bool will_inline = false);
1243 /* Return true when function can be removed from callgraph
1244 if all direct calls and references are eliminated. The function does
1245 not take into account comdat groups. */
1246 bool can_remove_if_no_direct_calls_and_refs_p (void);
1248 /* Return true when function cgraph_node and its aliases can be removed from
1249 callgraph if all direct calls are eliminated.
1250 If WILL_INLINE is true, assume that function will be inlined into all the
1251 direct calls. */
1252 bool can_remove_if_no_direct_calls_p (bool will_inline = false);
1254 /* Return true when callgraph node is a function with Gimple body defined
1255 in current unit. Functions can also be define externally or they
1256 can be thunks with no Gimple representation.
1258 Note that at WPA stage, the function body may not be present in memory. */
1259 inline bool has_gimple_body_p (void);
1261 /* Return true if function should be optimized for size. */
1262 bool optimize_for_size_p (void);
1264 /* Dump the callgraph to file F. */
1265 static void dump_cgraph (FILE *f);
1267 /* Dump the call graph to stderr. */
1268 static inline
1269 void debug_cgraph (void)
1271 dump_cgraph (stderr);
1274 /* Record that DECL1 and DECL2 are semantically identical function
1275 versions. */
1276 static void record_function_versions (tree decl1, tree decl2);
1278 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1279 DECL is a duplicate declaration. */
1280 static void delete_function_version_by_decl (tree decl);
1282 /* Add the function FNDECL to the call graph.
1283 Unlike finalize_function, this function is intended to be used
1284 by middle end and allows insertion of new function at arbitrary point
1285 of compilation. The function can be either in high, low or SSA form
1286 GIMPLE.
1288 The function is assumed to be reachable and have address taken (so no
1289 API breaking optimizations are performed on it).
1291 Main work done by this function is to enqueue the function for later
1292 processing to avoid need the passes to be re-entrant. */
1293 static void add_new_function (tree fndecl, bool lowered);
1295 /* Return callgraph node for given symbol and check it is a function. */
1296 static inline cgraph_node *get (const_tree decl)
1298 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
1299 return dyn_cast <cgraph_node *> (symtab_node::get (decl));
1302 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1303 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1304 have the garbage collector run at the moment. We would need to either
1305 create a new GC context, or just not compile right now. */
1306 static void finalize_function (tree, bool);
1308 /* Return cgraph node assigned to DECL. Create new one when needed. */
1309 static cgraph_node * create (tree decl);
1311 /* Try to find a call graph node for declaration DECL and if it does not
1312 exist or if it corresponds to an inline clone, create a new one. */
1313 static cgraph_node * get_create (tree);
1315 /* Return local info for the compiled function. */
1316 static cgraph_local_info *local_info (tree decl);
1318 /* Return local info for the compiled function. */
1319 static struct cgraph_rtl_info *rtl_info (tree);
1321 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1322 Return NULL if there's no such node. */
1323 static cgraph_node *get_for_asmname (tree asmname);
1325 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1326 successful and NULL otherwise.
1327 Same body aliases are output whenever the body of DECL is output,
1328 and cgraph_node::get (ALIAS) transparently
1329 returns cgraph_node::get (DECL). */
1330 static cgraph_node * create_same_body_alias (tree alias, tree decl);
1332 /* Verify whole cgraph structure. */
1333 static void DEBUG_FUNCTION verify_cgraph_nodes (void);
1335 /* Verify cgraph, if consistency checking is enabled. */
1336 static inline void checking_verify_cgraph_nodes (void);
1338 /* Worker to bring NODE local. */
1339 static bool make_local (cgraph_node *node, void *);
1341 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1342 the function body is associated
1343 with (not necessarily cgraph_node (DECL). */
1344 static cgraph_node *create_alias (tree alias, tree target);
1346 /* Return true if NODE has thunk. */
1347 static bool has_thunk_p (cgraph_node *node, void *);
1349 cgraph_edge *callees;
1350 cgraph_edge *callers;
1351 /* List of edges representing indirect calls with a yet undetermined
1352 callee. */
1353 cgraph_edge *indirect_calls;
1354 /* For nested functions points to function the node is nested in. */
1355 cgraph_node *origin;
1356 /* Points to first nested function, if any. */
1357 cgraph_node *nested;
1358 /* Pointer to the next function with same origin, if any. */
1359 cgraph_node *next_nested;
1360 /* Pointer to the next clone. */
1361 cgraph_node *next_sibling_clone;
1362 cgraph_node *prev_sibling_clone;
1363 cgraph_node *clones;
1364 cgraph_node *clone_of;
1365 /* If instrumentation_clone is 1 then instrumented_version points
1366 to the original function used to make instrumented version.
1367 Otherwise points to instrumented version of the function. */
1368 cgraph_node *instrumented_version;
1369 /* If instrumentation_clone is 1 then orig_decl is the original
1370 function declaration. */
1371 tree orig_decl;
1372 /* For functions with many calls sites it holds map from call expression
1373 to the edge to speed up cgraph_edge function. */
1374 hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
1375 /* Declaration node used to be clone of. */
1376 tree former_clone_of;
1378 /* If this is a SIMD clone, this points to the SIMD specific
1379 information for it. */
1380 cgraph_simd_clone *simdclone;
1381 /* If this function has SIMD clones, this points to the first clone. */
1382 cgraph_node *simd_clones;
1384 /* Interprocedural passes scheduled to have their transform functions
1385 applied next time we execute local pass on them. We maintain it
1386 per-function in order to allow IPA passes to introduce new functions. */
1387 vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
1389 cgraph_local_info local;
1390 cgraph_global_info global;
1391 struct cgraph_rtl_info *rtl;
1392 cgraph_clone_info clone;
1393 cgraph_thunk_info thunk;
1395 /* Expected number of executions: calculated in profile.c. */
1396 profile_count count;
1397 /* How to scale counts at materialization time; used to merge
1398 LTO units with different number of profile runs. */
1399 int count_materialization_scale;
1400 /* Unique id of the node. */
1401 int uid;
1402 /* Summary unique id of the node. */
1403 int summary_uid;
1404 /* ID assigned by the profiling. */
1405 unsigned int profile_id;
1406 /* Time profiler: first run of function. */
1407 int tp_first_run;
1409 /* Set when decl is an abstract function pointed to by the
1410 ABSTRACT_DECL_ORIGIN of a reachable function. */
1411 unsigned used_as_abstract_origin : 1;
1412 /* Set once the function is lowered (i.e. its CFG is built). */
1413 unsigned lowered : 1;
1414 /* Set once the function has been instantiated and its callee
1415 lists created. */
1416 unsigned process : 1;
1417 /* How commonly executed the node is. Initialized during branch
1418 probabilities pass. */
1419 ENUM_BITFIELD (node_frequency) frequency : 2;
1420 /* True when function can only be called at startup (from static ctor). */
1421 unsigned only_called_at_startup : 1;
1422 /* True when function can only be called at startup (from static dtor). */
1423 unsigned only_called_at_exit : 1;
1424 /* True when function is the transactional clone of a function which
1425 is called only from inside transactions. */
1426 /* ?? We should be able to remove this. We have enough bits in
1427 cgraph to calculate it. */
1428 unsigned tm_clone : 1;
1429 /* True if this decl is a dispatcher for function versions. */
1430 unsigned dispatcher_function : 1;
1431 /* True if this decl calls a COMDAT-local function. This is set up in
1432 compute_fn_summary and inline_call. */
1433 unsigned calls_comdat_local : 1;
1434 /* True if node has been created by merge operation in IPA-ICF. */
1435 unsigned icf_merged: 1;
1436 /* True when function is clone created for Pointer Bounds Checker
1437 instrumentation. */
1438 unsigned instrumentation_clone : 1;
1439 /* True if call to node can't result in a call to free, munmap or
1440 other operation that could make previously non-trapping memory
1441 accesses trapping. */
1442 unsigned nonfreeing_fn : 1;
1443 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1444 unsigned merged_comdat : 1;
1445 /* True if function was created to be executed in parallel. */
1446 unsigned parallelized_function : 1;
1447 /* True if function is part split out by ipa-split. */
1448 unsigned split_part : 1;
1449 /* True if the function appears as possible target of indirect call. */
1450 unsigned indirect_call_target : 1;
1452 private:
1453 /* Worker for call_for_symbol_and_aliases. */
1454 bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
1455 void *),
1456 void *data, bool include_overwritable);
1459 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1460 can appear in multiple sets. */
1461 struct cgraph_node_set_def
1463 hash_map<cgraph_node *, size_t> *map;
1464 vec<cgraph_node *> nodes;
1467 typedef cgraph_node_set_def *cgraph_node_set;
1468 typedef struct varpool_node_set_def *varpool_node_set;
1470 class varpool_node;
1472 /* A varpool node set is a collection of varpool nodes. A varpool node
1473 can appear in multiple sets. */
1474 struct varpool_node_set_def
1476 hash_map<varpool_node *, size_t> * map;
1477 vec<varpool_node *> nodes;
1480 /* Iterator structure for cgraph node sets. */
1481 struct cgraph_node_set_iterator
1483 cgraph_node_set set;
1484 unsigned index;
1487 /* Iterator structure for varpool node sets. */
1488 struct varpool_node_set_iterator
1490 varpool_node_set set;
1491 unsigned index;
1494 /* Context of polymorphic call. It represent information about the type of
1495 instance that may reach the call. This is used by ipa-devirt walkers of the
1496 type inheritance graph. */
1498 class GTY(()) ipa_polymorphic_call_context {
1499 public:
1500 /* The called object appears in an object of type OUTER_TYPE
1501 at offset OFFSET. When information is not 100% reliable, we
1502 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1503 HOST_WIDE_INT offset;
1504 HOST_WIDE_INT speculative_offset;
1505 tree outer_type;
1506 tree speculative_outer_type;
1507 /* True if outer object may be in construction or destruction. */
1508 unsigned maybe_in_construction : 1;
1509 /* True if outer object may be of derived type. */
1510 unsigned maybe_derived_type : 1;
1511 /* True if speculative outer object may be of derived type. We always
1512 speculate that construction does not happen. */
1513 unsigned speculative_maybe_derived_type : 1;
1514 /* True if the context is invalid and all calls should be redirected
1515 to BUILTIN_UNREACHABLE. */
1516 unsigned invalid : 1;
1517 /* True if the outer type is dynamic. */
1518 unsigned dynamic : 1;
1520 /* Build empty "I know nothing" context. */
1521 ipa_polymorphic_call_context ();
1522 /* Build polymorphic call context for indirect call E. */
1523 ipa_polymorphic_call_context (cgraph_edge *e);
1524 /* Build polymorphic call context for IP invariant CST.
1525 If specified, OTR_TYPE specify the type of polymorphic call
1526 that takes CST+OFFSET as a prameter. */
1527 ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
1528 HOST_WIDE_INT offset = 0);
1529 /* Build context for pointer REF contained in FNDECL at statement STMT.
1530 if INSTANCE is non-NULL, return pointer to the object described by
1531 the context. */
1532 ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
1533 tree *instance = NULL);
1535 /* Look for vtable stores or constructor calls to work out dynamic type
1536 of memory location. */
1537 bool get_dynamic_type (tree, tree, tree, gimple *);
1539 /* Make context non-speculative. */
1540 void clear_speculation ();
1542 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1543 NULL, the context is set to dummy "I know nothing" setting. */
1544 void clear_outer_type (tree otr_type = NULL);
1546 /* Walk container types and modify context to point to actual class
1547 containing OTR_TYPE (if non-NULL) as base class.
1548 Return true if resulting context is valid.
1550 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1551 valid only via allocation of new polymorphic type inside by means
1552 of placement new.
1554 When CONSIDER_BASES is false, only look for actual fields, not base types
1555 of TYPE. */
1556 bool restrict_to_inner_class (tree otr_type,
1557 bool consider_placement_new = true,
1558 bool consider_bases = true);
1560 /* Adjust all offsets in contexts by given number of bits. */
1561 void offset_by (HOST_WIDE_INT);
1562 /* Use when we can not track dynamic type change. This speculatively assume
1563 type change is not happening. */
1564 void possible_dynamic_type_change (bool, tree otr_type = NULL);
1565 /* Assume that both THIS and a given context is valid and strenghten THIS
1566 if possible. Return true if any strenghtening was made.
1567 If actual type the context is being used in is known, OTR_TYPE should be
1568 set accordingly. This improves quality of combined result. */
1569 bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1570 bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1572 /* Return TRUE if context is fully useless. */
1573 bool useless_p () const;
1574 /* Return TRUE if this context conveys the same information as X. */
1575 bool equal_to (const ipa_polymorphic_call_context &x) const;
1577 /* Dump human readable context to F. If NEWLINE is true, it will be
1578 terminated by a newline. */
1579 void dump (FILE *f, bool newline = true) const;
1580 void DEBUG_FUNCTION debug () const;
1582 /* LTO streaming. */
1583 void stream_out (struct output_block *) const;
1584 void stream_in (struct lto_input_block *, struct data_in *data_in);
1586 private:
1587 bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1588 bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1589 void set_by_decl (tree, HOST_WIDE_INT);
1590 bool set_by_invariant (tree, tree, HOST_WIDE_INT);
1591 bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
1592 void make_speculative (tree otr_type = NULL);
1595 /* Structure containing additional information about an indirect call. */
1597 struct GTY(()) cgraph_indirect_call_info
1599 /* When agg_content is set, an offset where the call pointer is located
1600 within the aggregate. */
1601 HOST_WIDE_INT offset;
1602 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1603 ipa_polymorphic_call_context context;
1604 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1605 HOST_WIDE_INT otr_token;
1606 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1607 tree otr_type;
1608 /* Index of the parameter that is called. */
1609 int param_index;
1610 /* ECF flags determined from the caller. */
1611 int ecf_flags;
1612 /* Profile_id of common target obtrained from profile. */
1613 int common_target_id;
1614 /* Probability that call will land in function with COMMON_TARGET_ID. */
1615 int common_target_probability;
1617 /* Set when the call is a virtual call with the parameter being the
1618 associated object pointer rather than a simple direct call. */
1619 unsigned polymorphic : 1;
1620 /* Set when the call is a call of a pointer loaded from contents of an
1621 aggregate at offset. */
1622 unsigned agg_contents : 1;
1623 /* Set when this is a call through a member pointer. */
1624 unsigned member_ptr : 1;
1625 /* When the agg_contents bit is set, this one determines whether the
1626 destination is loaded from a parameter passed by reference. */
1627 unsigned by_ref : 1;
1628 /* When the agg_contents bit is set, this one determines whether we can
1629 deduce from the function body that the loaded value from the reference is
1630 never modified between the invocation of the function and the load
1631 point. */
1632 unsigned guaranteed_unmodified : 1;
1633 /* For polymorphic calls this specify whether the virtual table pointer
1634 may have changed in between function entry and the call. */
1635 unsigned vptr_changed : 1;
1638 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1639 for_user)) cgraph_edge {
1640 friend class cgraph_node;
1642 /* Remove the edge in the cgraph. */
1643 void remove (void);
1645 /* Change field call_stmt of edge to NEW_STMT.
1646 If UPDATE_SPECULATIVE and E is any component of speculative
1647 edge, then update all components. */
1648 void set_call_stmt (gcall *new_stmt, bool update_speculative = true);
1650 /* Redirect callee of the edge to N. The function does not update underlying
1651 call expression. */
1652 void redirect_callee (cgraph_node *n);
1654 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1655 create one or more equivalent thunks for N and redirect E to the first in
1656 the chain. Note that it is then necessary to call
1657 n->expand_all_artificial_thunks once all callers are redirected. */
1658 void redirect_callee_duplicating_thunks (cgraph_node *n);
1660 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1661 CALLEE. DELTA is an integer constant that is to be added to the this
1662 pointer (first parameter) to compensate for skipping
1663 a thunk adjustment. */
1664 cgraph_edge *make_direct (cgraph_node *callee);
1666 /* Turn edge into speculative call calling N2. Update
1667 the profile so the direct call is taken COUNT times
1668 with FREQUENCY. */
1669 cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count);
1671 /* Given speculative call edge, return all three components. */
1672 void speculative_call_info (cgraph_edge *&direct, cgraph_edge *&indirect,
1673 ipa_ref *&reference);
1675 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1676 Remove the speculative call sequence and return edge representing the call.
1677 It is up to caller to redirect the call as appropriate. */
1678 cgraph_edge *resolve_speculation (tree callee_decl = NULL);
1680 /* If necessary, change the function declaration in the call statement
1681 associated with the edge so that it corresponds to the edge callee. */
1682 gimple *redirect_call_stmt_to_callee (void);
1684 /* Create clone of edge in the node N represented
1685 by CALL_EXPR the callgraph. */
1686 cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
1687 profile_count num, profile_count den,
1688 bool update_original);
1690 /* Verify edge count and frequency. */
1691 bool verify_count ();
1693 /* Return true when call of edge can not lead to return from caller
1694 and thus it is safe to ignore its side effects for IPA analysis
1695 when computing side effects of the caller. */
1696 bool cannot_lead_to_return_p (void);
1698 /* Return true when the edge represents a direct recursion. */
1699 bool recursive_p (void);
1701 /* Return true if the call can be hot. */
1702 bool maybe_hot_p (void);
1704 /* Rebuild cgraph edges for current function node. This needs to be run after
1705 passes that don't update the cgraph. */
1706 static unsigned int rebuild_edges (void);
1708 /* Rebuild cgraph references for current function node. This needs to be run
1709 after passes that don't update the cgraph. */
1710 static void rebuild_references (void);
1712 /* Expected number of executions: calculated in profile.c. */
1713 profile_count count;
1714 cgraph_node *caller;
1715 cgraph_node *callee;
1716 cgraph_edge *prev_caller;
1717 cgraph_edge *next_caller;
1718 cgraph_edge *prev_callee;
1719 cgraph_edge *next_callee;
1720 gcall *call_stmt;
1721 /* Additional information about an indirect call. Not cleared when an edge
1722 becomes direct. */
1723 cgraph_indirect_call_info *indirect_info;
1724 PTR GTY ((skip (""))) aux;
1725 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1726 explanation why function was not inlined. */
1727 enum cgraph_inline_failed_t inline_failed;
1728 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1729 when the function is serialized in. */
1730 unsigned int lto_stmt_uid;
1731 /* Unique id of the edge. */
1732 int uid;
1733 /* Whether this edge was made direct by indirect inlining. */
1734 unsigned int indirect_inlining_edge : 1;
1735 /* Whether this edge describes an indirect call with an undetermined
1736 callee. */
1737 unsigned int indirect_unknown_callee : 1;
1738 /* Whether this edge is still a dangling */
1739 /* True if the corresponding CALL stmt cannot be inlined. */
1740 unsigned int call_stmt_cannot_inline_p : 1;
1741 /* Can this call throw externally? */
1742 unsigned int can_throw_external : 1;
1743 /* Edges with SPECULATIVE flag represents indirect calls that was
1744 speculatively turned into direct (i.e. by profile feedback).
1745 The final code sequence will have form:
1747 if (call_target == expected_fn)
1748 expected_fn ();
1749 else
1750 call_target ();
1752 Every speculative call is represented by three components attached
1753 to a same call statement:
1754 1) a direct call (to expected_fn)
1755 2) an indirect call (to call_target)
1756 3) a IPA_REF_ADDR refrence to expected_fn.
1758 Optimizers may later redirect direct call to clone, so 1) and 3)
1759 do not need to necesarily agree with destination. */
1760 unsigned int speculative : 1;
1761 /* Set to true when caller is a constructor or destructor of polymorphic
1762 type. */
1763 unsigned in_polymorphic_cdtor : 1;
1765 /* Return true if call must bind to current definition. */
1766 bool binds_to_current_def_p ();
1768 /* Expected frequency of executions within the function.
1769 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1770 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1771 int frequency ();
1773 /* Expected frequency of executions within the function. */
1774 sreal sreal_frequency ();
1775 private:
1776 /* Remove the edge from the list of the callers of the callee. */
1777 void remove_caller (void);
1779 /* Remove the edge from the list of the callees of the caller. */
1780 void remove_callee (void);
1782 /* Set callee N of call graph edge and add it to the corresponding set of
1783 callers. */
1784 void set_callee (cgraph_node *n);
1786 /* Output flags of edge to a file F. */
1787 void dump_edge_flags (FILE *f);
1789 /* Verify that call graph edge corresponds to DECL from the associated
1790 statement. Return true if the verification should fail. */
1791 bool verify_corresponds_to_fndecl (tree decl);
1794 #define CGRAPH_FREQ_BASE 1000
1795 #define CGRAPH_FREQ_MAX 100000
1797 /* The varpool data structure.
1798 Each static variable decl has assigned varpool_node. */
1800 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
1801 public:
1802 /* Dump given varpool node to F. */
1803 void dump (FILE *f);
1805 /* Dump given varpool node to stderr. */
1806 void DEBUG_FUNCTION debug (void);
1808 /* Remove variable from symbol table. */
1809 void remove (void);
1811 /* Remove node initializer when it is no longer needed. */
1812 void remove_initializer (void);
1814 void analyze (void);
1816 /* Return variable availability. */
1817 availability get_availability (symtab_node *ref = NULL);
1819 /* When doing LTO, read variable's constructor from disk if
1820 it is not already present. */
1821 tree get_constructor (void);
1823 /* Return true if variable has constructor that can be used for folding. */
1824 bool ctor_useable_for_folding_p (void);
1826 /* For given variable pool node, walk the alias chain to return the function
1827 the variable is alias of. Do not walk through thunks.
1828 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1829 When REF is non-NULL, assume that reference happens in symbol REF
1830 when determining the availability. */
1831 inline varpool_node *ultimate_alias_target
1832 (availability *availability = NULL, symtab_node *ref = NULL);
1834 /* Return node that alias is aliasing. */
1835 inline varpool_node *get_alias_target (void);
1837 /* Output one variable, if necessary. Return whether we output it. */
1838 bool assemble_decl (void);
1840 /* For variables in named sections make sure get_variable_section
1841 is called before we switch to those sections. Then section
1842 conflicts between read-only and read-only requiring relocations
1843 sections can be resolved. */
1844 void finalize_named_section_flags (void);
1846 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1847 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1848 skipped. */
1849 bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
1850 void *data,
1851 bool include_overwritable);
1853 /* Return true when variable should be considered externally visible. */
1854 bool externally_visible_p (void);
1856 /* Return true when all references to variable must be visible
1857 in ipa_ref_list.
1858 i.e. if the variable is not externally visible or not used in some magic
1859 way (asm statement or such).
1860 The magic uses are all summarized in force_output flag. */
1861 inline bool all_refs_explicit_p ();
1863 /* Return true when variable can be removed from variable pool
1864 if all direct calls are eliminated. */
1865 inline bool can_remove_if_no_refs_p (void);
1867 /* Add the variable DECL to the varpool.
1868 Unlike finalize_decl function is intended to be used
1869 by middle end and allows insertion of new variable at arbitrary point
1870 of compilation. */
1871 static void add (tree decl);
1873 /* Return varpool node for given symbol and check it is a function. */
1874 static inline varpool_node *get (const_tree decl);
1876 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1877 the middle end to output the variable to asm file, if needed or externally
1878 visible. */
1879 static void finalize_decl (tree decl);
1881 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1882 Extra name aliases are output whenever DECL is output. */
1883 static varpool_node * create_extra_name_alias (tree alias, tree decl);
1885 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1886 Extra name aliases are output whenever DECL is output. */
1887 static varpool_node * create_alias (tree, tree);
1889 /* Dump the variable pool to F. */
1890 static void dump_varpool (FILE *f);
1892 /* Dump the variable pool to stderr. */
1893 static void DEBUG_FUNCTION debug_varpool (void);
1895 /* Allocate new callgraph node and insert it into basic data structures. */
1896 static varpool_node *create_empty (void);
1898 /* Return varpool node assigned to DECL. Create new one when needed. */
1899 static varpool_node *get_create (tree decl);
1901 /* Given an assembler name, lookup node. */
1902 static varpool_node *get_for_asmname (tree asmname);
1904 /* Set when variable is scheduled to be assembled. */
1905 unsigned output : 1;
1907 /* Set when variable has statically initialized pointer
1908 or is a static bounds variable and needs initalization. */
1909 unsigned need_bounds_init : 1;
1911 /* Set if the variable is dynamically initialized, except for
1912 function local statics. */
1913 unsigned dynamically_initialized : 1;
1915 ENUM_BITFIELD(tls_model) tls_model : 3;
1917 /* Set if the variable is known to be used by single function only.
1918 This is computed by ipa_signle_use pass and used by late optimizations
1919 in places where optimization would be valid for local static variable
1920 if we did not do any inter-procedural code movement. */
1921 unsigned used_by_single_function : 1;
1923 private:
1924 /* Assemble thunks and aliases associated to varpool node. */
1925 void assemble_aliases (void);
1927 /* Worker for call_for_node_and_aliases. */
1928 bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
1929 void *data,
1930 bool include_overwritable);
1933 /* Every top level asm statement is put into a asm_node. */
1935 struct GTY(()) asm_node {
1938 /* Next asm node. */
1939 asm_node *next;
1940 /* String for this asm node. */
1941 tree asm_str;
1942 /* Ordering of all cgraph nodes. */
1943 int order;
1946 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
1948 template <>
1949 template <>
1950 inline bool
1951 is_a_helper <cgraph_node *>::test (symtab_node *p)
1953 return p && p->type == SYMTAB_FUNCTION;
1956 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
1958 template <>
1959 template <>
1960 inline bool
1961 is_a_helper <varpool_node *>::test (symtab_node *p)
1963 return p && p->type == SYMTAB_VARIABLE;
1966 /* Macros to access the next item in the list of free cgraph nodes and
1967 edges. */
1968 #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next)
1969 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
1970 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
1972 typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
1973 typedef void (*cgraph_node_hook)(cgraph_node *, void *);
1974 typedef void (*varpool_node_hook)(varpool_node *, void *);
1975 typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
1976 typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
1978 struct cgraph_edge_hook_list;
1979 struct cgraph_node_hook_list;
1980 struct varpool_node_hook_list;
1981 struct cgraph_2edge_hook_list;
1982 struct cgraph_2node_hook_list;
1984 /* Map from a symbol to initialization/finalization priorities. */
1985 struct GTY(()) symbol_priority_map {
1986 priority_type init;
1987 priority_type fini;
1990 enum symtab_state
1992 /* Frontend is parsing and finalizing functions. */
1993 PARSING,
1994 /* Callgraph is being constructed. It is safe to add new functions. */
1995 CONSTRUCTION,
1996 /* Callgraph is being streamed-in at LTO time. */
1997 LTO_STREAMING,
1998 /* Callgraph is built and early IPA passes are being run. */
1999 IPA,
2000 /* Callgraph is built and all functions are transformed to SSA form. */
2001 IPA_SSA,
2002 /* All inline decisions are done; it is now possible to remove extern inline
2003 functions and virtual call targets. */
2004 IPA_SSA_AFTER_INLINING,
2005 /* Functions are now ordered and being passed to RTL expanders. */
2006 EXPANSION,
2007 /* All cgraph expansion is done. */
2008 FINISHED
2011 struct asmname_hasher : ggc_ptr_hash <symtab_node>
2013 typedef const_tree compare_type;
2015 static hashval_t hash (symtab_node *n);
2016 static bool equal (symtab_node *n, const_tree t);
2019 class GTY((tag ("SYMTAB"))) symbol_table
2021 public:
2022 friend class symtab_node;
2023 friend class cgraph_node;
2024 friend class cgraph_edge;
2026 symbol_table (): cgraph_max_summary_uid (1)
2030 /* Initialize callgraph dump file. */
2031 void initialize (void);
2033 /* Register a top-level asm statement ASM_STR. */
2034 inline asm_node *finalize_toplevel_asm (tree asm_str);
2036 /* Analyze the whole compilation unit once it is parsed completely. */
2037 void finalize_compilation_unit (void);
2039 /* C++ frontend produce same body aliases all over the place, even before PCH
2040 gets streamed out. It relies on us linking the aliases with their function
2041 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
2042 first produce aliases without links, but once C++ FE is sure he won't sream
2043 PCH we build the links via this function. */
2044 void process_same_body_aliases (void);
2046 /* Perform simple optimizations based on callgraph. */
2047 void compile (void);
2049 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2050 functions into callgraph in a way so they look like ordinary reachable
2051 functions inserted into callgraph already at construction time. */
2052 void process_new_functions (void);
2054 /* Once all functions from compilation unit are in memory, produce all clones
2055 and update all calls. We might also do this on demand if we don't want to
2056 bring all functions to memory prior compilation, but current WHOPR
2057 implementation does that and it is bit easier to keep everything right
2058 in this order. */
2059 void materialize_all_clones (void);
2061 /* Register a symbol NODE. */
2062 inline void register_symbol (symtab_node *node);
2064 inline void
2065 clear_asm_symbols (void)
2067 asmnodes = NULL;
2068 asm_last_node = NULL;
2071 /* Perform reachability analysis and reclaim all unreachable nodes. */
2072 bool remove_unreachable_nodes (FILE *file);
2074 /* Optimization of function bodies might've rendered some variables as
2075 unnecessary so we want to avoid these from being compiled. Re-do
2076 reachability starting from variables that are either externally visible
2077 or was referred from the asm output routines. */
2078 void remove_unreferenced_decls (void);
2080 /* Unregister a symbol NODE. */
2081 inline void unregister (symtab_node *node);
2083 /* Allocate new callgraph node and insert it into basic data structures. */
2084 cgraph_node *create_empty (void);
2086 /* Release a callgraph NODE with UID and put in to the list
2087 of free nodes. */
2088 void release_symbol (cgraph_node *node, int uid);
2090 /* Output all variables enqueued to be assembled. */
2091 bool output_variables (void);
2093 /* Weakrefs may be associated to external decls and thus not output
2094 at expansion time. Emit all necessary aliases. */
2095 void output_weakrefs (void);
2097 /* Return first static symbol with definition. */
2098 inline symtab_node *first_symbol (void);
2100 /* Return first assembler symbol. */
2101 inline asm_node *
2102 first_asm_symbol (void)
2104 return asmnodes;
2107 /* Return first static symbol with definition. */
2108 inline symtab_node *first_defined_symbol (void);
2110 /* Return first variable. */
2111 inline varpool_node *first_variable (void);
2113 /* Return next variable after NODE. */
2114 inline varpool_node *next_variable (varpool_node *node);
2116 /* Return first static variable with initializer. */
2117 inline varpool_node *first_static_initializer (void);
2119 /* Return next static variable with initializer after NODE. */
2120 inline varpool_node *next_static_initializer (varpool_node *node);
2122 /* Return first static variable with definition. */
2123 inline varpool_node *first_defined_variable (void);
2125 /* Return next static variable with definition after NODE. */
2126 inline varpool_node *next_defined_variable (varpool_node *node);
2128 /* Return first function with body defined. */
2129 inline cgraph_node *first_defined_function (void);
2131 /* Return next function with body defined after NODE. */
2132 inline cgraph_node *next_defined_function (cgraph_node *node);
2134 /* Return first function. */
2135 inline cgraph_node *first_function (void);
2137 /* Return next function. */
2138 inline cgraph_node *next_function (cgraph_node *node);
2140 /* Return first function with body defined. */
2141 cgraph_node *first_function_with_gimple_body (void);
2143 /* Return next reachable static variable with initializer after NODE. */
2144 inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
2146 /* Register HOOK to be called with DATA on each removed edge. */
2147 cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
2148 void *data);
2150 /* Remove ENTRY from the list of hooks called on removing edges. */
2151 void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
2153 /* Register HOOK to be called with DATA on each removed node. */
2154 cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
2155 void *data);
2157 /* Remove ENTRY from the list of hooks called on removing nodes. */
2158 void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
2160 /* Register HOOK to be called with DATA on each removed node. */
2161 varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
2162 void *data);
2164 /* Remove ENTRY from the list of hooks called on removing nodes. */
2165 void remove_varpool_removal_hook (varpool_node_hook_list *entry);
2167 /* Register HOOK to be called with DATA on each inserted node. */
2168 cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
2169 void *data);
2171 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2172 void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
2174 /* Register HOOK to be called with DATA on each inserted node. */
2175 varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
2176 void *data);
2178 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2179 void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
2181 /* Register HOOK to be called with DATA on each duplicated edge. */
2182 cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
2183 void *data);
2184 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2185 void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
2187 /* Register HOOK to be called with DATA on each duplicated node. */
2188 cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
2189 void *data);
2191 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2192 void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
2194 /* Call all edge removal hooks. */
2195 void call_edge_removal_hooks (cgraph_edge *e);
2197 /* Call all node insertion hooks. */
2198 void call_cgraph_insertion_hooks (cgraph_node *node);
2200 /* Call all node removal hooks. */
2201 void call_cgraph_removal_hooks (cgraph_node *node);
2203 /* Call all node duplication hooks. */
2204 void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
2206 /* Call all edge duplication hooks. */
2207 void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
2209 /* Call all node removal hooks. */
2210 void call_varpool_removal_hooks (varpool_node *node);
2212 /* Call all node insertion hooks. */
2213 void call_varpool_insertion_hooks (varpool_node *node);
2215 /* Arrange node to be first in its entry of assembler_name_hash. */
2216 void symtab_prevail_in_asm_name_hash (symtab_node *node);
2218 /* Initalize asm name hash unless. */
2219 void symtab_initialize_asm_name_hash (void);
2221 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2222 void change_decl_assembler_name (tree decl, tree name);
2224 /* Dump symbol table to F. */
2225 void dump (FILE *f);
2227 /* Dump symbol table to stderr. */
2228 void DEBUG_FUNCTION debug (void);
2230 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2231 name. */
2232 static bool assembler_names_equal_p (const char *name1, const char *name2);
2234 int cgraph_count;
2235 int cgraph_max_uid;
2236 int cgraph_max_summary_uid;
2238 int edges_count;
2239 int edges_max_uid;
2241 symtab_node* GTY(()) nodes;
2242 asm_node* GTY(()) asmnodes;
2243 asm_node* GTY(()) asm_last_node;
2244 cgraph_node* GTY(()) free_nodes;
2246 /* Head of a linked list of unused (freed) call graph edges.
2247 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
2248 cgraph_edge * GTY(()) free_edges;
2250 /* The order index of the next symtab node to be created. This is
2251 used so that we can sort the cgraph nodes in order by when we saw
2252 them, to support -fno-toplevel-reorder. */
2253 int order;
2255 /* Set when whole unit has been analyzed so we can access global info. */
2256 bool global_info_ready;
2257 /* What state callgraph is in right now. */
2258 enum symtab_state state;
2259 /* Set when the cgraph is fully build and the basic flags are computed. */
2260 bool function_flags_ready;
2262 bool cpp_implicit_aliases_done;
2264 /* Hash table used to hold sectoons. */
2265 hash_table<section_name_hasher> *GTY(()) section_hash;
2267 /* Hash table used to convert assembler names into nodes. */
2268 hash_table<asmname_hasher> *assembler_name_hash;
2270 /* Hash table used to hold init priorities. */
2271 hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
2273 FILE* GTY ((skip)) dump_file;
2275 /* Return symbol used to separate symbol name from suffix. */
2276 static char symbol_suffix_separator ();
2278 FILE* GTY ((skip)) ipa_clones_dump_file;
2280 hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;
2282 private:
2283 /* Allocate new callgraph node. */
2284 inline cgraph_node * allocate_cgraph_symbol (void);
2286 /* Allocate a cgraph_edge structure and fill it with data according to the
2287 parameters of which only CALLEE can be NULL (when creating an indirect call
2288 edge). */
2289 cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
2290 gcall *call_stmt, profile_count count,
2291 bool indir_unknown_callee);
2293 /* Put the edge onto the free list. */
2294 void free_edge (cgraph_edge *e);
2296 /* Insert NODE to assembler name hash. */
2297 void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
2299 /* Remove NODE from assembler name hash. */
2300 void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
2302 /* Hash asmnames ignoring the user specified marks. */
2303 static hashval_t decl_assembler_name_hash (const_tree asmname);
2305 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2306 static bool decl_assembler_name_equal (tree decl, const_tree asmname);
2308 friend struct asmname_hasher;
2310 /* List of hooks triggered when an edge is removed. */
2311 cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
2312 /* List of hooks triggem_red when a cgraph node is removed. */
2313 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
2314 /* List of hooks triggered when an edge is duplicated. */
2315 cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
2316 /* List of hooks triggered when a node is duplicated. */
2317 cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
2318 /* List of hooks triggered when an function is inserted. */
2319 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
2320 /* List of hooks triggered when an variable is inserted. */
2321 varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
2322 /* List of hooks triggered when a node is removed. */
2323 varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
2326 extern GTY(()) symbol_table *symtab;
2328 extern vec<cgraph_node *> cgraph_new_nodes;
2330 inline hashval_t
2331 asmname_hasher::hash (symtab_node *n)
2333 return symbol_table::decl_assembler_name_hash
2334 (DECL_ASSEMBLER_NAME (n->decl));
2337 inline bool
2338 asmname_hasher::equal (symtab_node *n, const_tree t)
2340 return symbol_table::decl_assembler_name_equal (n->decl, t);
2343 /* In cgraph.c */
2344 void cgraph_c_finalize (void);
2345 void release_function_body (tree);
2346 cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
2348 void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
2349 bool cgraph_function_possibly_inlined_p (tree);
2351 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
2352 cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
2354 extern bool gimple_check_call_matching_types (gimple *, tree, bool);
2356 /* In cgraphunit.c */
2357 void cgraphunit_c_finalize (void);
2359 /* Initialize datastructures so DECL is a function in lowered gimple form.
2360 IN_SSA is true if the gimple is in SSA. */
2361 basic_block init_lowered_empty_function (tree, bool, profile_count);
2363 tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree);
2364 /* In cgraphclones.c */
2366 tree clone_function_name_1 (const char *, const char *);
2367 tree clone_function_name (tree decl, const char *);
2369 void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
2370 bool, bitmap, bool, bitmap, basic_block);
2372 void dump_callgraph_transformation (const cgraph_node *original,
2373 const cgraph_node *clone,
2374 const char *suffix);
2375 tree cgraph_build_function_type_skip_args (tree orig_type, bitmap args_to_skip,
2376 bool skip_return);
2378 /* In cgraphbuild.c */
2379 int compute_call_stmt_bb_frequency (tree, basic_block bb);
2380 void record_references_in_initializer (tree, bool);
2382 /* In ipa.c */
2383 void cgraph_build_static_cdtor (char which, tree body, int priority);
2384 bool ipa_discover_readonly_nonaddressable_vars (void);
2386 /* In varpool.c */
2387 tree ctor_for_folding (tree);
2389 /* In tree-chkp.c */
2390 extern bool chkp_function_instrumented_p (tree fndecl);
2392 /* In ipa-inline-analysis.c */
2393 void initialize_inline_failed (struct cgraph_edge *);
2394 bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);
2396 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2397 or abstract function kept for debug info purposes only. */
2398 inline bool
2399 symtab_node::real_symbol_p (void)
2401 cgraph_node *cnode;
2403 if (DECL_ABSTRACT_P (decl))
2404 return false;
2405 if (transparent_alias && definition)
2406 return false;
2407 if (!is_a <cgraph_node *> (this))
2408 return true;
2409 cnode = dyn_cast <cgraph_node *> (this);
2410 if (cnode->global.inlined_to)
2411 return false;
2412 return true;
2415 /* Return true if DECL should have entry in symbol table if used.
2416 Those are functions and static & external veriables*/
2418 static inline bool
2419 decl_in_symtab_p (const_tree decl)
2421 return (TREE_CODE (decl) == FUNCTION_DECL
2422 || (TREE_CODE (decl) == VAR_DECL
2423 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
2426 inline bool
2427 symtab_node::in_same_comdat_group_p (symtab_node *target)
2429 symtab_node *source = this;
2431 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2433 if (cn->global.inlined_to)
2434 source = cn->global.inlined_to;
2436 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2438 if (cn->global.inlined_to)
2439 target = cn->global.inlined_to;
2442 return source->get_comdat_group () == target->get_comdat_group ();
2445 /* Return node that alias is aliasing. */
2447 inline symtab_node *
2448 symtab_node::get_alias_target (void)
2450 ipa_ref *ref = NULL;
2451 iterate_reference (0, ref);
2452 if (ref->use == IPA_REF_CHKP)
2453 iterate_reference (1, ref);
2454 gcc_checking_assert (ref->use == IPA_REF_ALIAS);
2455 return ref->referred;
2458 /* Return next reachable static symbol with initializer after the node. */
2460 inline symtab_node *
2461 symtab_node::next_defined_symbol (void)
2463 symtab_node *node1 = next;
2465 for (; node1; node1 = node1->next)
2466 if (node1->definition)
2467 return node1;
2469 return NULL;
2472 /* Iterates I-th reference in the list, REF is also set. */
2474 inline ipa_ref *
2475 symtab_node::iterate_reference (unsigned i, ipa_ref *&ref)
2477 vec_safe_iterate (ref_list.references, i, &ref);
2479 return ref;
2482 /* Iterates I-th referring item in the list, REF is also set. */
2484 inline ipa_ref *
2485 symtab_node::iterate_referring (unsigned i, ipa_ref *&ref)
2487 ref_list.referring.iterate (i, &ref);
2489 return ref;
2492 /* Iterates I-th referring alias item in the list, REF is also set. */
2494 inline ipa_ref *
2495 symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref)
2497 ref_list.referring.iterate (i, &ref);
2499 if (ref && ref->use != IPA_REF_ALIAS)
2500 return NULL;
2502 return ref;
2505 /* Return true if list contains an alias. */
2507 inline bool
2508 symtab_node::has_aliases_p (void)
2510 ipa_ref *ref = NULL;
2512 return (iterate_direct_aliases (0, ref) != NULL);
2515 /* Return true when RESOLUTION indicate that linker will use
2516 the symbol from non-LTO object files. */
2518 inline bool
2519 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2521 return (resolution == LDPR_PREVAILING_DEF
2522 || resolution == LDPR_PREEMPTED_REG
2523 || resolution == LDPR_RESOLVED_EXEC
2524 || resolution == LDPR_RESOLVED_DYN);
2527 /* Return true when symtab_node is known to be used from other (non-LTO)
2528 object file. Known only when doing LTO via linker plugin. */
2530 inline bool
2531 symtab_node::used_from_object_file_p (void)
2533 if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
2534 return false;
2535 if (resolution_used_from_other_file_p (resolution))
2536 return true;
2537 return false;
2540 /* Return varpool node for given symbol and check it is a function. */
2542 inline varpool_node *
2543 varpool_node::get (const_tree decl)
2545 gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
2546 return dyn_cast<varpool_node *> (symtab_node::get (decl));
2549 /* Register a symbol NODE. */
2551 inline void
2552 symbol_table::register_symbol (symtab_node *node)
2554 node->next = nodes;
2555 node->previous = NULL;
2557 if (nodes)
2558 nodes->previous = node;
2559 nodes = node;
2561 node->order = order++;
2564 /* Register a top-level asm statement ASM_STR. */
2566 asm_node *
2567 symbol_table::finalize_toplevel_asm (tree asm_str)
2569 asm_node *node;
2571 node = ggc_cleared_alloc<asm_node> ();
2572 node->asm_str = asm_str;
2573 node->order = order++;
2574 node->next = NULL;
2576 if (asmnodes == NULL)
2577 asmnodes = node;
2578 else
2579 asm_last_node->next = node;
2581 asm_last_node = node;
2582 return node;
2585 /* Unregister a symbol NODE. */
2586 inline void
2587 symbol_table::unregister (symtab_node *node)
2589 if (node->previous)
2590 node->previous->next = node->next;
2591 else
2592 nodes = node->next;
2594 if (node->next)
2595 node->next->previous = node->previous;
2597 node->next = NULL;
2598 node->previous = NULL;
2601 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2603 inline void
2604 symbol_table::release_symbol (cgraph_node *node, int uid)
2606 cgraph_count--;
2608 /* Clear out the node to NULL all pointers and add the node to the free
2609 list. */
2610 memset (node, 0, sizeof (*node));
2611 node->type = SYMTAB_FUNCTION;
2612 node->uid = uid;
2613 SET_NEXT_FREE_NODE (node, free_nodes);
2614 free_nodes = node;
2617 /* Allocate new callgraph node. */
2619 inline cgraph_node *
2620 symbol_table::allocate_cgraph_symbol (void)
2622 cgraph_node *node;
2624 if (free_nodes)
2626 node = free_nodes;
2627 free_nodes = NEXT_FREE_NODE (node);
2629 else
2631 node = ggc_cleared_alloc<cgraph_node> ();
2632 node->uid = cgraph_max_uid++;
2635 node->summary_uid = cgraph_max_summary_uid++;
2636 return node;
2640 /* Return first static symbol with definition. */
2641 inline symtab_node *
2642 symbol_table::first_symbol (void)
2644 return nodes;
2647 /* Walk all symbols. */
2648 #define FOR_EACH_SYMBOL(node) \
2649 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2651 /* Return first static symbol with definition. */
2652 inline symtab_node *
2653 symbol_table::first_defined_symbol (void)
2655 symtab_node *node;
2657 for (node = nodes; node; node = node->next)
2658 if (node->definition)
2659 return node;
2661 return NULL;
2664 /* Walk all symbols with definitions in current unit. */
2665 #define FOR_EACH_DEFINED_SYMBOL(node) \
2666 for ((node) = symtab->first_defined_symbol (); (node); \
2667 (node) = node->next_defined_symbol ())
2669 /* Return first variable. */
2670 inline varpool_node *
2671 symbol_table::first_variable (void)
2673 symtab_node *node;
2674 for (node = nodes; node; node = node->next)
2675 if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
2676 return vnode;
2677 return NULL;
2680 /* Return next variable after NODE. */
2681 inline varpool_node *
2682 symbol_table::next_variable (varpool_node *node)
2684 symtab_node *node1 = node->next;
2685 for (; node1; node1 = node1->next)
2686 if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
2687 return vnode1;
2688 return NULL;
2690 /* Walk all variables. */
2691 #define FOR_EACH_VARIABLE(node) \
2692 for ((node) = symtab->first_variable (); \
2693 (node); \
2694 (node) = symtab->next_variable ((node)))
2696 /* Return first static variable with initializer. */
2697 inline varpool_node *
2698 symbol_table::first_static_initializer (void)
2700 symtab_node *node;
2701 for (node = nodes; node; node = node->next)
2703 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2704 if (vnode && DECL_INITIAL (node->decl))
2705 return vnode;
2707 return NULL;
2710 /* Return next static variable with initializer after NODE. */
2711 inline varpool_node *
2712 symbol_table::next_static_initializer (varpool_node *node)
2714 symtab_node *node1 = node->next;
2715 for (; node1; node1 = node1->next)
2717 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2718 if (vnode1 && DECL_INITIAL (node1->decl))
2719 return vnode1;
2721 return NULL;
2724 /* Walk all static variables with initializer set. */
2725 #define FOR_EACH_STATIC_INITIALIZER(node) \
2726 for ((node) = symtab->first_static_initializer (); (node); \
2727 (node) = symtab->next_static_initializer (node))
2729 /* Return first static variable with definition. */
2730 inline varpool_node *
2731 symbol_table::first_defined_variable (void)
2733 symtab_node *node;
2734 for (node = nodes; node; node = node->next)
2736 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2737 if (vnode && vnode->definition)
2738 return vnode;
2740 return NULL;
2743 /* Return next static variable with definition after NODE. */
2744 inline varpool_node *
2745 symbol_table::next_defined_variable (varpool_node *node)
2747 symtab_node *node1 = node->next;
2748 for (; node1; node1 = node1->next)
2750 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2751 if (vnode1 && vnode1->definition)
2752 return vnode1;
2754 return NULL;
2756 /* Walk all variables with definitions in current unit. */
2757 #define FOR_EACH_DEFINED_VARIABLE(node) \
2758 for ((node) = symtab->first_defined_variable (); (node); \
2759 (node) = symtab->next_defined_variable (node))
2761 /* Return first function with body defined. */
2762 inline cgraph_node *
2763 symbol_table::first_defined_function (void)
2765 symtab_node *node;
2766 for (node = nodes; node; node = node->next)
2768 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2769 if (cn && cn->definition)
2770 return cn;
2772 return NULL;
2775 /* Return next function with body defined after NODE. */
2776 inline cgraph_node *
2777 symbol_table::next_defined_function (cgraph_node *node)
2779 symtab_node *node1 = node->next;
2780 for (; node1; node1 = node1->next)
2782 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2783 if (cn1 && cn1->definition)
2784 return cn1;
2786 return NULL;
2789 /* Walk all functions with body defined. */
2790 #define FOR_EACH_DEFINED_FUNCTION(node) \
2791 for ((node) = symtab->first_defined_function (); (node); \
2792 (node) = symtab->next_defined_function ((node)))
2794 /* Return first function. */
2795 inline cgraph_node *
2796 symbol_table::first_function (void)
2798 symtab_node *node;
2799 for (node = nodes; node; node = node->next)
2800 if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
2801 return cn;
2802 return NULL;
2805 /* Return next function. */
2806 inline cgraph_node *
2807 symbol_table::next_function (cgraph_node *node)
2809 symtab_node *node1 = node->next;
2810 for (; node1; node1 = node1->next)
2811 if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
2812 return cn1;
2813 return NULL;
2816 /* Return first function with body defined. */
2817 inline cgraph_node *
2818 symbol_table::first_function_with_gimple_body (void)
2820 symtab_node *node;
2821 for (node = nodes; node; node = node->next)
2823 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2824 if (cn && cn->has_gimple_body_p ())
2825 return cn;
2827 return NULL;
2830 /* Return next reachable static variable with initializer after NODE. */
2831 inline cgraph_node *
2832 symbol_table::next_function_with_gimple_body (cgraph_node *node)
2834 symtab_node *node1 = node->next;
2835 for (; node1; node1 = node1->next)
2837 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2838 if (cn1 && cn1->has_gimple_body_p ())
2839 return cn1;
2841 return NULL;
2844 /* Walk all functions. */
2845 #define FOR_EACH_FUNCTION(node) \
2846 for ((node) = symtab->first_function (); (node); \
2847 (node) = symtab->next_function ((node)))
2849 /* Return true when callgraph node is a function with Gimple body defined
2850 in current unit. Functions can also be define externally or they
2851 can be thunks with no Gimple representation.
2853 Note that at WPA stage, the function body may not be present in memory. */
2855 inline bool
2856 cgraph_node::has_gimple_body_p (void)
2858 return definition && !thunk.thunk_p && !alias;
2861 /* Walk all functions with body defined. */
2862 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2863 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2864 (node) = symtab->next_function_with_gimple_body (node))
2866 /* Uniquize all constants that appear in memory.
2867 Each constant in memory thus far output is recorded
2868 in `const_desc_table'. */
2870 struct GTY((for_user)) constant_descriptor_tree {
2871 /* A MEM for the constant. */
2872 rtx rtl;
2874 /* The value of the constant. */
2875 tree value;
2877 /* Hash of value. Computing the hash from value each time
2878 hashfn is called can't work properly, as that means recursive
2879 use of the hash table during hash table expansion. */
2880 hashval_t hash;
2883 /* Return true when function is only called directly or it has alias.
2884 i.e. it is not externally visible, address was not taken and
2885 it is not used in any other non-standard way. */
2887 inline bool
2888 cgraph_node::only_called_directly_or_aliased_p (void)
2890 gcc_assert (!global.inlined_to);
2891 return (!force_output && !address_taken
2892 && !ifunc_resolver
2893 && !used_from_other_partition
2894 && !DECL_VIRTUAL_P (decl)
2895 && !DECL_STATIC_CONSTRUCTOR (decl)
2896 && !DECL_STATIC_DESTRUCTOR (decl)
2897 && !used_from_object_file_p ()
2898 && !externally_visible);
2901 /* Return true when function can be removed from callgraph
2902 if all direct calls are eliminated. */
2904 inline bool
2905 cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
2907 gcc_checking_assert (!global.inlined_to);
2908 /* Instrumentation clones should not be removed before
2909 instrumentation happens. New callers may appear after
2910 instrumentation. */
2911 if (instrumentation_clone
2912 && !chkp_function_instrumented_p (decl))
2913 return false;
2914 /* Extern inlines can always go, we will use the external definition. */
2915 if (DECL_EXTERNAL (decl))
2916 return true;
2917 /* When function is needed, we can not remove it. */
2918 if (force_output || used_from_other_partition)
2919 return false;
2920 if (DECL_STATIC_CONSTRUCTOR (decl)
2921 || DECL_STATIC_DESTRUCTOR (decl))
2922 return false;
2923 /* Only COMDAT functions can be removed if externally visible. */
2924 if (externally_visible
2925 && (!DECL_COMDAT (decl)
2926 || forced_by_abi
2927 || used_from_object_file_p ()))
2928 return false;
2929 return true;
2932 /* Verify cgraph, if consistency checking is enabled. */
2934 inline void
2935 cgraph_node::checking_verify_cgraph_nodes (void)
2937 if (flag_checking)
2938 cgraph_node::verify_cgraph_nodes ();
2941 /* Return true when variable can be removed from variable pool
2942 if all direct calls are eliminated. */
2944 inline bool
2945 varpool_node::can_remove_if_no_refs_p (void)
2947 if (DECL_EXTERNAL (decl))
2948 return true;
2949 return (!force_output && !used_from_other_partition
2950 && ((DECL_COMDAT (decl)
2951 && !forced_by_abi
2952 && !used_from_object_file_p ())
2953 || !externally_visible
2954 || DECL_HAS_VALUE_EXPR_P (decl)));
2957 /* Return true when all references to variable must be visible in ipa_ref_list.
2958 i.e. if the variable is not externally visible or not used in some magic
2959 way (asm statement or such).
2960 The magic uses are all summarized in force_output flag. */
2962 inline bool
2963 varpool_node::all_refs_explicit_p ()
2965 return (definition
2966 && !externally_visible
2967 && !used_from_other_partition
2968 && !force_output);
2971 struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
2973 static hashval_t hash (constant_descriptor_tree *);
2974 static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
2977 /* Constant pool accessor function. */
2978 hash_table<tree_descriptor_hasher> *constant_pool_htab (void);
2980 /* Return node that alias is aliasing. */
2982 inline cgraph_node *
2983 cgraph_node::get_alias_target (void)
2985 return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
2988 /* Return node that alias is aliasing. */
2990 inline varpool_node *
2991 varpool_node::get_alias_target (void)
2993 return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
2996 /* Walk the alias chain to return the symbol NODE is alias of.
2997 If NODE is not an alias, return NODE.
2998 When AVAILABILITY is non-NULL, get minimal availability in the chain.
2999 When REF is non-NULL, assume that reference happens in symbol REF
3000 when determining the availability. */
3002 inline symtab_node *
3003 symtab_node::ultimate_alias_target (enum availability *availability,
3004 symtab_node *ref)
3006 if (!alias)
3008 if (availability)
3009 *availability = get_availability (ref);
3010 return this;
3013 return ultimate_alias_target_1 (availability, ref);
3016 /* Given function symbol, walk the alias chain to return the function node
3017 is alias of. Do not walk through thunks.
3018 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3019 When REF is non-NULL, assume that reference happens in symbol REF
3020 when determining the availability. */
3022 inline cgraph_node *
3023 cgraph_node::ultimate_alias_target (enum availability *availability,
3024 symtab_node *ref)
3026 cgraph_node *n = dyn_cast <cgraph_node *>
3027 (symtab_node::ultimate_alias_target (availability, ref));
3028 if (!n && availability)
3029 *availability = AVAIL_NOT_AVAILABLE;
3030 return n;
3033 /* For given variable pool node, walk the alias chain to return the function
3034 the variable is alias of. Do not walk through thunks.
3035 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3036 When REF is non-NULL, assume that reference happens in symbol REF
3037 when determining the availability. */
3039 inline varpool_node *
3040 varpool_node::ultimate_alias_target (availability *availability,
3041 symtab_node *ref)
3043 varpool_node *n = dyn_cast <varpool_node *>
3044 (symtab_node::ultimate_alias_target (availability, ref));
3046 if (!n && availability)
3047 *availability = AVAIL_NOT_AVAILABLE;
3048 return n;
3051 /* Set callee N of call graph edge and add it to the corresponding set of
3052 callers. */
3054 inline void
3055 cgraph_edge::set_callee (cgraph_node *n)
3057 prev_caller = NULL;
3058 if (n->callers)
3059 n->callers->prev_caller = this;
3060 next_caller = n->callers;
3061 n->callers = this;
3062 callee = n;
3065 /* Redirect callee of the edge to N. The function does not update underlying
3066 call expression. */
3068 inline void
3069 cgraph_edge::redirect_callee (cgraph_node *n)
3071 /* Remove from callers list of the current callee. */
3072 remove_callee ();
3074 /* Insert to callers list of the new callee. */
3075 set_callee (n);
3078 /* Return true when the edge represents a direct recursion. */
3080 inline bool
3081 cgraph_edge::recursive_p (void)
3083 cgraph_node *c = callee->ultimate_alias_target ();
3084 if (caller->global.inlined_to)
3085 return caller->global.inlined_to->decl == c->decl;
3086 else
3087 return caller->decl == c->decl;
3090 /* Remove the edge from the list of the callers of the callee. */
3092 inline void
3093 cgraph_edge::remove_callee (void)
3095 gcc_assert (!indirect_unknown_callee);
3096 if (prev_caller)
3097 prev_caller->next_caller = next_caller;
3098 if (next_caller)
3099 next_caller->prev_caller = prev_caller;
3100 if (!prev_caller)
3101 callee->callers = next_caller;
3104 /* Return true if call must bind to current definition. */
3106 inline bool
3107 cgraph_edge::binds_to_current_def_p ()
3109 if (callee)
3110 return callee->binds_to_current_def_p (caller);
3111 else
3112 return false;
3115 /* Expected frequency of executions within the function.
3116 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
3117 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
3119 inline int
3120 cgraph_edge::frequency ()
3122 return count.to_cgraph_frequency (caller->global.inlined_to
3123 ? caller->global.inlined_to->count
3124 : caller->count);
3128 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
3129 static inline bool
3130 decl_is_tm_clone (const_tree fndecl)
3132 cgraph_node *n = cgraph_node::get (fndecl);
3133 if (n)
3134 return n->tm_clone;
3135 return false;
3138 /* Likewise indicate that a node is needed, i.e. reachable via some
3139 external means. */
3141 inline void
3142 cgraph_node::mark_force_output (void)
3144 force_output = 1;
3145 gcc_checking_assert (!global.inlined_to);
3148 /* Return true if function should be optimized for size. */
3150 inline bool
3151 cgraph_node::optimize_for_size_p (void)
3153 if (opt_for_fn (decl, optimize_size))
3154 return true;
3155 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
3156 return true;
3157 else
3158 return false;
3161 /* Return symtab_node for NODE or create one if it is not present
3162 in symtab. */
3164 inline symtab_node *
3165 symtab_node::get_create (tree node)
3167 if (TREE_CODE (node) == VAR_DECL)
3168 return varpool_node::get_create (node);
3169 else
3170 return cgraph_node::get_create (node);
3173 /* Return availability of NODE when referenced from REF. */
3175 inline enum availability
3176 symtab_node::get_availability (symtab_node *ref)
3178 if (is_a <cgraph_node *> (this))
3179 return dyn_cast <cgraph_node *> (this)->get_availability (ref);
3180 else
3181 return dyn_cast <varpool_node *> (this)->get_availability (ref);
3184 /* Call calback on symtab node and aliases associated to this node.
3185 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3187 inline bool
3188 symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *,
3189 void *),
3190 void *data,
3191 bool include_overwritable)
3193 if (include_overwritable
3194 || get_availability () > AVAIL_INTERPOSABLE)
3196 if (callback (this, data))
3197 return true;
3199 if (has_aliases_p ())
3200 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3201 return false;
3204 /* Call callback on function and aliases associated to the function.
3205 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3206 skipped. */
3208 inline bool
3209 cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
3210 void *),
3211 void *data,
3212 bool include_overwritable)
3214 if (include_overwritable
3215 || get_availability () > AVAIL_INTERPOSABLE)
3217 if (callback (this, data))
3218 return true;
3220 if (has_aliases_p ())
3221 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3222 return false;
3225 /* Call calback on varpool symbol and aliases associated to varpool symbol.
3226 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3227 skipped. */
3229 inline bool
3230 varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
3231 void *),
3232 void *data,
3233 bool include_overwritable)
3235 if (include_overwritable
3236 || get_availability () > AVAIL_INTERPOSABLE)
3238 if (callback (this, data))
3239 return true;
3241 if (has_aliases_p ())
3242 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3243 return false;
3246 /* Return true if refernece may be used in address compare. */
3248 inline bool
3249 ipa_ref::address_matters_p ()
3251 if (use != IPA_REF_ADDR)
3252 return false;
3253 /* Addresses taken from virtual tables are never compared. */
3254 if (is_a <varpool_node *> (referring)
3255 && DECL_VIRTUAL_P (referring->decl))
3256 return false;
3257 return referred->address_can_be_compared_p ();
3260 /* Build polymorphic call context for indirect call E. */
3262 inline
3263 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
3265 gcc_checking_assert (e->indirect_info->polymorphic);
3266 *this = e->indirect_info->context;
3269 /* Build empty "I know nothing" context. */
3271 inline
3272 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3274 clear_speculation ();
3275 clear_outer_type ();
3276 invalid = false;
3279 /* Make context non-speculative. */
3281 inline void
3282 ipa_polymorphic_call_context::clear_speculation ()
3284 speculative_outer_type = NULL;
3285 speculative_offset = 0;
3286 speculative_maybe_derived_type = false;
3289 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
3290 NULL, the context is set to dummy "I know nothing" setting. */
3292 inline void
3293 ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
3295 outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
3296 offset = 0;
3297 maybe_derived_type = true;
3298 maybe_in_construction = true;
3299 dynamic = true;
3302 /* Adjust all offsets in contexts by OFF bits. */
3304 inline void
3305 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off)
3307 if (outer_type)
3308 offset += off;
3309 if (speculative_outer_type)
3310 speculative_offset += off;
3313 /* Return TRUE if context is fully useless. */
3315 inline bool
3316 ipa_polymorphic_call_context::useless_p () const
3318 return (!outer_type && !speculative_outer_type);
3321 /* Return true if NODE is local. Instrumentation clones are counted as local
3322 only when original function is local. */
3324 static inline bool
3325 cgraph_local_p (cgraph_node *node)
3327 if (!node->instrumentation_clone || !node->instrumented_version)
3328 return node->local.local;
3330 return node->local.local && node->instrumented_version->local.local;
3333 /* When using fprintf (or similar), problems can arise with
3334 transient generated strings. Many string-generation APIs
3335 only support one result being alive at once (e.g. by
3336 returning a pointer to a statically-allocated buffer).
3338 If there is more than one generated string within one
3339 fprintf call: the first string gets evicted or overwritten
3340 by the second, before fprintf is fully evaluated.
3341 See e.g. PR/53136.
3343 This function provides a workaround for this, by providing
3344 a simple way to create copies of these transient strings,
3345 without the need to have explicit cleanup:
3347 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3348 xstrdup_for_dump (EXPR_1),
3349 xstrdup_for_dump (EXPR_2));
3351 This is actually a simple wrapper around ggc_strdup, but
3352 the name documents the intent. We require that no GC can occur
3353 within the fprintf call. */
3355 static inline const char *
3356 xstrdup_for_dump (const char *transient_str)
3358 return ggc_strdup (transient_str);
3361 #endif /* GCC_CGRAPH_H */