GCC Middle and Back End API Reference
cgraph.h
Go to the documentation of this file.
1/* Callgraph handling code.
2 Copyright (C) 2003-2026 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#ifndef GCC_CGRAPH_H
22#define GCC_CGRAPH_H
23
24#include "profile-count.h"
25#include "ipa-ref.h"
26#include "plugin-api.h"
28
29extern void debuginfo_early_init (void);
30extern void debuginfo_init (void);
31extern void debuginfo_fini (void);
32extern void debuginfo_start (void);
33extern void debuginfo_stop (void);
34extern void debuginfo_early_start (void);
35extern void debuginfo_early_stop (void);
36
37class ipa_opt_pass_d;
39
40/* Toplevel consists of functions, variables and assembly.
41 Make sure toplevel_type_names in symtab.cc is kept in sync
42 with this.
43 TODO: add labels and CONST_DECLs. */
53
54/* Section names are stored as reference counted strings in GGC safe hashtable
55 (to make them survive through PCH). */
56
57struct GTY((for_user)) section_hash_entry
58{
60 char *name; /* As long as this datastructure stays in GGC, we cannot put
61 string at the tail of structure of GGC dies in horrible
62 way */
63};
64
65struct section_name_hasher : ggc_ptr_hash<section_hash_entry>
66{
67 typedef const char *compare_type;
68
69 static hashval_t hash (section_hash_entry *);
70 static bool equal (section_hash_entry *, const char *);
71};
72
74{
75 /* Not yet set by cgraph_function_body_availability. */
77 /* Function body/variable initializer is unknown. */
79 /* Function body/variable initializer is known but might be replaced
80 by a different one from other compilation unit and thus needs to
81 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
82 arbitrary side effects on escaping variables and functions, while
83 like AVAILABLE it might access static variables. */
85 /* Function body/variable initializer is known and will be used in final
86 program. */
88 /* Function body/variable initializer is known and all it's uses are
89 explicitly visible within current unit (i.e. it's address is never taken
90 and it is not exported to other units). Currently used only for
91 functions. */
93};
94
95/* Classification of symbols WRT partitioning. */
97{
98 /* External declarations are ignored by partitioning algorithms and they are
99 added into the boundary later via compute_ltrans_boundary. */
101 /* Partitioned symbols are put into one of partitions. */
103 /* Duplicated symbols (such as comdat or constant pool references) are
104 copied into every node needing them via add_symbol_to_partition. */
106};
107
108/* Base of all toplevel entries.
109 Inherited by symtab_node and asm_node. */
110struct GTY ((desc ("%h.type"), tag ("TOPLEVEL_BASE"),
111 chain_next("%h.next"),
112 chain_prev("%h.previous"))) toplevel_node {
113 /* Constructor. */
114 explicit toplevel_node (toplevel_type t)
115 : lto_file_data (NULL), order (-1), type (t)
116 {}
118 /* File stream where this node is being written to. */
121 /* Linked list of toplevel entries. */
122 toplevel_node *next = nullptr;
123 toplevel_node *previous = nullptr;
125 /* Ordering of all cgraph nodes. */
126 int order;
128 /* Type of the node. */
129 enum toplevel_type type : 8;
130};
131
132/* Base of all entries in the symbol table.
133 The symtab_node is inherited by cgraph and varpol nodes. */
134struct GTY ((tag ("SYMTAB_SYMBOL")))
136{
137public:
159 {}
160
161 /* Return name. */
162 const char *name () const;
163
164 /* Return dump name. */
165 const char *dump_name () const;
166
167 /* Return asm name. */
168 const char *asm_name () const;
169
170 /* Return dump name with assembler name. */
171 const char *dump_asm_name () const;
172
173 /* Return visibility name. */
174 const char *get_visibility_string () const;
175
176 /* Return type_name name. */
177 const char *get_symtab_type_string () const;
178
179 /* Add node into symbol table. This function is not used directly, but via
180 cgraph/varpool node creation routines. */
181 void register_symbol (void);
182
183 /* Remove symbol from symbol table. */
184 void remove (void);
185
186 /* Undo any definition or use of the symbol. */
187 void reset (bool preserve_comdat_group = false);
188
189 /* Dump symtab node to F. */
190 void dump (FILE *f);
191
192 /* Dump symtab callgraph in graphviz format. */
193 void dump_graphviz (FILE *f);
194
195 /* Dump symtab node to stderr. */
196 void DEBUG_FUNCTION debug (void);
197
198 /* Verify consistency of node. */
199 void DEBUG_FUNCTION verify (void);
200
201 /* Return ipa reference from this symtab_node to
202 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
203 of the use and STMT the statement (if it exists). */
204 ipa_ref *create_reference (symtab_node *referred_node,
205 enum ipa_ref_use use_type);
206
207 /* Return ipa reference from this symtab_node to
208 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
209 of the use and STMT the statement (if it exists). */
210 ipa_ref *create_reference (symtab_node *referred_node,
211 enum ipa_ref_use use_type, gimple *stmt);
212
213 /* If VAL is a reference to a function or a variable, add a reference from
214 this symtab_node to the corresponding symbol table node. Return the new
215 reference or NULL if none was created. */
216 ipa_ref *maybe_create_reference (tree val, gimple *stmt);
217
218 /* Clone all references from symtab NODE to this symtab_node. */
219 void clone_references (symtab_node *node);
220
221 /* Remove all stmt references in non-speculative references.
222 Those are not maintained during inlining & cloning.
223 The exception are speculative references that are updated along
224 with callgraph edges associated with them. */
225 void clone_referring (symtab_node *node);
226
227 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
228 ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt);
229
230 /* Find the structure describing a reference to REFERRED_NODE of USE_TYPE and
231 associated with statement STMT or LTO_STMT_UID. */
232 ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt,
233 unsigned int lto_stmt_uid,
234 enum ipa_ref_use use_type);
235
236 /* Remove all references that are associated with statement STMT. */
237 void remove_stmt_references (gimple *stmt);
238
239 /* Remove all stmt references in non-speculative references.
240 Those are not maintained during inlining & cloning.
241 The exception are speculative references that are updated along
242 with callgraph edges associated with them. */
243 void clear_stmts_in_references (void);
244
245 /* Remove all references in ref list. */
246 void remove_all_references (void);
247
248 /* Remove all referring items in ref list. */
249 void remove_all_referring (void);
250
251 /* Dump references in ref list to FILE. */
252 void dump_references (FILE *file);
253
254 /* Dump referring in list to FILE. */
255 void dump_referring (FILE *);
256
257 /* Get number of references for this node. */
258 inline unsigned num_references (void)
259 {
260 return ref_list.references.length ();
261 }
262
263 /* Iterates I-th reference in the list, REF is also set. */
264 ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);
265
266 /* Iterates I-th referring item in the list, REF is also set. */
267 ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);
268
269 /* Iterates I-th referring alias item in the list, REF is also set. */
270 ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref);
271
272 /* Return true if symtab node and TARGET represents
273 semantically equivalent symbols. */
274 bool semantically_equivalent_p (symtab_node *target);
275
276 /* Classify symbol symtab node for partitioning. */
278
279 /* Return comdat group. */
281 {
282 return x_comdat_group;
284
285 /* Return comdat group as identifier_node. */
286 tree get_comdat_group_id ()
287 {
288 if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE)
289 x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group);
290 return x_comdat_group;
292
293 /* Set comdat group. */
294 void set_comdat_group (tree group)
295 {
296 gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
297 || DECL_P (group));
298 x_comdat_group = group;
300
301 /* Return section as string. */
302 const char * get_section () const
303 {
304 if (!x_section)
305 return NULL;
306 return x_section->name;
307 }
308
309 /* Remove node from same comdat group. */
310 void remove_from_same_comdat_group (void);
311
312 /* Add this symtab_node to the same comdat group that OLD is in. */
313 void add_to_same_comdat_group (symtab_node *old_node);
314
315 /* Dissolve the same_comdat_group list in which NODE resides. */
316 void dissolve_same_comdat_group_list (void);
317
318 /* Return true when symtab_node is known to be used from other (non-LTO)
319 object file. Known only when doing LTO via linker plugin. */
320 bool used_from_object_file_p (void);
321
322 /* Walk the alias chain to return the symbol NODE is alias of.
323 If NODE is not an alias, return NODE.
324 When AVAILABILITY is non-NULL, get minimal availability in the chain.
325 When REF is non-NULL, assume that reference happens in symbol REF
326 when determining the availability. */
327 symtab_node *ultimate_alias_target (enum availability *avail = NULL,
328 struct symtab_node *ref = NULL);
329
330 /* Return next reachable static symbol with initializer after NODE. */
331 inline symtab_node *next_defined_symbol (void);
332
333 /* Add reference recording that symtab node is alias of TARGET.
334 If TRANSPARENT is true make the alias to be transparent alias.
335 The function can fail in the case of aliasing cycles; in this case
336 it returns false. */
337 bool resolve_alias (symtab_node *target, bool transparent = false);
338
339 /* C++ FE sometimes change linkage flags after producing same
340 body aliases. */
341 void fixup_same_cpp_alias_visibility (symtab_node *target);
342
343 /* Call callback on symtab node and aliases associated to this node.
344 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
345 skipped. */
346 bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
347 void *data,
348 bool include_overwrite);
349
350 /* If node cannot be interposable by static or dynamic linker to point to
351 different definition, return this symbol. Otherwise look for alias with
352 such property and if none exists, introduce new one. */
353 symtab_node *noninterposable_alias (void);
354
355 /* Return node that alias is aliasing. */
356 inline symtab_node *get_alias_target (void);
357
358 /* Return DECL that alias is aliasing. */
359 inline tree get_alias_target_tree ();
360
361 /* Set section for symbol and its aliases. */
362 void set_section (const char *section);
363
364 /* Like set_section, but copying the section name from another node. */
365 void set_section (const symtab_node &other);
366
367 /* Set section, do not recurse into aliases.
368 When one wants to change section of symbol and its aliases,
369 use set_section. */
370 void set_section_for_node (const char *section);
371
372 /* Like set_section_for_node, but copying the section name from another
373 node. */
374 void set_section_for_node (const symtab_node &other);
375
376 /* Set initialization priority to PRIORITY. */
377 void set_init_priority (priority_type priority);
378
379 /* Return the initialization priority. */
380 priority_type get_init_priority ();
381
382 /* Return availability of NODE when referenced from REF. */
383 enum availability get_availability (symtab_node *ref = NULL);
384
385 /* During LTO stream-in this predicate can be used to check whether node
386 in question prevails in the linking to save some memory usage. */
387 bool prevailing_p (void);
388
389 /* Return true if NODE binds to current definition in final executable
390 when referenced from REF. If REF is NULL return conservative value
391 for any reference. */
392 bool binds_to_current_def_p (symtab_node *ref = NULL);
393
394 /* Make DECL local. */
395 void make_decl_local (void);
396
397 /* Copy visibility from N. */
398 void copy_visibility_from (symtab_node *n);
399
400 /* Return desired alignment of the definition. This is NOT alignment useful
401 to access THIS, because THIS may be interposable and DECL_ALIGN should
402 be used instead. It however must be guaranteed when output definition
403 of THIS. */
404 unsigned int definition_alignment ();
405
406 /* Return true if alignment can be increased. */
407 bool can_increase_alignment_p ();
408
409 /* Increase alignment of symbol to ALIGN. */
410 void increase_alignment (unsigned int align);
411
412 /* Return true if list contains an alias. */
413 bool has_aliases_p (void);
414
415 /* Return true when the symbol is real symbol, i.e. it is not inline clone
416 or abstract function kept for debug info purposes only. */
417 bool real_symbol_p (void);
418
419 /* Return true when the symbol needs to be output to the LTO symbol table. */
420 bool output_to_lto_symbol_table_p (void);
421
422 /* Determine if symbol declaration is needed. That is, visible to something
423 either outside this translation unit, something magic in the system
424 configury. This function is used just during symbol creation. */
425 bool needed_p (void);
426
427 /* Return true if this symbol is a function from the C frontend specified
428 directly in RTL form (with "__RTL"). */
429 bool native_rtl_p () const;
430
431 /* Return true when there are references to the node. */
432 bool referred_to_p (bool include_self = true);
433
434 /* Return true if symbol can be discarded by linker from the binary.
435 Assume that symbol is used (so there is no need to take into account
436 garbage collecting linkers)
437
438 This can happen for comdats, commons and weaks when they are prevailed
439 by other definition at static linking time. */
440 inline bool
441 can_be_discarded_p (void)
442 {
443 return ((DECL_EXTERNAL (decl)
445 || ((get_comdat_group ()
446 || DECL_COMMON (decl)
448 && ((resolution != LDPR_PREVAILING_DEF
449 && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
450 || flag_incremental_link)
451 && resolution != LDPR_PREVAILING_DEF_IRONLY));
452 }
453
454 /* Return true if NODE is local to a particular COMDAT group, and must not
455 be named from outside the COMDAT. This is used for C++ decloned
456 constructors. */
457 inline bool comdat_local_p (void)
458 {
459 return (same_comdat_group && !TREE_PUBLIC (decl));
460 }
461
462 /* Return true if ONE and TWO are part of the same COMDAT group. */
463 inline bool in_same_comdat_group_p (symtab_node *target);
464
465 /* Return true if symbol is known to be nonzero, assume that
466 flag_delete_null_pointer_checks is equal to delete_null_pointer_checks. */
467 bool nonzero_address (bool delete_null_pointer_checks);
468
469 /* Return true if symbol is known to be nonzero. */
470 bool nonzero_address ();
471
472 /* Return 0 if symbol is known to have different address than S2,
473 Return 1 if symbol is known to have same address as S2,
474 return 2 otherwise.
475
476 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
477 and S2 is going to be accessed. This eliminates the situations when
478 either THIS or S2 is NULL and is useful for comparing bases when deciding
479 about memory aliasing. */
480 int equal_address_to (symtab_node *s2, bool memory_accessed = false);
481
482 /* Return true if symbol's address may possibly be compared to other
483 symbol's address. */
484 bool address_matters_p ();
485
486 /* Return true if NODE's address can be compared. This use properties
487 of NODE only and does not look if the address is actually taken in
488 interesting way. For that use ADDRESS_MATTERS_P instead. */
489 bool address_can_be_compared_p (void);
491 /* Return symbol table node associated with DECL, if any,
492 and NULL otherwise. */
493 static inline symtab_node *get (const_tree decl)
494 {
495 /* Check that we are called for sane type of object - functions
496 and static or external variables. */
497 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
498 || (TREE_CODE (decl) == VAR_DECL
500 || in_lto_p)));
501 /* Check that the mapping is sane - perhaps this check can go away,
502 but at the moment frontends tends to corrupt the mapping by calling
503 memcpy/memset on the tree nodes. */
507 }
508
509 /* Try to find a symtab node for declaration DECL and if it does not
510 exist or if it corresponds to an inline clone, create a new one. */
511 static inline symtab_node * get_create (tree node);
512
513 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
514 Return NULL if there's no such node. */
515 static symtab_node *get_for_asmname (const_tree asmname);
516
517 /* Check symbol table for callees of IFUNC resolvers. */
518 static void check_ifunc_callee_symtab_nodes (void);
519
520 /* Verify symbol table for internal consistency. */
521 static DEBUG_FUNCTION void verify_symtab_nodes (void);
522
523 /* Perform internal consistency checks, if they are enabled. */
524 static inline void checking_verify_symtab_nodes (void);
525
526 /* Get unique identifier of the node. */
527 inline int get_uid () const
528 {
529 return m_uid;
531
532 /* The symbols resolution. */
533 enum ld_plugin_symbol_resolution resolution : 8;
534
535 /*** Flags representing the symbol type. ***/
537 /* True when symbol corresponds to a definition in current unit.
538 set via finalize_function or finalize_decl */
539 unsigned definition : 1;
540 /* True when symbol is an alias.
541 Set by assemble_alias. */
542 unsigned alias : 1;
543 /* When true the alias is translated into its target symbol either by GCC
544 or assembler (it also may just be a duplicate declaration of the same
545 linker name).
546
547 Currently transparent aliases come in three different flavors
548 - aliases having the same assembler name as their target (aka duplicated
549 declarations). In this case the assembler names compare via
550 assembler_names_equal_p and weakref is false
551 - aliases that are renamed at a time being output to final file
552 by varasm.cc. For those DECL_ASSEMBLER_NAME have
553 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
554 name must be unique.
555 Weakrefs belong to this category when we target assembler without
556 .weakref directive.
557 - weakrefs that are renamed by assembler via .weakref directive.
558 In this case the alias may or may not be definition (depending if
559 target declaration was seen by the compiler), weakref is set.
560 Unless we are before renaming statics, assembler names are different.
562 Given that we now support duplicate declarations, the second option is
563 redundant and will be removed. */
564 unsigned transparent_alias : 1;
565 /* True when alias is a weakref. */
566 unsigned weakref : 1;
567 /* C++ frontend produce same body aliases and extra name aliases for
568 virtual functions and vtables that are obviously equivalent.
569 Those aliases are bit special, especially because C++ frontend
570 visibility code is so ugly it cannot get them right at first time
571 and their visibility needs to be copied from their "masters" at
572 the end of parsing. */
573 unsigned cpp_implicit_alias : 1;
574 /* The alias is a symbol version. */
575 unsigned symver : 1;
576 /* Set once the definition was analyzed. The list of references and
577 other properties are built during analysis. */
578 unsigned analyzed : 1;
579 /* Set for write-only variables. */
580 unsigned writeonly : 1;
581 /* Visibility of symbol was used for further optimization; do not
582 permit further changes. */
583 unsigned refuse_visibility_changes : 1;
584
585 /*** Visibility and linkage flags. ***/
586
587 /* Set when function is visible by other units. */
588 unsigned externally_visible : 1;
589 /* Don't reorder to other symbols having this set. */
590 unsigned no_reorder : 1;
591 /* The symbol will be assumed to be used in an invisible way (like
592 by an toplevel asm statement). */
593 unsigned force_output : 1;
594 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
595 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
596 to static and it does not inhibit optimization. */
597 unsigned forced_by_abi : 1;
598 /* Referenced from toplevel assembly. Must not be removed.
599 Static symbol may be renamed. Global symbol should not be renamed.
600 Unlike force_output, can be on declarations. */
601 unsigned ref_by_asm : 1;
602 /* Set when asm_name must remain in TU partition.
603 Used to guarantee not renaming of static ref_by_asm symbols. */
605 /* Set when body (or any references) must remain in TU partition.
606 Used on symbols referring/calling must_remain_in_tu_name. */
607 unsigned must_remain_in_tu_body : 1;
608 /* True when the name is known to be unique and thus it does not need mangling. */
609 unsigned unique_name : 1;
610 /* Specify whether the section was set by user or by
611 compiler via -ffunction-sections. */
612 unsigned implicit_section : 1;
613 /* True when body and other characteristics have been removed by
614 symtab_remove_unreachable_nodes. */
615 unsigned body_removed : 1;
616 /* True when symbol should comply to -fsemantic-interposition flag. */
617 unsigned semantic_interposition : 1;
618
619 /*** WHOPR Partitioning flags.
620 These flags are used at ltrans stage when only part of the callgraph is
621 available. ***/
622
623 /* Set when variable is used from other LTRANS partition. */
624 unsigned used_from_other_partition : 1;
625 /* Set when function is available in the other LTRANS partition.
626 During WPA output it is used to mark nodes that are present in
627 multiple partitions. */
628 unsigned in_other_partition : 1;
629
630
631
632 /*** other flags. ***/
633
634 /* Set when symbol has address taken. */
635 unsigned address_taken : 1;
636 /* Set when init priority is set. */
637 unsigned in_init_priority_hash : 1;
639 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
640 of offloading, for separate compilation for a different target. */
641 unsigned need_lto_streaming : 1;
642
643 /* Set when symbol can be streamed into bytecode for offloading. */
644 unsigned offloadable : 1;
645
646 /* Set when symbol is an IFUNC resolver. */
647 unsigned ifunc_resolver : 1;
649
650 /* Declaration representing the symbol. */
651 tree decl;
652
653 /* Linked list of symbols with the same asm name. There may be multiple
654 entries for single symbol name during LTO, because symbols are renamed
655 only after partitioning.
656
657 Because inline clones are kept in the assembler name has, they also produce
658 duplicate entries.
660 There are also several long standing bugs where frontends and builtin
661 code produce duplicated decls. */
664
665 /* Circular list of nodes in the same comdat group if non-NULL. */
667
668 /* Vectors of referring and referenced entities. */
669 ipa_ref_list GTY((skip)) ref_list;
670
671 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
672 depending to what was known to frontend on the creation time.
673 Once alias is resolved, this pointer become NULL. */
675
676 void *GTY ((skip)) aux;
677
678 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
680
681 /* Section name. Again can be private, if allowed. */
683
684protected:
685 /* Dump base fields of symtab nodes to F. Not to be used directly. */
686 void dump_base (FILE *);
687
688 /* Verify common part of symtab node. */
689 bool DEBUG_FUNCTION verify_base (void);
690
691 /* Remove node from symbol table. This function is not used directly, but via
692 cgraph/varpool node removal routines. */
693 void unregister (struct clone_info *);
694
695 /* Return the initialization and finalization priority information for
696 DECL. If there is no previous priority information, a freshly
697 allocated structure is returned. */
698 struct symbol_priority_map *priority_info (void);
699
700 /* Worker for call_for_symbol_and_aliases_1. */
701 bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
702 void *data,
703 bool include_overwrite);
704private:
705 /* Unique id of the node. */
706 int m_uid;
707
708 /* Workers for set_section. */
709 static bool set_section_from_string (symtab_node *n, void *s);
710 static bool set_section_from_node (symtab_node *n, void *o);
711
712 /* Worker for symtab_resolve_alias. */
713 static bool set_implicit_section (symtab_node *n, void *);
714
715 /* Worker searching noninterposable alias. */
716 static bool noninterposable_alias (symtab_node *node, void *data);
717
718 /* Worker for ultimate_alias_target. */
720 symtab_node *ref = NULL);
721
722 /* Get dump name with normal or assembly name. */
723 const char *get_dump_name (bool asm_name_p) const;
725
726inline void
728{
729 if (flag_checking)
732
733/* Walk all aliases for NODE. */
734#define FOR_EACH_ALIAS(NODE, ALIAS) \
735 for (unsigned ALIAS##_iter_ = 0; \
736 (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS); \
737 ALIAS##_iter_++)
738
739/* This is the information that is put into the cgraph local structure
740 to recover a function. */
741struct lto_file_decl_data;
742
743extern const char * const cgraph_availability_names[];
744extern const char * const ld_plugin_symbol_resolution_names[];
745extern const char * const tls_model_names[];
747/* Represent which DECL tree (or reference to such tree)
748 will be replaced by another tree while versioning. */
750{
751 /* The new (replacing) tree. */
753 /* Parameter number to replace, when old_tree is NULL. */
754 int parm_num;
755 /* Set if the newly added reference should not be an address one, but a load
756 one from the operand of the ADDR_EXPR in NEW_TREE. This is for cases when
757 the corresponding parameter p is used only as *p. */
777};
778
779/* Function arguments in the original function of a SIMD clone.
780 Supplementary data for `struct simd_clone'. */
781
783 /* Original function argument as it originally existed in
784 DECL_ARGUMENTS. */
787 /* orig_arg's function (or for extern functions type from
788 TYPE_ARG_TYPES). */
790
791 /* If argument is a vector, this holds the vector version of
792 orig_arg that after adjusting the argument types will live in
793 DECL_ARGUMENTS. Otherwise, this is NULL.
795 This basically holds:
796 vector(simdlen) __typeof__(orig_arg) new_arg. */
798
799 /* vector_arg's type (or for extern functions new vector type. */
801
802 /* If argument is a vector, this holds the array where the simd
803 argument is held while executing the simd clone function. This
804 is a local variable in the cloned function. Its content is
805 copied from vector_arg upon entry to the clone.
807 This basically holds:
808 __typeof__(orig_arg) simd_array[simdlen]. */
811 /* A SIMD clone's argument can be either linear (constant or
812 variable), uniform, or vector. */
814
815 /* Variable alignment if available, otherwise 0. */
816 unsigned int alignment;
817
818 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
819 the constant linear step, if arg_type is
820 SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
821 the uniform argument holding the step, otherwise 0.
822 For arg_type SIMD_CLONE_ARG_TYPE_MASK and a mask_mode that is
823 not VOIDmode, this is the number of mask arguments. */
824 HOST_WIDE_INT linear_step;
825};
827/* Specific data for a SIMD function clone. */
829struct GTY(()) cgraph_simd_clone {
830 /* Number of words in the SIMD lane associated with this clone. */
833 /* Number of annotated function arguments in `args'. This is
834 usually the number of named arguments in FNDECL. */
835 unsigned int nargs;
836
837 /* Max hardware vector size in bits for integral vectors. */
839
840 /* Max hardware vector size in bits for floating point vectors. */
842
843 /* Machine mode of the mask argument(s), if they are to be passed
844 as bitmasks in integer argument(s). VOIDmode if masks are passed
845 as vectors of characteristic type. */
846 machine_mode mask_mode;
847
848 /* The mangling character for a given vector size. This is used
849 to determine the ISA mangling bit as specified in the Intel
850 Vector ABI. */
851 unsigned char vecsize_mangle;
853 /* True if this is the masked, in-branch version of the clone,
854 otherwise false. */
855 unsigned int inbranch : 1;
856
857 /* Doubly linked list of SIMD clones. */
859
860 /* Original cgraph node the SIMD clones were created for. */
862
863 /* Annotated function arguments for the original function. */
864 cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
866
867/* Function Multiversioning info. */
868struct GTY((for_user)) cgraph_function_version_info {
869 /* The cgraph_node for which the function version info is stored. */
871 /* Chains all the semantically identical function versions. The
872 first function in this chain is the version_info node of the
873 default function. */
875 /* If this version node corresponds to a dispatcher for function
876 versions, this points to the version info node of the default
877 function, the first node in the chain. */
879 /* If this node corresponds to a function version, this points
880 to the dispatcher function decl, which is the function that must
881 be called to execute the right function version at run-time.
882
883 If this cgraph node is a dispatcher (if dispatcher_function is
884 true, in the cgraph_node struct) for function versions, this
885 points to resolver function, which holds the function body of the
886 dispatcher. The dispatcher decl is an alias to the resolver
887 function decl. */
889
890 /* The assmbly name of the function set before version mangling. */
891 tree assembler_name;
892};
893
894#define DEFCIFCODE(code, type, string) CIF_ ## code,
895/* Reasons for inlining failures. */
896
898#include "cif-code.def"
899 CIF_N_REASONS
900};
903{
906};
908struct cgraph_edge;
910struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
911{
912 typedef gimple *compare_type;
913
914 static hashval_t hash (cgraph_edge *);
915 static hashval_t hash (gimple *);
916 static bool equal (cgraph_edge *, gimple *);
917};
918
919/* The cgraph data structure.
920 Each function decl has assigned cgraph_node listing callees and callers. */
922struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
923{
924 friend class symbol_table;
925
926 /* Constructor. */
927 explicit cgraph_node ()
933 inlined_to (NULL), rtl (NULL),
934 count (profile_count::uninitialized ()),
935 count_materialization_scale (REG_BR_PROB_BASE), profile_id (0),
936 unit_id (0), tp_first_run (0), thunk (false),
937 used_as_abstract_origin (false),
938 lowered (false), process (false), frequency (NODE_FREQUENCY_NORMAL),
939 only_called_at_startup (false), only_called_at_exit (false),
940 tm_clone (false), dispatcher_function (false),
941 dispatcher_resolver_function (false), is_target_clone (false),
942 calls_comdat_local (false), icf_merged (false), assume_function (false),
943 nonfreeing_fn (false), merged_comdat (false),
944 merged_extern_inline (false), parallelized_function (false),
945 split_part (false), indirect_call_target (false), local (false),
946 versionable (false), can_change_signature (false),
947 redefined_extern_inline (false), tm_may_enter_irr (false),
948 ipcp_clone (false), gc_candidate (false),
949 called_by_ifunc_resolver (false), has_omp_variant_constructs (false),
950 m_summary_id (-1)
951 {}
952
953 /* Remove the node from cgraph and all inline clones inlined into it.
954 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
955 removed. This allows to call the function from outer loop walking clone
956 tree. */
957 bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
958
959 /* Record all references from cgraph_node that are taken
960 in statement STMT. */
961 void record_stmt_references (gimple *stmt);
962
963 /* Like cgraph_set_call_stmt but walk the clone tree and update all
964 clones sharing the same function body.
965 When WHOLE_SPECULATIVE_EDGES is true, all three components of
966 speculative edge gets updated. Otherwise we update only direct
967 call. */
968 void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
969 bool update_speculative = true);
970
971 /* Walk the alias chain to return the function cgraph_node is alias of.
972 Walk through thunk, too.
973 When AVAILABILITY is non-NULL, get minimal availability in the chain.
974 When REF is non-NULL, assume that reference happens in symbol REF
975 when determining the availability. */
976 cgraph_node *function_symbol (enum availability *avail = NULL,
977 struct symtab_node *ref = NULL);
978
979 /* Walk the alias chain to return the function cgraph_node is alias of.
980 Walk through non virtual thunks, too. Thus we return either a function
981 or a virtual thunk node.
982 When AVAILABILITY is non-NULL, get minimal availability in the chain.
983 When REF is non-NULL, assume that reference happens in symbol REF
984 when determining the availability. */
985 cgraph_node *function_or_virtual_thunk_symbol
986 (enum availability *avail = NULL,
987 struct symtab_node *ref = NULL);
988
989 /* Create node representing clone of N executed COUNT times. Decrease
990 the execution counts from original node too.
991 The new clone will have decl set to DECL that may or may not be the same
992 as decl of N.
993
994 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
995 function's profile to reflect the fact that part of execution is handled
996 by node.
997 When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about
998 the new clone. Otherwise the caller is responsible for doing so later.
999
1000 If the new node is being inlined into another one, NEW_INLINED_TO should be
1001 the outline function the new one is (even indirectly) inlined to.
1002 All hooks will see this in node's inlined_to, when invoked.
1003 Should be NULL if the node is not inlined.
1004
1005 SUFFIX is string that is appended to the original name, it should only be
1006 NULL if NEW_INLINED_TO is not NULL or if the clone being created is
1007 temporary and a record about it should not be added into the ipa-clones
1008 dump file. */
1009 cgraph_node *create_clone (tree decl, profile_count count,
1010 bool update_original,
1011 vec<cgraph_edge *> redirect_callers,
1012 bool call_duplication_hook,
1013 cgraph_node *new_inlined_to,
1014 ipa_param_adjustments *param_adjustments,
1015 const char *suffix);
1016
1017 /* Create callgraph node clone with new declaration. The actual body will be
1018 copied later at compilation stage. The name of the new clone will be
1019 constructed from the name of the original node, SUFFIX and NUM_SUFFIX. */
1020 cgraph_node *create_virtual_clone (const vec<cgraph_edge *> &redirect_callers,
1021 vec<ipa_replace_map *, va_gc> *tree_map,
1022 ipa_param_adjustments *param_adjustments,
1023 const char * suffix, unsigned num_suffix);
1024
1025 /* Remove the node from the tree of virtual and inline clones and make it a
1026 standalone node - not a clone any more. */
1027 void remove_from_clone_tree ();
1028
1029 /* cgraph node being removed from symbol table; see if its entry can be
1030 replaced by other inline clone. */
1031 cgraph_node *find_replacement (struct clone_info *);
1032
1033 /* Create a new cgraph node which is the new version of
1034 callgraph node. REDIRECT_CALLERS holds the callers
1035 edges which should be redirected to point to
1036 NEW_VERSION. ALL the callees edges of the node
1037 are cloned to the new version node. Return the new
1038 version node.
1039
1040 If non-NULL BLOCK_TO_COPY determine what basic blocks
1041 was copied to prevent duplications of calls that are dead
1042 in the clone.
1043
1044 SUFFIX is string that is appended to the original name. */
1045
1046 cgraph_node *create_version_clone (tree new_decl,
1047 vec<cgraph_edge *> redirect_callers,
1048 bitmap bbs_to_copy,
1049 const char *suffix = NULL);
1050
1051 /* Perform function versioning.
1052 Function versioning includes copying of the tree and
1053 a callgraph update (creating a new cgraph node and updating
1054 its callees and callers).
1055
1056 REDIRECT_CALLERS varray includes the edges to be redirected
1057 to the new version.
1058
1059 TREE_MAP is a mapping of tree nodes we want to replace with
1060 new ones (according to results of prior analysis).
1061
1062 If non-NULL PARAM_ADJUSTMENTS determine how function formal parameters
1063 should be modified in the new version and if it should return void.
1064 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
1065 If non_NULL NEW_ENTRY determine new entry BB of the clone.
1066 SUFFIX is a string that will be used to create a new name for the new
1067 function.
1068
1069 If TARGET_ATTRIBUTES is non-null, when creating a new declaration,
1070 add the attributes to DECL_ATTRIBUTES. And call valid_attribute_p
1071 that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET
1072 of the declaration.
1073
1074 If VERSION_DECL is set true, use clone_function_name_numbered for the
1075 function clone. Otherwise, use clone_function_name.
1076
1077 Return the new version's cgraph node. */
1078 cgraph_node *create_version_clone_with_body
1079 (vec<cgraph_edge *> redirect_callers,
1080 vec<ipa_replace_map *, va_gc> *tree_map,
1081 ipa_param_adjustments *param_adjustments,
1082 bitmap bbs_to_copy, basic_block new_entry_block, const char *suffix,
1083 tree target_attributes = NULL_TREE, bool version_decl = true);
1084
1085 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
1086 corresponding to cgraph_node. */
1087 cgraph_function_version_info *insert_new_function_version (void);
1088
1089 /* Get the cgraph_function_version_info node corresponding to node. */
1090 cgraph_function_version_info *function_version (void);
1091
1092 /* Discover all functions and variables that are trivially needed, analyze
1093 them as well as all functions and variables referred by them */
1094 void analyze (void);
1095
1096 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
1097 aliases DECL with an adjustments made into the first parameter.
1098 See comments in struct symtab-thunks.h for detail on the parameters. */
1099 cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
1100 HOST_WIDE_INT fixed_offset,
1101 HOST_WIDE_INT virtual_value,
1102 HOST_WIDE_INT indirect_offset,
1103 tree virtual_offset,
1104 tree real_alias);
1105
1106
1107 /* Return node that alias is aliasing. */
1108 inline cgraph_node *get_alias_target (void);
1109
1110 /* Given function symbol, walk the alias chain to return the function node
1111 is alias of. Do not walk through thunks.
1112 When AVAILABILITY is non-NULL, get minimal availability in the chain.
1113 When REF is non-NULL, assume that reference happens in symbol REF
1114 when determining the availability. */
1115
1116 cgraph_node *ultimate_alias_target (availability *availability = NULL,
1117 symtab_node *ref = NULL);
1118
1119 /* Call expand_thunk on all callers that are thunks and analyze those
1120 nodes that were expanded. */
1121 void expand_all_artificial_thunks ();
1122
1123 /* Assemble thunks and aliases associated to node. */
1124 void assemble_thunks_and_aliases (void);
1125
1126 /* Expand function specified by node. */
1127 void expand (void);
1128
1129 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
1130 kind of wrapper method. */
1131 void create_wrapper (cgraph_node *target);
1132
1133 /* Verify cgraph nodes of the cgraph node. */
1134 void DEBUG_FUNCTION verify_node (void);
1135
1136 /* Remove function from symbol table. */
1137 void remove (void);
1138
1139 /* Dump call graph node to file F. */
1140 void dump (FILE *f);
1141
1142 /* Dump call graph node to file F. */
1143 void dump_graphviz (FILE *f);
1144
1145 /* Dump call graph node to stderr. */
1146 void DEBUG_FUNCTION debug (void);
1147
1148 /* When doing LTO, read cgraph_node's body from disk if it is not already
1149 present. */
1150 bool get_untransformed_body ();
1151
1152 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
1153 if it is not already present. When some IPA transformations are scheduled,
1154 apply them. */
1155 bool get_body ();
1156
1157 void materialize_clone (void);
1158
1159 /* Release memory used to represent body of function.
1160 Use this only for functions that are released before being translated to
1161 target code (i.e. RTL). Functions that are compiled to RTL and beyond
1162 are free'd in final.cc via free_after_compilation(). */
1163 void release_body (bool keep_arguments = false);
1164
1165 /* Return the DECL_STRUCT_FUNCTION of the function. */
1166 struct function *get_fun () const;
1167
1168 /* Bring cgraph node local. */
1169 void make_local (void);
1170
1171 /* Likewise indicate that a node is having address taken. */
1172 void mark_address_taken (void);
1173
1174 /* Set finalization priority to PRIORITY. */
1175 void set_fini_priority (priority_type priority);
1176
1177 /* Return the finalization priority. */
1178 priority_type get_fini_priority (void);
1179
1180 /* Create edge from a given function to CALLEE in the cgraph. */
1181 cgraph_edge *create_edge (cgraph_node *callee,
1182 gcall *call_stmt, profile_count count,
1183 bool cloning_p = false);
1184
1185 /* Create an indirect edge to a (yet-)undetermined callee. CALL_STMT is the
1186 corresponding statement, if available, ECF_FLAGS and COUNT are
1187 corresponding gimple call flags and profiling count respectively.
1188 CLONING_P should be set if properties that are copied from an original
1189 edge should not be calculated. */
1190
1191 cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
1192 profile_count count,
1193 bool cloning_p = false);
1194
1195 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
1196 same function body. If clones already have edge for OLD_STMT; only
1197 update the edge same way as cgraph_set_call_stmt_including_clones does. */
1198 void create_edge_including_clones (cgraph_node *callee,
1199 gimple *old_stmt, gcall *stmt,
1200 profile_count count,
1201 cgraph_inline_failed_t reason);
1202
1203 /* Return the callgraph edge representing the GIMPLE_CALL statement
1204 CALL_STMT. */
1205 cgraph_edge *get_edge (gimple *call_stmt);
1206
1207 /* Collect all callers of cgraph_node and its aliases that are known to lead
1208 to NODE (i.e. are not overwritable) and that are not thunks. */
1209 auto_vec<cgraph_edge *> collect_callers (void);
1210
1211 /* Remove all callers from the node. */
1212 void remove_callers (void);
1213
1214 /* Remove all callees from the node. */
1215 void remove_callees (void);
1216
1217 /* Return function availability. See cgraph.h for description of individual
1218 return values. */
1219 enum availability get_availability (symtab_node *ref = NULL);
1220
1221 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1222 if any to NOTHROW. */
1223 bool set_nothrow_flag (bool nothrow);
1224
1225 /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
1226 if any. */
1227 bool set_malloc_flag (bool malloc_p);
1228
1229 /* SET TREE_THIS_VOLATILE on cgraph_node's decl and on aliases of the node
1230 if any. */
1231 bool set_noreturn_flag (bool noreturn_p);
1232
1233 /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
1234 If SET_CONST if false, clear the flag.
1235
1236 When setting the flag be careful about possible interposition and
1237 do not set the flag for functions that can be interposed and set pure
1238 flag for functions that can bind to other definition.
1239
1240 Return true if any change was done. */
1241
1242 bool set_const_flag (bool set_const, bool looping);
1243
1244 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1245 if any to PURE.
1246
1247 When setting the flag, be careful about possible interposition.
1248 Return true if any change was done. */
1249
1250 bool set_pure_flag (bool pure, bool looping);
1251
1252 /* Add attribute ATTR to cgraph_node's decl and on aliases of the node
1253 if any. */
1254 bool add_detected_attribute (const char *attr);
1255
1256 /* Call callback on function and aliases associated to the function.
1257 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1258 skipped. */
1259
1260 bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
1261 void *),
1262 void *data, bool include_overwritable);
1263
1264 /* Call callback on cgraph_node, thunks and aliases associated to NODE.
1265 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1266 skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
1267 skipped. */
1268 bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
1269 void *data),
1270 void *data,
1271 bool include_overwritable,
1272 bool exclude_virtual_thunks = false);
1273
1274 /* Likewise indicate that a node is needed, i.e. reachable via some
1275 external means. */
1276 inline void mark_force_output (void);
1277
1278 /* Return true when function can be marked local. */
1279 bool local_p (void);
1280
1281 /* Return true if cgraph_node can be made local for API change.
1282 Extern inline functions and C++ COMDAT functions can be made local
1283 at the expense of possible code size growth if function is used in multiple
1284 compilation units. */
1285 bool can_be_local_p (void);
1286
1287 /* Return true when cgraph_node cannot return or throw and thus
1288 it is safe to ignore its side effects for IPA analysis. */
1289 bool cannot_return_p (void);
1290
1291 /* Return true when function cgraph_node and all its aliases are only called
1292 directly.
1293 i.e. it is not externally visible, address was not taken and
1294 it is not used in any other non-standard way. */
1295 bool only_called_directly_p (void);
1296
1297 /* Returns TRUE iff THIS is a descendant of N in the clone tree. */
1298 bool is_clone_of (cgraph_node *n) const;
1299
1300 /* Turn profile to global0. Walk into inlined functions. */
1301 void make_profile_local ();
1302
1303 /* Turn profile to global0. Walk into inlined functions. */
1304 void make_profile_global0 (profile_quality quality);
1305
1306 /* Scale profile by NUM/DEN. Walk into inlined function. */
1307 void apply_scale (profile_count num, profile_count den);
1308
1309 /* Scale profile to given IPA_COUNT.
1310 IPA_COUNT should pass ipa_p () with a single exception.
1311 It can be also GUESSED_LOCAL in case we want to
1312 drop any IPA info about the profile. */
1313 void scale_profile_to (profile_count ipa_count);
1314
1315 /* Return true when function is only called directly or it has alias.
1316 i.e. it is not externally visible, address was not taken and
1317 it is not used in any other non-standard way. */
1318 inline bool only_called_directly_or_aliased_p (void);
1319
1320 /* Return true when function cgraph_node can be expected to be removed
1321 from program when direct calls in this compilation unit are removed.
1322
1323 As a special case COMDAT functions are
1324 cgraph_can_remove_if_no_direct_calls_p while the are not
1325 cgraph_only_called_directly_p (it is possible they are called from other
1326 unit)
1327
1328 This function behaves as cgraph_only_called_directly_p because eliminating
1329 all uses of COMDAT function does not make it necessarily disappear from
1330 the program unless we are compiling whole program or we do LTO. In this
1331 case we know we win since dynamic linking will not really discard the
1332 linkonce section.
1333
1334 If WILL_INLINE is true, assume that function will be inlined into all the
1335 direct calls. */
1336 bool will_be_removed_from_program_if_no_direct_calls_p
1337 (bool will_inline = false);
1338
1339 /* Return true when function can be removed from callgraph
1340 if all direct calls and references are eliminated. The function does
1341 not take into account comdat groups. */
1342 bool can_remove_if_no_direct_calls_and_refs_p (void);
1343
1344 /* Return true when function cgraph_node and its aliases can be removed from
1345 callgraph if all direct calls are eliminated.
1346 If WILL_INLINE is true, assume that function will be inlined into all the
1347 direct calls. */
1348 bool can_remove_if_no_direct_calls_p (bool will_inline = false);
1349
1350 /* Return true when callgraph node is a function with Gimple body defined
1351 in current unit. Functions can also be define externally or they
1352 can be thunks with no Gimple representation.
1353
1354 Note that at WPA stage, the function body may not be present in memory. */
1355 inline bool has_gimple_body_p (void);
1356
1357 /* Return true if this node represents a former, i.e. an expanded, thunk. */
1358 bool former_thunk_p (void);
1359
1360 /* Check if function calls comdat local. This is used to recompute
1361 calls_comdat_local flag after function transformations. */
1362 bool check_calls_comdat_local_p ();
1363
1364 /* Return true if function should be optimized for size. */
1365 enum optimize_size_level optimize_for_size_p (void);
1366
1367 /* Dump the callgraph to file F. */
1368 static void dump_cgraph (FILE *f);
1370 /* Dump the call graph to stderr. */
1371 static inline
1372 void debug_cgraph (void)
1373 {
1374 dump_cgraph (stderr);
1376
1377 /* Get summary id of the node. */
1378 inline int get_summary_id ()
1379 {
1380 return m_summary_id;
1381 }
1382
1383 /* Adds DECL to the FN_V structure of semantically identical functions. */
1384 static void add_function_version (cgraph_function_version_info *fn_v,
1385 tree decl);
1386
1387 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1388 DECL is a duplicate declaration. */
1389 static void delete_function_version_by_decl (tree decl);
1390
1391 static void delete_function_version (cgraph_function_version_info *);
1392
1393 /* Add the function FNDECL to the call graph.
1394 Unlike finalize_function, this function is intended to be used
1395 by middle end and allows insertion of new function at arbitrary point
1396 of compilation. The function can be either in high, low or SSA form
1397 GIMPLE.
1398
1399 The function is assumed to be reachable and have address taken (so no
1400 API breaking optimizations are performed on it).
1401
1402 Main work done by this function is to enqueue the function for later
1403 processing to avoid need the passes to be re-entrant.
1404
1405 Returns the created node. */
1407
1408 /* Return callgraph node for given symbol and check it is a function. */
1409 static inline cgraph_node *get (const_tree decl)
1410 {
1411 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
1413 }
1414
1415 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1416 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1417 have the garbage collector run at the moment. We would need to either
1418 create a new GC context, or just not compile right now. Returns the
1419 created node. */
1420 static cgraph_node *finalize_function (tree, bool);
1421
1422 /* Return cgraph node assigned to DECL. Create new one when needed. */
1423 static cgraph_node * create (tree decl);
1424
1425 /* Try to find a call graph node for declaration DECL and if it does not
1426 exist or if it corresponds to an inline clone, create a new one. */
1427 static cgraph_node * get_create (tree);
1428
1429 /* Return local info for the compiled function. */
1430 static cgraph_node *local_info_node (tree decl);
1431
1432 /* Return RTL info for the compiled function. */
1433 static struct cgraph_rtl_info *rtl_info (const_tree);
1434
1435 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1436 Return NULL if there's no such node. */
1437 static cgraph_node *get_for_asmname (tree asmname);
1438
1439 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1440 successful and NULL otherwise.
1441 Same body aliases are output whenever the body of DECL is output,
1442 and cgraph_node::get (ALIAS) transparently
1443 returns cgraph_node::get (DECL). */
1444 static cgraph_node * create_same_body_alias (tree alias, tree decl);
1445
1446 /* Verify whole cgraph structure. */
1447 static void DEBUG_FUNCTION verify_cgraph_nodes (void);
1448
1449 /* Verify cgraph, if consistency checking is enabled. */
1450 static inline void checking_verify_cgraph_nodes (void);
1451
1452 /* Worker to bring NODE local. */
1453 static bool make_local (cgraph_node *node, void *);
1454
1455 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1456 the function body is associated
1457 with (not necessarily cgraph_node (DECL). */
1458 static cgraph_node *create_alias (tree alias, tree target);
1459
1460 /* Return true if NODE has thunk. */
1461 static bool has_thunk_p (cgraph_node *node, void *);
1462
1465 /* List of edges representing indirect calls with a yet undetermined
1466 callee. */
1472 /* For functions with many calls sites it holds map from call expression
1473 to the edge to speed up cgraph_edge function. */
1475 /* Declaration node used to be clone of. */
1478 /* If this is a SIMD clone, this points to the SIMD specific
1479 information for it. */
1481 /* If this function has SIMD clones, this points to the first clone. */
1483
1484 /* Interprocedural passes scheduled to have their transform functions
1485 applied next time we execute local pass on them. We maintain it
1486 per-function in order to allow IPA passes to introduce new functions. */
1489 /* For inline clones this points to the function they will be
1490 inlined into. */
1492
1494
1495 /* Expected number of executions: calculated in profile.cc. */
1497 /* How to scale counts at materialization time; used to merge
1498 LTO units with different number of profile runs. */
1500 /* ID assigned by the profiling. */
1501 unsigned int profile_id;
1502 /* ID of the translation unit. */
1503 int unit_id;
1504 /* Time profiler: first run of function. */
1506
1507 /* True when symbol is a thunk. */
1508 unsigned thunk : 1;
1509 /* Set when decl is an abstract function pointed to by the
1510 ABSTRACT_DECL_ORIGIN of a reachable function. */
1511 unsigned used_as_abstract_origin : 1;
1512 /* Set once the function is lowered (i.e. its CFG is built). */
1513 unsigned lowered : 1;
1514 /* Set once the function has been instantiated and its callee
1515 lists created. */
1516 unsigned process : 1;
1517 /* How commonly executed the node is. Initialized during branch
1518 probabilities pass. */
1519 enum node_frequency frequency : 2;
1520 /* True when function can only be called at startup (from static ctor). */
1521 unsigned only_called_at_startup : 1;
1522 /* True when function can only be called at startup (from static dtor). */
1523 unsigned only_called_at_exit : 1;
1524 /* True when function is the transactional clone of a function which
1525 is called only from inside transactions. */
1526 /* ?? We should be able to remove this. We have enough bits in
1527 cgraph to calculate it. */
1528 unsigned tm_clone : 1;
1529 /* True if this decl is a dispatcher for function versions. */
1530 unsigned dispatcher_function : 1;
1531 /* True if this decl is a resolver for function versions. */
1532 unsigned dispatcher_resolver_function : 1;
1533 /* True this is part of a multiversioned set and this version comes from a
1534 target_clone attribute. Or if this is a dispatched symbol or resolver
1535 and the default version comes from a target_clones. */
1536 unsigned is_target_clone : 1;
1537 /* True if this decl calls a COMDAT-local function. This is set up in
1538 compute_fn_summary and inline_call. */
1539 unsigned calls_comdat_local : 1;
1540 /* True if node has been created by merge operation in IPA-ICF. */
1541 unsigned icf_merged: 1;
1542 /* True if node has been created by lowering an [[assume(...)]] statement. */
1543 unsigned assume_function : 1;
1544 /* True if call to node can't result in a call to free, munmap or
1545 other operation that could make previously non-trapping memory
1546 accesses trapping. */
1547 unsigned nonfreeing_fn : 1;
1548 /* True if there was multiple COMDAT bodies merged by lto-symtab. */
1549 unsigned merged_comdat : 1;
1550 /* True if this def was merged with extern inlines. */
1551 unsigned merged_extern_inline : 1;
1552 /* True if function was created to be executed in parallel. */
1553 unsigned parallelized_function : 1;
1554 /* True if function is part split out by ipa-split. */
1555 unsigned split_part : 1;
1556 /* True if the function appears as possible target of indirect call. */
1558 /* Set when function is visible in current compilation unit only and
1559 its address is never taken. */
1560 unsigned local : 1;
1561 /* False when there is something makes versioning impossible. */
1562 unsigned versionable : 1;
1563 /* False when function calling convention and signature cannot be changed.
1564 This is the case when __builtin_apply_args is used. */
1566 /* True when the function has been originally extern inline, but it is
1567 redefined now. */
1568 unsigned redefined_extern_inline : 1;
1569 /* True if the function may enter serial irrevocable mode. */
1570 unsigned tm_may_enter_irr : 1;
1571 /* True if this was a clone created by ipa-cp. */
1572 unsigned ipcp_clone : 1;
1573 /* True if the function should only be emitted if it is used. This flag
1574 is set for local SIMD clones when they are created and cleared if the
1575 vectorizer uses them. */
1576 unsigned gc_candidate : 1;
1577 /* Set if the function is called by an IFUNC resolver. */
1578 unsigned called_by_ifunc_resolver : 1;
1579 /* True if the function contains unresolved OpenMP metadirectives. */
1580 unsigned has_omp_variant_constructs : 1;
1581
1582private:
1583
1584 /* Summary id that is recycled. */
1585 int m_summary_id;
1586
1587 /* Worker for call_for_symbol_and_aliases. */
1588 bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
1589 void *),
1590 void *data, bool include_overwritable);
1591};
1593/* A cgraph node set is a collection of cgraph nodes. A cgraph node
1594 can appear in multiple sets. */
1596{
1600
1601typedef cgraph_node_set_def *cgraph_node_set;
1602typedef struct varpool_node_set_def *varpool_node_set;
1603
1604struct varpool_node;
1606/* A varpool node set is a collection of varpool nodes. A varpool node
1607 can appear in multiple sets. */
1609{
1613
1614/* Iterator structure for cgraph node sets. */
1616{
1618 unsigned index;
1620
1621/* Iterator structure for varpool node sets. */
1623{
1625 unsigned index;
1626};
1627
1628/* Context of polymorphic call. It represent information about the type of
1629 instance that may reach the call. This is used by ipa-devirt walkers of the
1630 type inheritance graph. */
1631
1633public:
1634 /* The called object appears in an object of type OUTER_TYPE
1635 at offset OFFSET. When information is not 100% reliable, we
1636 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1637 HOST_WIDE_INT offset;
1638 HOST_WIDE_INT speculative_offset;
1641 /* True if outer object may be in construction or destruction. */
1642 unsigned maybe_in_construction : 1;
1643 /* True if outer object may be of derived type. */
1645 /* True if speculative outer object may be of derived type. We always
1646 speculate that construction does not happen. */
1648 /* True if the context is invalid and all calls should be redirected
1649 to BUILTIN_UNREACHABLE. */
1650 unsigned invalid : 1;
1651 /* True if the outer type is dynamic. */
1652 unsigned dynamic : 1;
1653
1654 /* Build empty "I know nothing" context. */
1656 /* Build polymorphic call context for indirect call E. */
1658 /* Build polymorphic call context for IP invariant CST.
1659 If specified, OTR_TYPE specify the type of polymorphic call
1660 that takes CST+OFFSET as a parameter. */
1661 ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
1662 HOST_WIDE_INT offset = 0);
1663 /* Build context for pointer REF contained in FNDECL at statement STMT.
1664 if INSTANCE is non-NULL, return pointer to the object described by
1665 the context. */
1666 ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
1667 tree *instance = NULL);
1668
1669 /* Look for vtable stores or constructor calls to work out dynamic type
1670 of memory location. */
1671 bool get_dynamic_type (tree, tree, tree, gimple *, unsigned *);
1672
1673 /* Make context non-speculative. */
1674 void clear_speculation ();
1675
1676 /* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is
1677 NULL, the context is set to dummy "I know nothing" setting. */
1678 void clear_outer_type (tree otr_type = NULL);
1679
1680 /* Walk container types and modify context to point to actual class
1681 containing OTR_TYPE (if non-NULL) as base class.
1682 Return true if resulting context is valid.
1683
1684 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1685 valid only via allocation of new polymorphic type inside by means
1686 of placement new.
1687
1688 When CONSIDER_BASES is false, only look for actual fields, not base types
1689 of TYPE. */
1690 bool restrict_to_inner_class (tree otr_type,
1691 bool consider_placement_new = true,
1692 bool consider_bases = true);
1693
1694 /* Adjust all offsets in contexts by given number of bits. */
1695 void offset_by (HOST_WIDE_INT);
1696 /* Use when we cannot track dynamic type change. This speculatively assume
1697 type change is not happening. */
1698 void possible_dynamic_type_change (bool, tree otr_type = NULL);
1699 /* Assume that both THIS and a given context is valid and strengthen THIS
1700 if possible. Return true if any strengthening was made.
1701 If actual type the context is being used in is known, OTR_TYPE should be
1702 set accordingly. This improves quality of combined result. */
1705
1706 /* Return TRUE if context is fully useless. */
1707 bool useless_p () const;
1708 /* Return TRUE if this context conveys the same information as X. */
1709 bool equal_to (const ipa_polymorphic_call_context &x) const;
1710
1711 /* Dump human readable context to F. If NEWLINE is true, it will be
1712 terminated by a newline. */
1713 void dump (FILE *f, bool newline = true) const;
1714 void DEBUG_FUNCTION debug () const;
1715
1716 /* LTO streaming. */
1717 void stream_out (struct output_block *) const;
1718 void stream_in (class lto_input_block *, class data_in *data_in);
1719
1720private:
1721 bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1722 bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1723 void set_by_decl (tree, HOST_WIDE_INT);
1724 bool set_by_invariant (tree, tree, HOST_WIDE_INT);
1725 bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
1726 void make_speculative (tree otr_type = NULL);
1727};
1728
1729/* Denotes the kind of call that a particular cgraph_indirect_call_info
1730 instance describes. */
1731
1733 /* Unspecified kind. Only to be used when no information about the call
1734 statement is available or it does not fall into any of the other
1735 categories. */
1737 /* A normal indirect call when the target is an SSA_NAME. */
1739 /* Call of a virtual method when the target is an OBJ_TYPE_REF which conforms
1740 to virtual_method_call_p. */
1742 /* Must be last */
1744};
1745
1746/* The base class containing additional information about all kinds of indirect
1747 calls. It can also be used when no information about the call statement is
1748 available or it does not fall into any of the other categories. */
1749
1750class GTY((desc ("%h.kind"), tag ("CIIK_UNSPECIFIED")))
1752{
1753public:
1754 cgraph_indirect_call_info (int flags)
1755 : ecf_flags (flags), param_index (-1), kind (CIIK_UNSPECIFIED),
1758 : ecf_flags (flags), param_index (-1), kind (k),
1759 num_speculative_call_targets (0) {}
1760
1761 /* Dump human readable information about the indirect call to F. If NEWLINE
1762 is true, it will be terminated by a newline. */
1763 void dump (FILE *f, bool newline = true) const;
1764 void DEBUG_FUNCTION debug () const;
1765
1766 /* ECF flags determined from the caller. */
1767 int ecf_flags;
1768 /* If we can relate this call target to a specific formal parameter of the
1769 caller, then this is its index. Otherwise set to -1. */
1770 int param_index;
1772 /* Identifier of the specific type of indirect info this actually is. */
1774 /* Number of speculative call targets. */
1775 unsigned num_speculative_call_targets : 16;
1776};
1778/* Structure containing additional information about non-virtual indirect calls
1779 where the target is an SSA_NAME. */
1781class GTY((tag ("CIIK_SIMPLE")))
1783{
1784public:
1785 cgraph_simple_indirect_info (int flags)
1787 rec_type (NULL_TREE), fld_offset (0), agg_contents (false),
1788 member_ptr (false), fnptr_loaded_from_record (false), by_ref (false),
1790 {}
1791
1792 /* When agg_content is set, an offset where the call pointer is located
1793 within the aggregate. */
1794 HOST_WIDE_INT offset;
1795 /* Only meaningful if fnptr_loaded_from_record is set. Then it contains the
1796 type of the record from which the target of the call was loaded. */
1797 tree rec_type;
1798 /* Only meaningful if fnptr_loaded_from_record is set. Then it contains the
1799 offset in bytes within the type above from which the target of the call
1800 was loaded. */
1801 unsigned fld_offset;
1803 /* Set when the call is a call of a pointer loaded from contents of an
1804 aggregate at offset. */
1805 unsigned agg_contents : 1;
1806 /* Set when this is a call through a member pointer. */
1807 unsigned member_ptr : 1;
1808 /* Set if the function is a call of a pointer loaded from a record type
1809 stored in otr_type at offset offset. */
1810 unsigned fnptr_loaded_from_record : 1;
1811 /* When the agg_contents bit is set, this one determines whether the
1812 destination is loaded from a parameter passed by reference. */
1813 unsigned by_ref : 1;
1814 /* When the agg_contents bit is set, this one determines whether we can
1815 deduce from the function body that the loaded value from the reference is
1816 never modified between the invocation of the function and the load
1817 point. */
1818 unsigned guaranteed_unmodified : 1;
1819};
1821/* Structure containing additional information about non-virtual indirect calls
1822 when the target is an OBJ_TYPE_REF which conforms to
1823 virtual_method_call_p. */
1824
1825class GTY((tag ("CIIK_POLYMORPHIC")))
1828public:
1831 otr_token (0), otr_type (nullptr), offset (0), vptr_changed (true)
1832 {}
1835 HOST_WIDE_INT token, tree type)
1839
1840 /* Return true if the information is usable for devirtualization. This can
1841 happen if part of the required information is not streamed in yet and for
1842 some cases we determine it is no longer useful to attempt to use the
1843 information too. */
1844 bool usable_p () const
1845 {
1846 return !!otr_type;
1847 }
1848 /* Mark this information as not useful for devirtualization. Return true if
1849 it was considered useful until now. */
1850 bool mark_unusable ()
1851 {
1852 bool r = !!otr_type;
1854 return r;
1855 }
1857 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1859 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1860 HOST_WIDE_INT otr_token;
1861 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1862 tree otr_type;
1863 /* The offset from the point where the parameter identified by param_index to
1864 the point where the corresponding object appears. */
1865 HOST_WIDE_INT offset;
1866
1867 /* For polymorphic calls this specify whether the virtual table pointer
1868 may have changed in between function entry and the call. */
1869 unsigned vptr_changed : 1;
1870};
1871
1872/* Return true if ii is a cgraph_polymorphic_indirect_info that is usable_p. */
1873
1874inline bool
1875usable_polymorphic_info_p (cgraph_indirect_call_info *ii)
1879 return pii && pii->usable_p ();
1881
1882class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1883 for_user)) cgraph_edge
1884{
1885public:
1886 friend struct cgraph_node;
1887 friend class symbol_table;
1888
1889 /* Remove EDGE from the cgraph. */
1890 static void remove (cgraph_edge *edge);
1891
1892 /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_DERIVED_EDGES and
1893 E is any component of speculative edge, then update all components.
1894 Speculations can be resolved in the process and EDGE can be removed and
1895 deallocated. Return the edge that now represents the call. If
1896 UPDATE_DERIVED_EDGES and E is a part of a callback edge, update all
1897 associated edges and return the callback-carrying edge. */
1898 static cgraph_edge *set_call_stmt (cgraph_edge *e, gcall *new_stmt,
1899 bool update_derived_edges = true);
1900
1901 /* Redirect callee of the edge to N. The function does not update underlying
1902 call expression. */
1903 void redirect_callee (cgraph_node *n);
1904
1905 /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise
1906 create one or more equivalent thunks for N and redirect E to the first in
1907 the chain. Note that it is then necessary to call
1908 n->expand_all_artificial_thunks once all callers are redirected. */
1909 void redirect_callee_duplicating_thunks (cgraph_node *n);
1910
1911 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1912 CALLEE. Speculations can be resolved in the process and EDGE can be
1913 removed and deallocated. Return the edge that now represents the
1914 call. */
1915 static cgraph_edge *make_direct (cgraph_edge *edge, cgraph_node *callee);
1916
1917 /* Returns the next speculative_id based on currently in use
1918 for the given statement for the edge.
1919 Returns 0 if no speculative edges exist for this statement. */
1920 int get_next_speculative_id ();
1921
1922 /* Turn edge into speculative call calling N2. Update
1923 the profile so the direct call is taken COUNT times
1924 with FREQUENCY. speculative_id is used to link direct calls with their
1925 corresponding IPA_REF_ADDR references when representing speculative calls.
1926 */
1927 cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count,
1928 unsigned int speculative_id = 0);
1929
1930 /* Create a callback edge, representing an indirect call to n2
1931 passed to a function by argument. Sets has_callback flag of the original
1932 edge. Both edges are attached to the same call statement. Returns created
1933 callback edge. FN_IDX is the index of the callback function in dispatching
1934 function's argument list. ATTR is the attribute used to derive the
1935 edge. */
1936 cgraph_edge *make_callback (cgraph_node *n2, unsigned fn_idx, tree attr);
1937
1938 /* Create a callback edge, representing an indirect call to target
1939 passed to an internal function by argument. As internal calls are not
1940 represented in the callgraph, the created edge won't have any associated
1941 dispatching edge. The created callback edge will be attached to the
1942 internal call statement STMT. Returns created callback edge. */
1943 static cgraph_edge *make_callback_internal (cgraph_node *caller,
1944 cgraph_node *target,
1945 gcall *call_stmt);
1946
1947 /* Returns the callback-carrying edge of a callback edge or NULL, if such edge
1948 cannot be found. An edge is considered callback-carrying, if it has it's
1949 has_callback flag set and shares it's call statement with the edge
1950 this method is caled on. */
1951 cgraph_edge *get_callback_carrying_edge ();
1952
1953 /* Returns TRUE iff THIS is a callback edge with a carrying edge. */
1954 bool callback_with_carrying_edge_p () const;
1955
1956 /* Returns the first callback edge in the list of callees of the caller node.
1957 Note that the edges might be in arbitrary order. Must be called on a
1958 callback or callback-carrying edge. */
1959 cgraph_edge *first_callback_edge ();
1960
1961 /* Given a callback edge, returns the next callback edge belonging to the same
1962 callback-carrying edge. Must be called on a callback edge, not the
1963 callback-carrying edge. */
1964 cgraph_edge *next_callback_edge ();
1965
1966 /* When called on a callback-carrying edge, removes all of its attached
1967 callback edges and sets has_callback to FALSE. */
1968 void purge_callback_edges ();
1969
1970 /* Speculative call consists of an indirect edge and one or more
1971 direct edge+ref pairs. Speculative will expand to the following sequence:
1972
1973 if (call_dest == target1) // reference to target1
1974 target1 (); // direct call to target1
1975 else if (call_dest == target2) // reference to targt2
1976 target2 (); // direct call to target2
1977 else
1978 call_dest (); // indirect call
1979
1980 Before the expansion we will have indirect call and the direct call+ref
1981 pairs all linked to single statement.
1982
1983 Note that ref may point to different symbol than the corresponding call
1984 because the speculated edge may have been optimized (redirected to
1985 a clone) or inlined.
1986
1987 Given an edge which is part of speculative call, return the first
1988 direct call edge in the speculative call sequence.
1989
1990 In the example above called on any cgraph edge in the sequence it will
1991 return direct call to target1. */
1993
1994 /* Return next speculative call target or NULL if there is none.
1995 All targets are required to form an interval in the callee list.
1996
1997 In example above, if called on call to target1 it will return call to
1998 target2. */
2000 {
2001 cgraph_edge *e = this;
2003
2004 if (e->next_callee && e->next_callee->speculative
2005 && e->next_callee->call_stmt == e->call_stmt
2006 && e->next_callee->lto_stmt_uid == e->lto_stmt_uid)
2007 return e->next_callee;
2008 return NULL;
2009 }
2010
2011 /* When called on any edge in the speculative call return the (unique)
2012 indirect call edge in the speculative call sequence. */
2013 cgraph_edge *speculative_call_indirect_edge ()
2014 {
2015 gcc_checking_assert (speculative);
2016 if (!callee)
2017 return this;
2018 for (cgraph_edge *e2 = caller->indirect_calls;
2019 true; e2 = e2->next_callee)
2020 if (e2->speculative
2021 && call_stmt == e2->call_stmt
2022 && lto_stmt_uid == e2->lto_stmt_uid)
2023 return e2;
2024 }
2025
2026 /* When called on any edge in speculative call and when given any target
2027 of ref which is speculated to it returns the corresponding direct call.
2029 In example above if called on function target2 it will return call to
2030 target2. */
2032
2033 /* Return REF corresponding to direct call in the speculative call
2034 sequence. */
2036 {
2037 ipa_ref *ref;
2038
2040 for (unsigned int i = 0; caller->iterate_reference (i, ref); i++)
2041 if (ref->speculative && ref->speculative_id == speculative_id
2042 && ref->stmt == (gimple *)call_stmt
2043 && ref->lto_stmt_uid == lto_stmt_uid)
2044 return ref;
2045 gcc_unreachable ();
2046 }
2047
2048 /* Speculative call edge turned out to be direct call to CALLEE_DECL. Remove
2049 the speculative call sequence and return edge representing the call, the
2050 original EDGE can be removed and deallocated. It is up to caller to
2051 redirect the call as appropriate. Return the edge that now represents the
2052 call.
2053
2054 For "speculative" indirect call that contains multiple "speculative"
2055 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
2056 decrease the count and only remove current direct edge.
2057
2058 If no speculative direct call left to the speculative indirect call, remove
2059 the speculative of both the indirect call and corresponding direct edge.
2060
2061 It is up to caller to iteratively resolve each "speculative" direct call
2062 and redirect the call as appropriate. */
2063 static cgraph_edge *resolve_speculation (cgraph_edge *edge,
2064 tree callee_decl = NULL);
2065
2066 /* If necessary, change the function declaration in the call statement
2067 associated with edge E so that it corresponds to the edge callee.
2068 Speculations can be resolved in the process and EDGE can be removed and
2069 deallocated.
2070
2071 The edge could be one of speculative direct call generated from speculative
2072 indirect call. In this circumstance, decrease the speculative targets
2073 count (i.e. num_speculative_call_targets) and redirect call stmt to the
2074 corresponding i-th target. If no speculative direct call left to the
2075 speculative indirect call, remove "speculative" of the indirect call and
2076 also redirect stmt to it's final direct target.
2077
2078 When called from within tree-inline, KILLED_SSAs has to contain the
2079 pointer to killed_new_ssa_names within the copy_body_data structure and
2080 SSAs discovered to be useless (if LHS is removed) will be added to it,
2081 otherwise it needs to be NULL.
2082
2083 It is up to caller to iteratively transform each "speculative"
2084 direct call as appropriate. */
2085 static gimple *redirect_call_stmt_to_callee (cgraph_edge *e,
2086 hash_set <tree>
2087 *killed_ssas = nullptr);
2088
2089 /* Create clone of edge in the node N represented
2090 by CALL_EXPR the callgraph. */
2091 cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
2093 bool update_original);
2094
2095 /* Verify edge count and frequency. */
2096 bool verify_count ();
2097
2098 /* Return true when call of edge cannot lead to return from caller
2099 and thus it is safe to ignore its side effects for IPA analysis
2100 when computing side effects of the caller. */
2101 bool cannot_lead_to_return_p (void);
2102
2103 /* Return true when the edge represents a direct recursion. */
2104 bool recursive_p (void);
2105
2106 /* Return true if the edge may be considered hot after scalling its count. */
2107 bool maybe_hot_p ();
2109 /* Return true if the edge may be considered hot after scalling its count
2110 (i.e. assume that optimization would reduce runtime for callee,
2111 possibly significantly). */
2112 bool maybe_hot_p (sreal scale);
2113
2114 /* Get unique identifier of the edge. */
2115 inline int get_uid () const
2116 {
2117 return m_uid;
2118 }
2119
2120 /* Get summary id of the edge. */
2121 inline int get_summary_id ()
2122 {
2123 return m_summary_id;
2124 }
2125
2126 /* Rebuild cgraph edges for current function node. This needs to be run after
2127 passes that don't update the cgraph. */
2128 static unsigned int rebuild_edges (void);
2129
2130 /* Rebuild cgraph references for current function node. This needs to be run
2131 after passes that don't update the cgraph. */
2132 static void rebuild_references (void);
2133
2134 /* During LTO stream in this can be used to check whether call can possibly
2135 be internal to the current translation unit. */
2138 /* Return num_speculative_targets of this edge. */
2141 /* Expected number of executions: calculated in profile.cc. */
2150 /* Additional information about an indirect call. Not cleared when an edge
2151 becomes direct. */
2153 void *GTY ((skip (""))) aux;
2154 /* When equal to CIF_OK, inline this call. Otherwise, points to the
2155 explanation why function was not inlined. */
2157 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
2158 when the function is serialized in. */
2159 unsigned int lto_stmt_uid;
2160 /* speculative id is used to link direct calls with their corresponding
2161 IPA_REF_ADDR references when representing speculative calls. */
2162 unsigned int speculative_id : 16;
2163 /* Whether this edge was made direct by indirect inlining. */
2164 unsigned int indirect_inlining_edge : 1;
2165 /* Whether this edge describes an indirect call with an undetermined
2166 callee. */
2167 unsigned int indirect_unknown_callee : 1;
2168 /* Whether this edge is still a dangling */
2169 /* True if the corresponding CALL stmt cannot be inlined. */
2170 unsigned int call_stmt_cannot_inline_p : 1;
2171 /* Can this call throw externally? */
2172 unsigned int can_throw_external : 1;
2173 /* Edges with SPECULATIVE flag represents indirect calls that was
2174 speculatively turned into direct (i.e. by profile feedback).
2175 The final code sequence will have form:
2176
2177 if (call_target == expected_fn)
2178 expected_fn ();
2179 else
2180 call_target ();
2181
2182 Every speculative call is represented by three components attached
2183 to a same call statement:
2184 1) a direct call (to expected_fn)
2185 2) an indirect call (to call_target)
2186 3) a IPA_REF_ADDR reference to expected_fn.
2187
2188 Optimizers may later redirect direct call to clone, so 1) and 3)
2189 do not need to necessarily agree with destination. */
2190 unsigned int speculative : 1;
2191 /* Edges with CALLBACK flag represent indirect calls to functions passed
2192 to their callers by argument. This is useful in cases, where the body
2193 of these caller functions is not known, e. g. qsort in glibc or
2194 GOMP_parallel in libgomp. These edges are never made into real calls,
2195 but are used instead to optimize these callback functions and later replace
2196 their addresses with their optimized versions. Edges with this flag set
2197 share their call statement with their callback-carrying edge. */
2198 unsigned int callback : 1;
2199 /* Edges with this flag set have one or more callback edges attached. They
2200 share their call statements with this edge. This flag represents the fact
2201 that the callee of this edge takes a function and it's parameters by
2202 argument and calls it at a later time. */
2203 unsigned int has_callback : 1;
2204 /* Set to true when caller is a constructor or destructor of polymorphic
2205 type. */
2206 unsigned in_polymorphic_cdtor : 1;
2207
2208 /* Return true if call must bind to current definition. */
2209 bool binds_to_current_def_p ();
2210
2211 /* Expected frequency of executions within the function.
2212 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
2213 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
2214 int frequency ();
2215
2216 /* Expected frequency of executions within the function. */
2218
2219 /* Expected frequency of executions within the function.
2220 If edge is speculative, sum all its indirect targets. */
2222private:
2223 /* Unique id of the edge. */
2224 int m_uid;
2225
2226 /* Summary id that is recycled. */
2227 int m_summary_id;
2228
2229 /* Remove the edge from the list of the callers of the callee. */
2230 void remove_caller (void);
2231
2232 /* Remove the edge from the list of the callees of the caller. */
2233 void remove_callee (void);
2234
2235 /* Set callee N of call graph edge and add it to the corresponding set of
2236 callers. */
2237 void set_callee (cgraph_node *n);
2238
2239 /* Output flags of edge to a file F. */
2240 void dump_edge_flags (FILE *f);
2241
2242 /* Dump edge to stderr. */
2245 /* Verify that call graph edge corresponds to DECL from the associated
2246 statement. Return true if the verification should fail. */
2247 bool verify_corresponds_to_fndecl (tree decl);
2248};
2250#define CGRAPH_FREQ_BASE 1000
2251#define CGRAPH_FREQ_MAX 100000
2253/* The varpool data structure.
2254 Each static variable decl has assigned varpool_node. */
2255
2256struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node
2257{
2258 /* Constructor. */
2259 explicit varpool_node ()
2262 {}
2263
2264 /* Dump given varpool node to F. */
2265 void dump (FILE *f);
2266
2267 /* Dump given varpool node to stderr. */
2268 void DEBUG_FUNCTION debug (void);
2269
2270 /* Remove variable from symbol table. */
2271 void remove (void);
2272
2273 /* Remove node initializer when it is no longer needed. */
2274 void remove_initializer (void);
2275
2276 void analyze (void);
2277
2278 /* Return variable availability. */
2280
2281 /* When doing LTO, read variable's constructor from disk if
2282 it is not already present. */
2283 tree get_constructor (void);
2284
2285 /* Return true if variable has constructor that can be used for folding. */
2286 bool ctor_useable_for_folding_p (void);
2287
2288 /* For given variable pool node, walk the alias chain to return the function
2289 the variable is alias of. Do not walk through thunks.
2290 When AVAILABILITY is non-NULL, get minimal availability in the chain.
2291 When REF is non-NULL, assume that reference happens in symbol REF
2292 when determining the availability. */
2295
2296 /* Return node that alias is aliasing. */
2297 inline varpool_node *get_alias_target (void);
2298
2299 /* Output one variable, if necessary. Return whether we output it. */
2300 bool assemble_decl (void);
2301
2302 /* For variables in named sections make sure get_variable_section
2303 is called before we switch to those sections. Then section
2304 conflicts between read-only and read-only requiring relocations
2305 sections can be resolved. */
2306 void finalize_named_section_flags (void);
2307
2308 /* Call callback on varpool symbol and aliases associated to varpool symbol.
2309 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2310 skipped. */
2311 bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
2312 void *data,
2313 bool include_overwritable);
2314
2315 /* Return true when variable should be considered externally visible. */
2316 bool externally_visible_p (void);
2317
2318 /* Return true when all references to variable must be visible
2319 in ipa_ref_list.
2320 i.e. if the variable is not externally visible or not used in some magic
2321 way (asm statement or such).
2322 The magic uses are all summarized in force_output flag. */
2323 inline bool all_refs_explicit_p ();
2324
2325 /* Return true when variable can be removed from variable pool
2326 if all direct calls are eliminated. */
2327 inline bool can_remove_if_no_refs_p (void);
2328
2329 /* Add the variable DECL to the varpool.
2330 Unlike finalize_decl function is intended to be used
2331 by middle end and allows insertion of new variable at arbitrary point
2332 of compilation. */
2333 static void add (tree decl);
2334
2335 /* Return varpool node for given symbol and check it is a function. */
2336 static inline varpool_node *get (const_tree decl);
2337
2338 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
2339 the middle end to output the variable to asm file, if needed or externally
2340 visible. */
2341 static void finalize_decl (tree decl);
2342
2343 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
2344 Extra name aliases are output whenever DECL is output. */
2346
2347 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
2348 Extra name aliases are output whenever DECL is output. */
2349 static varpool_node * create_alias (tree, tree);
2350
2351 /* Dump the variable pool to F. */
2352 static void dump_varpool (FILE *f);
2353
2354 /* Dump the variable pool to stderr. */
2355 static void DEBUG_FUNCTION debug_varpool (void);
2356
2357 /* Allocate new callgraph node and insert it into basic data structures. */
2358 static varpool_node *create_empty (void);
2359
2360 /* Return varpool node assigned to DECL. Create new one when needed. */
2361 static varpool_node *get_create (tree decl);
2362
2363 /* Given an assembler name, lookup node. */
2365
2366 /* Set when variable is scheduled to be assembled. */
2367 unsigned output : 1;
2368
2369 /* Set if the variable is dynamically initialized, except for
2370 function local statics. */
2371 unsigned dynamically_initialized : 1;
2373 enum tls_model tls_model : 3;
2374
2375 /* Set if the variable is known to be used by single function only.
2376 This is computed by ipa_single_use pass and used by late optimizations
2377 in places where optimization would be valid for local static variable
2378 if we did not do any inter-procedural code movement. */
2379 unsigned used_by_single_function : 1;
2380
2381private:
2382 /* Assemble thunks and aliases associated to varpool node. */
2383 void assemble_aliases (void);
2384
2385 /* Worker for call_for_node_and_aliases. */
2386 bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
2387 void *data,
2388 bool include_overwritable);
2389};
2390
2391/* Every top level asm statement is put into a asm_node. */
2392
2393struct GTY ((tag ("TOPLEVEL_ASM"))) asm_node: public toplevel_node {
2396 {}
2397 /* String for this asm node. */
2398 tree asm_str;
2399 /* Vector of referenced symbols used for LTO partitioning.
2400 Not populated in flag_ltrans. */
2401 vec<symtab_node*> GTY ((skip)) symbols_referenced;
2402};
2404
2405/* Report whether or not THIS symtab node is a function, aka cgraph_node. */
2406
2407template <>
2408template <>
2409inline bool
2411{
2412 return p && p->type == SYMTAB_FUNCTION;
2414
2415/* Report whether or not THIS symtab node is a variable, aka varpool_node. */
2416
2417template <>
2418template <>
2419inline bool
2421{
2422 return p && p->type == SYMTAB_VARIABLE;
2424
2425/* Report whether or not THIS toplevel node is a function, aka cgraph_node. */
2426
2427template <>
2428template <>
2429inline bool
2431{
2432 return p && p->type == SYMTAB_FUNCTION;
2434
2435/* Report whether or not THIS toplevel node is a variable, aka varpool_node. */
2436
2437template <>
2438template <>
2439inline bool
2441{
2442 return p && p->type == SYMTAB_VARIABLE;
2444
2445/* Report whether or not THIS toplevel node is a symtab_node. */
2446
2447template <>
2448template <>
2449inline bool
2451{
2452 return p && p->type >= SYMTAB_SYMBOL;
2453}
2455/* Report whether or not THIS toplevel node is a toplevel assembly, aka
2456 asm_node. */
2457
2458template <>
2459template <>
2460inline bool
2462{
2463 return p && p->type == TOPLEVEL_ASM;
2465
2466/* Report whether or not THIS indirect info is a known simple one. */
2467
2468template <>
2469template <>
2470inline bool
2472{
2473 return p && p->kind == CIIK_SIMPLE;
2474}
2476/* Likewise, but const qualified. */
2477
2478template <>
2479template <>
2480inline bool
2481is_a_helper <const cgraph_simple_indirect_info *>
2483{
2484 return p && p->kind == CIIK_SIMPLE;
2485}
2487/* Report whether or not THIS indirect info is a known polymorphic one. */
2488
2489template <>
2490template <>
2491inline bool
2492is_a_helper <cgraph_polymorphic_indirect_info *>
2494{
2495 return p && p->kind == CIIK_POLYMORPHIC;
2496}
2498/* Likewise, but const qualified. */
2499
2500template <>
2501template <>
2502inline bool
2503is_a_helper <const cgraph_polymorphic_indirect_info *>
2506 return p && p->kind == CIIK_POLYMORPHIC;
2507}
2508
2509typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
2510typedef void (*cgraph_node_hook)(cgraph_node *, void *);
2511typedef void (*varpool_node_hook)(varpool_node *, void *);
2512typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
2513typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
2514
2521/* Map from a symbol to initialization/finalization priorities. */
2522struct GTY(()) symbol_priority_map {
2524 priority_type fini;
2526
2528{
2529 /* Frontend is parsing and finalizing functions. */
2530 PARSING,
2531 /* Callgraph is being constructed. It is safe to add new functions. */
2533 /* Callgraph is being streamed-in at LTO time. */
2535 /* Callgraph is built and early IPA passes are being run. */
2537 /* Callgraph is built and all functions are transformed to SSA form. */
2539 /* All inline decisions are done; it is now possible to remove extern inline
2540 functions and virtual call targets. */
2542 /* Functions are now ordered and being passed to RTL expanders. */
2544 /* All cgraph expansion is done. */
2545 FINISHED
2546};
2547
2548struct asmname_hasher : ggc_ptr_hash <symtab_node>
2549{
2550 typedef const_tree compare_type;
2551
2552 static hashval_t hash (symtab_node *n);
2553 static bool equal (symtab_node *n, const_tree t);
2554};
2555
2556/* Core summaries maintained about symbols. */
2558struct thunk_info;
2559template <class T> class function_summary;
2560typedef function_summary <thunk_info *> thunk_summary;
2561
2563template <class T> class function_summary;
2564typedef function_summary <clone_info *> clone_summary;
2565
2566class GTY((tag ("SYMTAB"))) symbol_table
2567{
2568public:
2569 friend struct symtab_node;
2570 friend struct cgraph_node;
2571 friend struct cgraph_edge;
2572
2573 symbol_table ():
2578 order (0), max_unit (0), global_info_ready (false), state (PARSING),
2587 {
2588 }
2589
2590 /* Initialize callgraph dump file. */
2591 void initialize (void);
2592
2593 /* Register a top-level asm statement ASM_STR. */
2594 inline asm_node *finalize_toplevel_asm (tree asm_str);
2595
2596 /* Analyze the whole compilation unit once it is parsed completely. */
2597 void finalize_compilation_unit (void);
2598
2599 /* C++ frontend produce same body aliases all over the place, even before PCH
2600 gets streamed out. It relies on us linking the aliases with their function
2601 in order to do the fixups, but ipa-ref is not PCH safe. Consequently we
2602 first produce aliases without links, but once C++ FE is sure it won't
2603 stream PCH we build the links via this function. */
2604 void process_same_body_aliases (void);
2605
2606 /* Perform simple optimizations based on callgraph. */
2607 void compile (void);
2608
2609 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
2610 functions into callgraph in a way so they look like ordinary reachable
2611 functions inserted into callgraph already at construction time. */
2612 void process_new_functions (void);
2613
2614 /* Register a symbol NODE. */
2615 inline void register_symbol (symtab_node *node);
2616
2617 inline void
2618 clear_asm_symbols (void)
2619 {
2620 asmnodes = NULL;
2622 }
2623
2624 /* Perform reachability analysis and reclaim all unreachable nodes. */
2625 bool remove_unreachable_nodes (FILE *file);
2626
2627 /* Optimization of function bodies might've rendered some variables as
2628 unnecessary so we want to avoid these from being compiled. Re-do
2629 reachability starting from variables that are either externally visible
2630 or was referred from the asm output routines. */
2631 void remove_unreferenced_decls (void);
2632
2633 /* Unregister a symbol NODE. */
2634 inline void unregister (symtab_node *node);
2635
2636 /* Allocate new callgraph node and insert it into basic data structures. */
2637 cgraph_node *create_empty (void);
2638
2639 /* Release a callgraph NODE. */
2640 void release_symbol (cgraph_node *node);
2641
2642 /* Output all variables enqueued to be assembled. */
2643 bool output_variables (void);
2644
2645 /* Weakrefs may be associated to external decls and thus not output
2646 at expansion time. Emit all necessary aliases. */
2647 void output_weakrefs (void);
2648
2649 /* Return first static symbol with definition. */
2650 inline symtab_node *first_symbol (void);
2651
2652 /* Return first assembler symbol. */
2653 inline asm_node *
2654 first_asm_symbol (void)
2655 {
2656 return asmnodes;
2657 }
2658
2659 /* Return first static symbol with definition. */
2660 inline symtab_node *first_defined_symbol (void);
2661
2662 /* Return first variable. */
2663 inline varpool_node *first_variable (void);
2664
2665 /* Return next variable after NODE. */
2666 inline varpool_node *next_variable (varpool_node *node);
2667
2668 /* Return first static variable with initializer. */
2669 inline varpool_node *first_static_initializer (void);
2670
2671 /* Return next static variable with initializer after NODE. */
2672 inline varpool_node *next_static_initializer (varpool_node *node);
2673
2674 /* Return first static variable with definition. */
2675 inline varpool_node *first_defined_variable (void);
2676
2677 /* Return next static variable with definition after NODE. */
2678 inline varpool_node *next_defined_variable (varpool_node *node);
2679
2680 /* Return first function with body defined. */
2681 inline cgraph_node *first_defined_function (void);
2682
2683 /* Return next function with body defined after NODE. */
2684 inline cgraph_node *next_defined_function (cgraph_node *node);
2685
2686 /* Return first function. */
2687 inline cgraph_node *first_function (void);
2688
2689 /* Return next function. */
2690 inline cgraph_node *next_function (cgraph_node *node);
2691
2692 /* Return first function with body defined. */
2693 cgraph_node *first_function_with_gimple_body (void);
2694
2695 /* Return next reachable static variable with initializer after NODE. */
2696 inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
2697
2698 /* Register HOOK to be called with DATA on each removed edge. */
2699 cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
2700 void *data);
2701
2702 /* Remove ENTRY from the list of hooks called on removing edges. */
2703 void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
2704
2705 /* Register HOOK to be called with DATA on each removed node. */
2706 cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
2707 void *data);
2708
2709 /* Remove ENTRY from the list of hooks called on removing nodes. */
2710 void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
2711
2712 /* Register HOOK to be called with DATA on each removed node. */
2713 varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
2714 void *data);
2715
2716 /* Remove ENTRY from the list of hooks called on removing nodes. */
2717 void remove_varpool_removal_hook (varpool_node_hook_list *entry);
2718
2719 /* Register HOOK to be called with DATA on each inserted node. */
2720 cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
2721 void *data);
2722
2723 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2724 void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
2725
2726 /* Register HOOK to be called with DATA on each inserted node. */
2727 varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
2728 void *data);
2729
2730 /* Remove ENTRY from the list of hooks called on inserted nodes. */
2731 void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
2732
2733 /* Register HOOK to be called with DATA on each duplicated edge. */
2734 cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
2735 void *data);
2736 /* Remove ENTRY from the list of hooks called on duplicating edges. */
2737 void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
2738
2739 /* Register HOOK to be called with DATA on each duplicated node. */
2740 cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
2741 void *data);
2742
2743 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
2744 void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
2745
2746 /* Call all edge removal hooks. */
2747 void call_edge_removal_hooks (cgraph_edge *e);
2748
2749 /* Call all node insertion hooks. */
2750 void call_cgraph_insertion_hooks (cgraph_node *node);
2751
2752 /* Call all node removal hooks. */
2753 void call_cgraph_removal_hooks (cgraph_node *node);
2754
2755 /* Call all node duplication hooks. */
2756 void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
2757
2758 /* Call all edge duplication hooks. */
2759 void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
2760
2761 /* Call all node removal hooks. */
2762 void call_varpool_removal_hooks (varpool_node *node);
2763
2764 /* Call all node insertion hooks. */
2765 void call_varpool_insertion_hooks (varpool_node *node);
2766
2767 /* Arrange node to be first in its entry of assembler_name_hash. */
2768 void symtab_prevail_in_asm_name_hash (symtab_node *node);
2769
2770 /* Initialize asm name hash unless. */
2771 void symtab_initialize_asm_name_hash (void);
2772
2773 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2775
2776 /* Dump symbol table to F. */
2777 void dump (FILE *f);
2778
2779 /* Dump symbol table to F in graphviz format. */
2780 void dump_graphviz (FILE *f);
2781
2782 /* Dump symbol table to stderr. */
2783 void DEBUG_FUNCTION debug (void);
2784
2785 /* Assign a new summary ID for the callgraph NODE. */
2786 inline int assign_summary_id (cgraph_node *node)
2787 {
2788 if (!cgraph_released_summary_ids.is_empty ())
2789 node->m_summary_id = cgraph_released_summary_ids.pop ();
2790 else
2791 node->m_summary_id = cgraph_max_summary_id++;
2792
2793 return node->m_summary_id;
2794 }
2795
2796 /* Assign a new summary ID for the callgraph EDGE. */
2797 inline int assign_summary_id (cgraph_edge *edge)
2798 {
2799 if (!edge_released_summary_ids.is_empty ())
2800 edge->m_summary_id = edge_released_summary_ids.pop ();
2801 else
2802 edge->m_summary_id = edges_max_summary_id++;
2803
2804 return edge->m_summary_id;
2807 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
2808 name. */
2809 static bool assembler_names_equal_p (const char *name1, const char *name2);
2811 int cgraph_count;
2812 int cgraph_max_uid;
2814
2815 int edges_count;
2818
2819 /* Vector of released summary IDS for cgraph nodes. */
2822 /* Vector of released summary IDS for cgraph nodes. */
2824
2825 /* Return symbol used to separate symbol name from suffix. */
2826 static char symbol_suffix_separator ();
2827
2829 asm_node* GTY(()) asmnodes;
2832 /* The order index of the next symtab node to be created. This is
2833 used so that we can sort the cgraph nodes in order by when we saw
2834 them, to support -fno-toplevel-reorder. */
2835 int order;
2837 /* Maximal unit ID used. */
2839
2840 /* Set when whole unit has been analyzed so we can access global info. */
2841 bool global_info_ready;
2842 /* What state callgraph is in right now. */
2844 /* Set when the cgraph is fully build and the basic flags are computed. */
2848
2849 /* Hash table used to hold sections. */
2852 /* Hash table used to convert assembler names into nodes. */
2854
2855 /* Hash table used to hold init priorities. */
2857
2858 FILE* GTY ((skip)) dump_file;
2859
2860 FILE* GTY ((skip)) ipa_clones_dump_file;
2862 hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;
2863
2864 /* Thunk annotations. */
2866
2867 /* Virtual clone annotations. */
2869
2870private:
2871 /* Allocate a cgraph_edge structure and fill it with data according to the
2872 parameters of which only CALLEE can be NULL (when creating an indirect
2873 call edge). CLONING_P should be set if properties that are copied from an
2874 original edge should not be calculated. */
2876 gcall *call_stmt, profile_count count,
2877 bool indir_unknown_callee, bool cloning_p);
2878
2879 /* Put the edge onto the free list. */
2880 void free_edge (cgraph_edge *e);
2881
2882 /* Insert NODE to assembler name hash. */
2883 void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
2884
2885 /* Remove NODE from assembler name hash. */
2886 void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
2888 /* Hash asmnames ignoring the user specified marks. */
2889 static hashval_t decl_assembler_name_hash (const_tree asmname);
2891 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2893
2894 friend struct asmname_hasher;
2895
2896 /* List of hooks triggered when an edge is removed. */
2898 /* List of hooks trigger_red when a cgraph node is removed. */
2900 /* List of hooks triggered when an edge is duplicated. */
2902 /* List of hooks triggered when a node is duplicated. */
2904 /* List of hooks triggered when an function is inserted. */
2906 /* List of hooks triggered when an variable is inserted. */
2908 /* List of hooks triggered when a node is removed. */
2911
2912extern GTY(()) symbol_table *symtab;
2913
2915
2916inline hashval_t
2921}
2922
2923inline bool
2925{
2926 return symbol_table::decl_assembler_name_equal (n->decl, t);
2927}
2928
2929/* In cgraph.cc */
2930void cgraph_cc_finalize (void);
2932
2933void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
2935
2938
2939/* In cgraphunit.cc */
2940void cgraphunit_cc_finalize (void);
2941int tp_first_run_node_cmp (const void *pa, const void *pb);
2942
2943/* In symtab-thunks.cc */
2944void symtab_thunks_cc_finalize (void);
2945
2946/* Initialize datastructures so DECL is a function in lowered gimple form.
2947 IN_SSA is true if the gimple is in SSA. */
2948basic_block init_lowered_empty_function (tree, bool, profile_count);
2949
2950tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree,
2951 HOST_WIDE_INT);
2952/* In cgraphclones.cc */
2953
2954tree clone_function_name_numbered (const char *name, const char *suffix);
2955tree clone_function_name_numbered (tree decl, const char *suffix);
2956tree clone_function_name (const char *name, const char *suffix,
2957 unsigned long number);
2958tree clone_function_name (tree decl, const char *suffix,
2959 unsigned long number);
2960tree clone_function_name (tree decl, const char *suffix);
2961tree clone_identifier (tree decl, const char *suffix,
2962 bool filter_suffix = false);
2963
2964void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
2965 ipa_param_adjustments *,
2966 bool, bitmap, basic_block);
2967
2968void dump_callgraph_transformation (const cgraph_node *original,
2969 const cgraph_node *clone,
2970 const char *suffix);
2971void set_new_clone_decl_and_node_flags (cgraph_node *new_node);
2972/* In cgraphbuild.cc */
2975
2976/* In ipa.cc */
2977void cgraph_build_static_cdtor (char which, tree body, int priority);
2978bool ipa_discover_variable_flags (void);
2979
2980/* In varpool.cc */
2982
2983/* In ipa-inline-analysis.cc */
2985bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);
2986
2987/* Return true when the symbol is real symbol, i.e. it is not inline clone
2988 or abstract function kept for debug info purposes only. */
2989inline bool
2991{
2992 cgraph_node *cnode;
2993
2994 if (DECL_ABSTRACT_P (decl))
2995 return false;
2997 return false;
2998 if (!is_a <cgraph_node *> (this))
2999 return true;
3000 cnode = dyn_cast <cgraph_node *> (this);
3001 if (cnode->inlined_to)
3002 return false;
3003 return true;
3004}
3005
3006/* Return true if DECL should have entry in symbol table if used.
3007 Those are functions and static & external variables. */
3008
3009inline bool
3012 return (TREE_CODE (decl) == FUNCTION_DECL
3013 || (VAR_P (decl)
3014 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
3015}
3016
3017inline bool
3019{
3020 symtab_node *source = this;
3021
3022 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
3023 {
3024 if (cn->inlined_to)
3025 source = cn->inlined_to;
3026 }
3027 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
3028 {
3029 if (cn->inlined_to)
3030 target = cn->inlined_to;
3031 }
3033 return source->get_comdat_group () == target->get_comdat_group ();
3034}
3035
3036/* Return node that alias is aliasing. */
3037
3038inline symtab_node *
3040{
3041 ipa_ref *ref = NULL;
3042 iterate_reference (0, ref);
3044 return ref->referred;
3045}
3046
3047/* Return the DECL (or identifier) that alias is aliasing. Unlike the above,
3048 this works whether or not the alias has been analyzed already. */
3049
3050inline tree
3052{
3053 if (alias_target)
3055 return get_alias_target ()->decl;
3056}
3057
3058/* Return next reachable static symbol with initializer after the node. */
3059
3060inline symtab_node *
3062{
3064
3065 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3066 if (node1->definition)
3067 return node1;
3069 return NULL;
3070}
3071
3072/* Iterates I-th reference in the list, REF is also set. */
3073
3074inline ipa_ref *
3076{
3077 ref_list.references.iterate (i, &ref);
3079 return ref;
3080}
3081
3082/* Iterates I-th referring item in the list, REF is also set. */
3083
3084inline ipa_ref *
3086{
3087 ref_list.referring.iterate (i, &ref);
3089 return ref;
3090}
3091
3092/* Iterates I-th referring alias item in the list, REF is also set. */
3093
3094inline ipa_ref *
3096{
3097 ref_list.referring.iterate (i, &ref);
3098
3099 if (ref && ref->use != IPA_REF_ALIAS)
3100 return NULL;
3102 return ref;
3103}
3104
3105/* Return true if list contains an alias. */
3106
3107inline bool
3109{
3110 ipa_ref *ref = NULL;
3111
3112 return (iterate_direct_aliases (0, ref) != NULL);
3113}
3114
3115/* Return true when RESOLUTION indicate that linker will use
3116 the symbol from non-LTO object files. */
3117
3118inline bool
3119resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
3120{
3121 return (resolution == LDPR_PREVAILING_DEF
3122 || resolution == LDPR_PREEMPTED_REG
3123 || resolution == LDPR_RESOLVED_EXEC
3124 || resolution == LDPR_RESOLVED_DYN);
3125}
3126
3127/* Return true when symtab_node is known to be used from other (non-LTO)
3128 object file. Known only when doing LTO via linker plugin. */
3129
3130inline bool
3132{
3133 if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
3134 return false;
3135 if (resolution_used_from_other_file_p (resolution))
3136 return true;
3137 return false;
3138}
3139
3140/* Return varpool node for given symbol and check it is a function. */
3141
3142inline varpool_node *
3144{
3147}
3148
3149/* Register a symbol NODE. */
3150
3151inline void
3153{
3154 node->next = nodes;
3155 node->previous = NULL;
3156
3157 if (nodes)
3158 nodes->previous = node;
3159 nodes = node;
3160
3161 nodes->m_uid = cgraph_max_uid++;
3162
3163 if (node->order == -1)
3164 node->order = order++;
3165}
3166
3167/* Register a top-level asm statement ASM_STR. */
3168
3169asm_node *
3171{
3172 asm_node *node;
3173
3174 node = new (ggc_cleared_alloc<asm_node> ()) asm_node (asm_str);
3175 node->order = order++;
3176
3177 if (asmnodes == NULL)
3178 asmnodes = node;
3179 else
3180 asm_last_node->next = node;
3183 return node;
3184}
3185
3186/* Unregister a symbol NODE. */
3187inline void
3189{
3190 if (node->previous)
3191 node->previous->next = node->next;
3192 else
3193 nodes = safe_as_a<symtab_node *>(node->next);
3194
3195 if (node->next)
3196 node->next->previous = node->previous;
3197
3198 node->next = NULL;
3199 node->previous = NULL;
3200}
3201
3202/* Release a callgraph NODE with UID and put in to the list of free nodes. */
3203
3204inline void
3206{
3207 cgraph_count--;
3208 if (node->m_summary_id != -1)
3209 cgraph_released_summary_ids.safe_push (node->m_summary_id);
3210 ggc_free (node);
3211}
3212
3213/* Return first static symbol with definition. */
3216{
3217 return nodes;
3218}
3219
3220/* Walk all symbols. */
3221#define FOR_EACH_SYMBOL(node) \
3222 for ((node) = symtab->first_symbol (); (node); \
3223 (node) = safe_as_a<symtab_node *>((node)->next))
3224
3225/* Return first static symbol with definition. */
3226inline symtab_node *
3228{
3230
3231 for (node = nodes; node;
3233 if (node->definition)
3234 return node;
3235
3236 return NULL;
3237}
3238
3239/* Walk all symbols with definitions in current unit. */
3240#define FOR_EACH_DEFINED_SYMBOL(node) \
3241 for ((node) = symtab->first_defined_symbol (); (node); \
3242 (node) = node->next_defined_symbol ())
3243
3244/* Return first variable. */
3245inline varpool_node *
3247{
3249 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3251 return vnode;
3252 return NULL;
3253}
3254
3255/* Return next variable after NODE. */
3256inline varpool_node *
3258{
3260 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3261 if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
3262 return vnode1;
3263 return NULL;
3264}
3265/* Walk all variables. */
3266#define FOR_EACH_VARIABLE(node) \
3267 for ((node) = symtab->first_variable (); \
3268 (node); \
3269 (node) = symtab->next_variable ((node)))
3270
3271/* Return first static variable with initializer. */
3272inline varpool_node *
3274{
3276 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3277 {
3279 if (vnode && DECL_INITIAL (node->decl))
3280 return vnode;
3281 }
3282 return NULL;
3283}
3284
3285/* Return next static variable with initializer after NODE. */
3286inline varpool_node *
3287symbol_table::next_static_initializer (varpool_node *node)
3288{
3289 symtab_node *node1 = safe_as_a<symtab_node *>(node->next);
3290 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3291 {
3292 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
3293 if (vnode1 && DECL_INITIAL (node1->decl))
3294 return vnode1;
3295 }
3296 return NULL;
3297}
3298
3299/* Walk all static variables with initializer set. */
3300#define FOR_EACH_STATIC_INITIALIZER(node) \
3301 for ((node) = symtab->first_static_initializer (); (node); \
3302 (node) = symtab->next_static_initializer (node))
3303
3304/* Return first static variable with definition. */
3305inline varpool_node *
3307{
3309 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3310 {
3312 if (vnode && vnode->definition)
3313 return vnode;
3314 }
3315 return NULL;
3316}
3317
3318/* Return next static variable with definition after NODE. */
3319inline varpool_node *
3320symbol_table::next_defined_variable (varpool_node *node)
3321{
3322 symtab_node *node1 = safe_as_a<symtab_node *>(node->next);
3323 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3324 {
3326 if (vnode1 && vnode1->definition)
3327 return vnode1;
3328 }
3329 return NULL;
3330}
3331/* Walk all variables with definitions in current unit. */
3332#define FOR_EACH_DEFINED_VARIABLE(node) \
3333 for ((node) = symtab->first_defined_variable (); (node); \
3334 (node) = symtab->next_defined_variable (node))
3335
3336/* Return first function with body defined. */
3337inline cgraph_node *
3339{
3341 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3342 {
3344 if (cn && cn->definition)
3345 return cn;
3346 }
3347 return NULL;
3348}
3349
3350/* Return next function with body defined after NODE. */
3351inline cgraph_node *
3352symbol_table::next_defined_function (cgraph_node *node)
3353{
3354 symtab_node *node1 = safe_as_a<symtab_node *>(node->next);
3355 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3356 {
3357 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
3358 if (cn1 && cn1->definition)
3359 return cn1;
3360 }
3361 return NULL;
3362}
3363
3364/* Walk all functions with body defined. */
3365#define FOR_EACH_DEFINED_FUNCTION(node) \
3366 for ((node) = symtab->first_defined_function (); (node); \
3367 (node) = symtab->next_defined_function ((node)))
3368
3369/* Return first function. */
3370inline cgraph_node *
3372{
3374 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3376 return cn;
3377 return NULL;
3378}
3379
3380/* Return next function. */
3381inline cgraph_node *
3383{
3385 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3387 return cn1;
3388 return NULL;
3389}
3390
3391/* Return first function with body defined. */
3392inline cgraph_node *
3394{
3396 for (node = nodes; node; node = safe_as_a<symtab_node *>(node->next))
3397 {
3399 if (cn && cn->has_gimple_body_p ())
3400 return cn;
3401 }
3402 return NULL;
3403}
3404
3405/* Return next reachable static variable with initializer after NODE. */
3406inline cgraph_node *
3408{
3409 symtab_node *node1 = safe_as_a<symtab_node *>(node->next);
3410 for (; node1; node1 = safe_as_a<symtab_node *>(node1->next))
3411 {
3412 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
3413 if (cn1 && cn1->has_gimple_body_p ())
3414 return cn1;
3415 }
3416 return NULL;
3417}
3419/* Walk all functions. */
3420#define FOR_EACH_FUNCTION(node) \
3421 for ((node) = symtab->first_function (); (node); \
3422 (node) = symtab->next_function ((node)))
3423
3424/* Walk all functions but precompute so a node can be deleted if needed. */
3425#define FOR_EACH_FUNCTION_REMOVABLE(node) \
3426 cgraph_node *next; \
3427 for ((node) = symtab->first_function (), \
3428 next = (node) ? symtab->next_function ((node)) : NULL; (node); \
3429 (node) = next, next = (node) ? symtab->next_function ((node)) : NULL)
3430
3431/* Return true when callgraph node is a function with Gimple body defined
3432 in current unit. Functions can also be define externally or they
3433 can be thunks with no Gimple representation.
3434
3435 Note that at WPA stage, the function body may not be present in memory. */
3436
3437inline bool
3439{
3440 return definition && !thunk && !alias;
3441}
3442
3443/* Walk all functions with body defined. */
3444#define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
3445 for ((node) = symtab->first_function_with_gimple_body (); (node); \
3446 (node) = symtab->next_function_with_gimple_body (node))
3448/* Uniquize all constants that appear in memory.
3449 Each constant in memory thus far output is recorded
3450 in `const_desc_table'. */
3451
3452struct GTY((for_user)) constant_descriptor_tree {
3453 /* A MEM for the constant. */
3454 rtx rtl;
3456 /* The value of the constant. */
3457 tree value;
3458
3459 /* Hash of value. Computing the hash from value each time
3460 hashfn is called can't work properly, as that means recursive
3461 use of the hash table during hash table expansion. */
3462 hashval_t hash;
3464
3465/* Return true when function is only called directly or it has alias.
3466 i.e. it is not externally visible, address was not taken and
3467 it is not used in any other non-standard way. */
3468
3469inline bool
3471{
3472 gcc_assert (!inlined_to);
3473 return (!force_output && !address_taken
3474 && !ref_by_asm
3475 && !ifunc_resolver
3476 && !used_from_other_partition
3477 && !DECL_VIRTUAL_P (decl)
3480 && !used_from_object_file_p ()
3482}
3483
3484/* Return true when function can be removed from callgraph
3485 if all direct calls are eliminated. */
3486
3487inline bool
3489{
3490 gcc_checking_assert (!inlined_to);
3491 /* Extern inlines can always go, we will use the external definition. */
3492 if (DECL_EXTERNAL (decl))
3493 return true;
3494 /* When function is needed, we cannot remove it. */
3495 if (force_output || used_from_other_partition || ref_by_asm)
3496 return false;
3499 return false;
3500 /* Only COMDAT functions can be removed if externally visible. */
3501 if (externally_visible
3502 && ((!DECL_COMDAT (decl) || ifunc_resolver)
3503 || forced_by_abi
3504 || used_from_object_file_p ()))
3505 return false;
3506 return true;
3507}
3508
3509/* Verify cgraph, if consistency checking is enabled. */
3510
3511inline void
3513{
3514 if (flag_checking)
3516}
3517
3518/* Return true when variable can be removed from variable pool
3519 if all direct calls are eliminated. */
3520
3521inline bool
3523{
3524 if (DECL_EXTERNAL (decl))
3525 return true;
3526 return (!force_output && !used_from_other_partition
3527 && !ref_by_asm
3528 && ((DECL_COMDAT (decl)
3529 && !forced_by_abi
3530 && !used_from_object_file_p ())
3531 || !externally_visible
3533}
3535/* Return true when all references to variable must be visible in ipa_ref_list.
3536 i.e. if the variable is not externally visible or not used in some magic
3537 way (asm statement or such).
3538 The magic uses are all summarized in force_output flag. */
3539
3540inline bool
3542{
3543 return (definition
3544 && !externally_visible
3545 && !used_from_other_partition
3546 && !ref_by_asm
3547 && !force_output);
3548}
3549
3550struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
3551{
3552 static hashval_t hash (constant_descriptor_tree *);
3553 static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
3554};
3556/* Constant pool accessor function. */
3558
3559/* Return node that alias is aliasing. */
3560
3561inline cgraph_node *
3567/* Return node that alias is aliasing. */
3568
3569inline varpool_node *
3571{
3573}
3574
3575/* Walk the alias chain to return the symbol NODE is alias of.
3576 If NODE is not an alias, return NODE.
3577 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3578 When REF is non-NULL, assume that reference happens in symbol REF
3579 when determining the availability. */
3580
3581inline symtab_node *
3583 symtab_node *ref)
3584{
3585 if (!alias)
3586 {
3587 if (availability)
3589 return this;
3590 }
3591
3593}
3594
3595/* Given function symbol, walk the alias chain to return the function node
3596 is alias of. Do not walk through thunks.
3597 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3598 When REF is non-NULL, assume that reference happens in symbol REF
3599 when determining the availability. */
3600
3601inline cgraph_node *
3603 symtab_node *ref)
3604{
3607 if (!n && availability)
3609 return n;
3610}
3611
3612/* For given variable pool node, walk the alias chain to return the function
3613 the variable is alias of. Do not walk through thunks.
3614 When AVAILABILITY is non-NULL, get minimal availability in the chain.
3615 When REF is non-NULL, assume that reference happens in symbol REF
3616 when determining the availability. */
3617
3618inline varpool_node *
3620 symtab_node *ref)
3621{
3624
3625 if (!n && availability)
3627 return n;
3628}
3629
3630/* Set callee N of call graph edge and add it to the corresponding set of
3631 callers. */
3632
3633inline void
3635{
3636 prev_caller = NULL;
3637 if (n->callers)
3638 n->callers->prev_caller = this;
3639 next_caller = n->callers;
3640 n->callers = this;
3641 callee = n;
3642}
3643
3644/* Return true when the edge represents a direct recursion. */
3645
3646inline bool
3648{
3649 cgraph_node *c = callee->ultimate_alias_target ();
3650 if (caller->inlined_to)
3651 return caller->inlined_to->decl == c->decl;
3652 else
3653 return caller->decl == c->decl;
3654}
3655
3656/* Remove the edge from the list of the callers of the callee. */
3657
3658inline void
3660{
3661 gcc_assert (!indirect_unknown_callee);
3662 if (prev_caller)
3663 prev_caller->next_caller = next_caller;
3664 if (next_caller)
3665 next_caller->prev_caller = prev_caller;
3668}
3669
3670/* Return true if call must bind to current definition. */
3671
3672inline bool
3674{
3675 if (callee)
3676 return callee->binds_to_current_def_p (caller);
3677 else
3678 return false;
3680
3681/* Expected frequency of executions within the function.
3682 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
3683 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
3684
3685inline int
3687{
3688 return count.to_cgraph_frequency (caller->inlined_to
3690 : caller->count);
3691}
3692
3693
3694/* Return true if the TM_CLONE bit is set for a given FNDECL. */
3695inline bool
3697{
3698 cgraph_node *n = cgraph_node::get (fndecl);
3699 if (n)
3700 return n->tm_clone;
3701 return false;
3702}
3703
3704/* Likewise indicate that a node is needed, i.e. reachable via some
3705 external means. */
3706
3707inline void
3709{
3712}
3713
3714/* Return true if function should be optimized for size. */
3715
3716inline enum optimize_size_level
3718{
3719 if (opt_for_fn (decl, optimize_size))
3720 return OPTIMIZE_SIZE_MAX;
3721 if (count == profile_count::zero ())
3722 return OPTIMIZE_SIZE_MAX;
3723 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
3725 else
3727}
3728
3729/* Return symtab_node for NODE or create one if it is not present
3730 in symtab. */
3731
3732inline symtab_node *
3734{
3735 if (VAR_P (node))
3737 else
3739}
3740
3741/* Return availability of NODE when referenced from REF. */
3742
3743inline enum availability
3745{
3746 if (is_a <cgraph_node *> (this))
3747 return dyn_cast <cgraph_node *> (this)->get_availability (ref);
3748 else
3749 return dyn_cast <varpool_node *> (this)->get_availability (ref);
3750}
3751
3752/* Call callback on symtab node and aliases associated to this node.
3753 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */
3754
3755inline bool
3757 void *),
3758 void *data,
3759 bool include_overwritable)
3760{
3761 if (include_overwritable
3762 || get_availability () > AVAIL_INTERPOSABLE)
3763 {
3764 if (callback (this, data))
3765 return true;
3766 }
3767 if (has_aliases_p ())
3768 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3769 return false;
3771
3772/* Call callback on function and aliases associated to the function.
3773 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3774 skipped. */
3775
3776inline bool
3778 void *),
3779 void *data,
3780 bool include_overwritable)
3781{
3782 if (include_overwritable
3783 || get_availability () > AVAIL_INTERPOSABLE)
3784 {
3785 if (callback (this, data))
3786 return true;
3787 }
3788 if (has_aliases_p ())
3789 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3790 return false;
3792
3793/* Call callback on varpool symbol and aliases associated to varpool symbol.
3794 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
3795 skipped. */
3796
3797inline bool
3799 void *),
3800 void *data,
3801 bool include_overwritable)
3802{
3803 if (include_overwritable
3804 || get_availability () > AVAIL_INTERPOSABLE)
3805 {
3806 if (callback (this, data))
3807 return true;
3808 }
3809 if (has_aliases_p ())
3810 return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
3811 return false;
3812}
3813
3814/* Return true if reference may be used in address compare. */
3815
3816inline bool
3818{
3819 if (use != IPA_REF_ADDR)
3820 return false;
3821 /* Addresses taken from virtual tables are never compared. */
3822 if (is_a <varpool_node *> (referring)
3823 && DECL_VIRTUAL_P (referring->decl))
3824 return false;
3825 return referred->address_can_be_compared_p ();
3826}
3827
3828/* Build polymorphic call context for indirect call E. */
3829
3830inline
3832{
3835 *this = pii->context;
3836}
3837
3838/* Build empty "I know nothing" context. */
3839
3840inline
3842{
3843 clear_speculation ();
3845 invalid = false;
3846}
3847
3848/* Make context non-speculative. */
3849
3850inline void
3852{
3853 speculative_outer_type = NULL;
3854 speculative_offset = 0;
3856}
3857
3858/* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is
3859 NULL, the context is set to dummy "I know nothing" setting. */
3860
3861inline void
3863{
3864 outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
3865 offset = 0;
3866 maybe_derived_type = true;
3868 dynamic = true;
3869}
3870
3871/* Adjust all offsets in contexts by OFF bits. */
3872
3873inline void
3875{
3876 if (outer_type)
3877 offset += off;
3879 speculative_offset += off;
3880}
3881
3882/* Return TRUE if context is fully useless. */
3883
3884inline bool
3886{
3887 return (!outer_type && !speculative_outer_type);
3888}
3889
3890/* When using fprintf (or similar), problems can arise with
3891 transient generated strings. Many string-generation APIs
3892 only support one result being alive at once (e.g. by
3893 returning a pointer to a statically-allocated buffer).
3894
3895 If there is more than one generated string within one
3896 fprintf call: the first string gets evicted or overwritten
3897 by the second, before fprintf is fully evaluated.
3898 See e.g. PR/53136.
3899
3900 This function provides a workaround for this, by providing
3901 a simple way to create copies of these transient strings,
3902 without the need to have explicit cleanup:
3903
3904 fprintf (dumpfile, "string 1: %s string 2:%s\n",
3905 xstrdup_for_dump (EXPR_1),
3906 xstrdup_for_dump (EXPR_2));
3907
3908 This is actually a simple wrapper around ggc_strdup, but
3909 the name documents the intent. We require that no GC can occur
3910 within the fprintf call. */
3911
3912inline const char *
3913xstrdup_for_dump (const char *transient_str)
3915 return ggc_strdup (transient_str);
3916}
3917
3918/* During LTO stream-in this predicate can be used to check whether node
3919 in question prevails in the linking to save some memory usage. */
3920inline bool
3922{
3923 return definition && ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
3924 || previous_sharing_asm_name == NULL);
3925}
3926
3927extern GTY(()) symbol_table *saved_symtab;
3928
3929#if CHECKING_P
3930
3931namespace selftest {
3932
3933/* An RAII-style class for use in selftests for temporarily using a different
3934 symbol_table, so that such tests can be isolated from each other. */
3935
3936class symbol_table_test
3937{
3938 public:
3939 /* Constructor. Override "symtab". */
3940 symbol_table_test ();
3941
3942 /* Destructor. Restore the saved_symtab. */
3943 ~symbol_table_test ();
3944};
3945
3946} // namespace selftest
3947
3948#endif /* CHECKING_P */
3949
3950#endif /* GCC_CGRAPH_H */
void analyze_toplevel_extended_asm()
Definition asm-toplevel.cc:97
gcov_type apply_scale(gcov_type freq, gcov_type scale)
Definition basic-block.h:577
void cgraph_update_edges_for_call_stmt(gimple *old_stmt, tree old_decl, gimple *new_stmt)
Definition cgraph.cc:2141
bool cgraph_function_possibly_inlined_p(tree decl)
Definition cgraph.cc:2841
symbol_table * symtab
Definition cgraph.cc:79
cgraph_inline_failed_type_t cgraph_inline_failed_type(cgraph_inline_failed_t reason)
Definition cgraph.cc:2509
const char *const cgraph_availability_names[]
Definition cgraph.cc:2525
void release_function_body(tree decl)
Definition cgraph.cc:2245
symbol_table * saved_symtab
Definition cgraph.cc:4925
void cgraph_cc_finalize(void)
Definition cgraph.cc:4775
const char * cgraph_inline_failed_string(cgraph_inline_failed_t reason)
Definition cgraph.cc:2491
symtab_state
Definition cgraph.h:2521
@ LTO_STREAMING
Definition cgraph.h:2527
@ IPA
Definition cgraph.h:2529
@ PARSING
Definition cgraph.h:2523
@ EXPANSION
Definition cgraph.h:2536
@ IPA_SSA_AFTER_INLINING
Definition cgraph.h:2534
@ FINISHED
Definition cgraph.h:2538
@ IPA_SSA
Definition cgraph.h:2531
@ CONSTRUCTION
Definition cgraph.h:2525
const char * xstrdup_for_dump(const char *transient_str)
Definition cgraph.h:3906
void debuginfo_early_stop(void)
Definition cgraphunit.cc:2555
cgraph_indirect_info_kind
Definition cgraph.h:1729
@ CIIK_UNSPECIFIED
Definition cgraph.h:1733
@ CIIK_N_KINDS
Definition cgraph.h:1740
@ CIIK_POLYMORPHIC
Definition cgraph.h:1738
@ CIIK_SIMPLE
Definition cgraph.h:1735
void debuginfo_start(void)
Definition cgraphunit.cc:2531
tree ctor_for_folding(tree)
Definition varpool.cc:428
struct varpool_node_set_def * varpool_node_set
Definition cgraph.h:1599
bool ipa_discover_variable_flags(void)
Definition ipa.cc:790
void symtab_thunks_cc_finalize(void)
Definition symtab-thunks.cc:660
int compute_call_stmt_bb_frequency(tree, basic_block bb)
Definition cgraphbuild.cc:202
void debuginfo_early_init(void)
Definition cgraphunit.cc:2491
cgraph_inline_failed_type_t
Definition cgraph.h:900
@ CIF_FINAL_NORMAL
Definition cgraph.h:901
@ CIF_FINAL_ERROR
Definition cgraph.h:902
void(*) cgraph_node_hook(cgraph_node *, void *)
Definition cgraph.h:2503
void set_new_clone_decl_and_node_flags(cgraph_node *new_node)
Definition cgraphclones.cc:179
bool speculation_useful_p(struct cgraph_edge *e, bool anticipate_inlining)
Definition ipa-inline.cc:1971
symbol_table * symtab
Definition cgraph.cc:79
void debuginfo_stop(void)
Definition cgraphunit.cc:2539
void record_references_in_initializer(tree, bool)
Definition cgraphbuild.cc:407
cgraph_node_set_def * cgraph_node_set
Definition cgraph.h:1598
basic_block init_lowered_empty_function(tree, bool, profile_count)
Definition cgraphunit.cc:1739
tree clone_function_name_numbered(const char *name, const char *suffix)
Definition cgraphclones.cc:526
void tree_function_versioning(tree, tree, vec< ipa_replace_map *, va_gc > *, ipa_param_adjustments *, bool, bitmap, basic_block)
Definition tree-inline.cc:6327
hash_table< tree_descriptor_hasher > * constant_pool_htab(void)
Definition varasm.cc:3361
void dump_callgraph_transformation(const cgraph_node *original, const cgraph_node *clone, const char *suffix)
Definition cgraphclones.cc:338
bool usable_polymorphic_info_p(cgraph_indirect_call_info *ii)
Definition cgraph.h:1869
bool decl_is_tm_clone(const_tree fndecl)
Definition cgraph.h:3689
void(*) cgraph_edge_hook(cgraph_edge *, void *)
Definition cgraph.h:2502
void cgraphunit_cc_finalize(void)
Definition cgraphunit.cc:2636
tree clone_function_name(const char *name, const char *suffix, unsigned long number)
Definition cgraphclones.cc:557
void cgraph_build_static_cdtor(char which, tree body, int priority)
Definition ipa.cc:943
availability
Definition cgraph.h:74
@ AVAIL_UNSET
Definition cgraph.h:76
@ AVAIL_LOCAL
Definition cgraph.h:92
@ AVAIL_NOT_AVAILABLE
Definition cgraph.h:78
@ AVAIL_INTERPOSABLE
Definition cgraph.h:84
@ AVAIL_AVAILABLE
Definition cgraph.h:87
void debuginfo_early_start(void)
Definition cgraphunit.cc:2547
int tp_first_run_node_cmp(const void *pa, const void *pb)
Definition cgraphunit.cc:1956
void debuginfo_fini(void)
Definition cgraphunit.cc:2520
symbol_partitioning_class
Definition cgraph.h:97
@ SYMBOL_EXTERNAL
Definition cgraph.h:100
@ SYMBOL_PARTITION
Definition cgraph.h:102
@ SYMBOL_DUPLICATE
Definition cgraph.h:105
tree thunk_adjust(gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree, HOST_WIDE_INT)
Definition symtab-thunks.cc:190
void(*) cgraph_2node_hook(cgraph_node *, cgraph_node *, void *)
Definition cgraph.h:2506
void initialize_inline_failed(struct cgraph_edge *)
Definition ipa-inline-analysis.cc:104
tree clone_identifier(tree decl, const char *suffix, bool filter_suffix=false)
Definition cgraphclones.cc:618
bool decl_in_symtab_p(const_tree decl)
Definition cgraph.h:3003
ipa_opt_pass_d * ipa_opt_pass
Definition cgraph.h:38
void(*) varpool_node_hook(varpool_node *, void *)
Definition cgraph.h:2504
function_summary< thunk_info * > thunk_summary
Definition cgraph.h:2553
void(*) cgraph_2edge_hook(cgraph_edge *, cgraph_edge *, void *)
Definition cgraph.h:2505
toplevel_type
Definition cgraph.h:45
@ TOPLEVEL_MAX
Definition cgraph.h:51
@ TOPLEVEL_ASM
Definition cgraph.h:47
@ TOPLEVEL_BASE
Definition cgraph.h:46
@ SYMTAB_FUNCTION
Definition cgraph.h:49
@ SYMTAB_SYMBOL
Definition cgraph.h:48
@ SYMTAB_VARIABLE
Definition cgraph.h:50
const char *const ld_plugin_symbol_resolution_names[]
Definition symtab.cc:45
const char *const tls_model_names[]
Definition varpool.cc:40
cgraph_simd_clone_arg_type
Definition cgraph.h:759
@ SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP
Definition cgraph.h:763
@ SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP
Definition cgraph.h:768
@ SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP
Definition cgraph.h:772
@ SIMD_CLONE_ARG_TYPE_VECTOR
Definition cgraph.h:760
@ SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP
Definition cgraph.h:770
@ SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP
Definition cgraph.h:769
@ SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP
Definition cgraph.h:764
@ SIMD_CLONE_ARG_TYPE_MASK
Definition cgraph.h:773
@ SIMD_CLONE_ARG_TYPE_UNIFORM
Definition cgraph.h:761
@ SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP
Definition cgraph.h:767
@ SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP
Definition cgraph.h:771
function_summary< clone_info * > clone_summary
Definition cgraph.h:2557
vec< cgraph_node * > cgraph_new_nodes
Definition cgraphunit.cc:216
cgraph_inline_failed_t
Definition cgraph.h:894
void debuginfo_init(void)
Definition cgraphunit.cc:2507
bool resolution_used_from_other_file_p(enum ld_plugin_symbol_resolution resolution)
Definition cgraph.h:3112
Definition cgraph.h:1877
ipa_ref * speculative_call_target_ref()
Definition cgraph.h:2028
void purge_callback_edges()
Definition cgraph.cc:1488
cgraph_edge * speculative_call_indirect_edge()
Definition cgraph.h:2006
unsigned int indirect_inlining_edge
Definition cgraph.h:2157
void remove_caller(void)
Definition cgraph.cc:1214
profile_count count
Definition cgraph.h:2135
cgraph_node * callee
Definition cgraph.h:2137
void dump_edge_flags(FILE *f)
Definition cgraph.cc:2531
static cgraph_edge * make_direct(cgraph_edge *edge, cgraph_node *callee)
Definition cgraph.cc:1659
bool binds_to_current_def_p()
Definition cgraph.h:3666
unsigned int callback
Definition cgraph.h:2191
cgraph_edge * make_callback(cgraph_node *n2, unsigned fn_idx, tree attr)
Definition cgraph.cc:1363
cgraph_edge * prev_caller
Definition cgraph.h:2138
cgraph_edge * next_caller
Definition cgraph.h:2139
unsigned int can_throw_external
Definition cgraph.h:2165
static cgraph_edge * resolve_speculation(cgraph_edge *edge, tree callee_decl=NULL)
Definition cgraph.cc:1571
int m_summary_id
Definition cgraph.h:2220
int m_uid
Definition cgraph.h:2217
int get_uid() const
Definition cgraph.h:2108
void redirect_callee(cgraph_node *n)
Definition cgraph.cc:1733
unsigned in_polymorphic_cdtor
Definition cgraph.h:2199
cgraph_edge * next_speculative_call_target()
Definition cgraph.h:1992
sreal sreal_frequency()
Definition cgraph.cc:4822
unsigned int speculative_id
Definition cgraph.h:2155
cgraph_indirect_call_info * indirect_info
Definition cgraph.h:2145
static unsigned int rebuild_edges(void)
Definition cgraphbuild.cc:423
cgraph_edge * make_speculative(cgraph_node *n2, profile_count direct_count, unsigned int speculative_id=0)
Definition cgraph.cc:1315
static void rebuild_references(void)
Definition cgraphbuild.cc:468
friend class symbol_table
Definition cgraph.h:1880
unsigned int call_stmt_cannot_inline_p
Definition cgraph.h:2163
int get_summary_id()
Definition cgraph.h:2114
int num_speculative_call_targets_p(void)
Definition cgraph.cc:4887
bool callback_with_carrying_edge_p() const
Definition cgraph.cc:1442
void set_callee(cgraph_node *n)
Definition cgraph.h:3627
bool maybe_hot_p()
Definition cgraph.cc:3534
cgraph_edge * get_callback_carrying_edge()
Definition cgraph.cc:1427
unsigned int lto_stmt_uid
Definition cgraph.h:2152
void DEBUG_FUNCTION debug(void)
Definition cgraph.cc:2559
bool possibly_call_in_translation_unit_p(void)
Definition cgraph.cc:4853
cgraph_edge * speculative_call_for_target(cgraph_node *)
Definition cgraph.cc:1642
cgraph_node * caller
Definition cgraph.h:2136
enum cgraph_inline_failed_t inline_failed
Definition cgraph.h:2149
unsigned int speculative
Definition cgraph.h:2183
void remove_callee(void)
Definition cgraph.h:3652
static void remove(cgraph_edge *edge)
Definition cgraph.cc:1250
cgraph_edge * first_callback_edge()
Definition cgraph.cc:1453
static gimple * redirect_call_stmt_to_callee(cgraph_edge *e, hash_set< tree > *killed_ssas=nullptr)
Definition cgraph.cc:1798
bool verify_count()
Definition cgraph.cc:3789
unsigned int indirect_unknown_callee
Definition cgraph.h:2160
bool cannot_lead_to_return_p(void)
Definition cgraph.cc:3447
cgraph_edge * clone(cgraph_node *n, gcall *call_stmt, unsigned stmt_uid, profile_count num, profile_count den, bool update_original)
Definition cgraphclones.cc:98
cgraph_edge * next_callback_edge()
Definition cgraph.cc:1471
static cgraph_edge * make_callback_internal(cgraph_node *caller, cgraph_node *target, gcall *call_stmt)
Definition cgraph.cc:1397
sreal combined_sreal_frequency()
Definition cgraph.cc:4833
bool recursive_p(void)
Definition cgraph.h:3640
int frequency()
Definition cgraph.h:3679
unsigned int has_callback
Definition cgraph.h:2196
cgraph_edge * first_speculative_call_target()
Definition cgraph.cc:1507
cgraph_edge * next_callee
Definition cgraph.h:2141
int get_next_speculative_id()
Definition cgraph.cc:1271
void * aux
Definition cgraph.h:2146
static cgraph_edge * set_call_stmt(cgraph_edge *e, gcall *new_stmt, bool update_derived_edges=true)
Definition cgraph.cc:960
gcall * call_stmt
Definition cgraph.h:2142
bool verify_corresponds_to_fndecl(tree decl)
Definition cgraph.cc:3823
friend struct cgraph_node
Definition cgraph.h:1879
cgraph_edge * prev_callee
Definition cgraph.h:2140
void redirect_callee_duplicating_thunks(cgraph_node *n)
Definition cgraphclones.cc:294
Definition cgraph.h:1748
cgraph_indirect_call_info(int flags)
Definition cgraph.h:1750
void DEBUG_FUNCTION debug() const
Definition cgraph.cc:2833
int ecf_flags
Definition cgraph.h:1763
cgraph_indirect_call_info(enum cgraph_indirect_info_kind k, int flags)
Definition cgraph.h:1753
int param_index
Definition cgraph.h:1766
void dump(FILE *f, bool newline=true) const
Definition cgraph.cc:2791
enum cgraph_indirect_info_kind kind
Definition cgraph.h:1769
unsigned num_speculative_call_targets
Definition cgraph.h:1771
Definition cgraph.h:1821
bool mark_unusable()
Definition cgraph.h:1844
cgraph_polymorphic_indirect_info(int flags)
Definition cgraph.h:1823
bool usable_p() const
Definition cgraph.h:1838
ipa_polymorphic_call_context context
Definition cgraph.h:1852
HOST_WIDE_INT otr_token
Definition cgraph.h:1854
tree otr_type
Definition cgraph.h:1856
unsigned vptr_changed
Definition cgraph.h:1863
cgraph_polymorphic_indirect_info(int flags, const ipa_polymorphic_call_context &ctx, HOST_WIDE_INT token, tree type)
Definition cgraph.h:1827
HOST_WIDE_INT offset
Definition cgraph.h:1859
HOST_WIDE_INT offset
Definition cgraph.h:1789
unsigned by_ref
Definition cgraph.h:1808
unsigned member_ptr
Definition cgraph.h:1802
unsigned fld_offset
Definition cgraph.h:1796
unsigned guaranteed_unmodified
Definition cgraph.h:1813
unsigned agg_contents
Definition cgraph.h:1800
cgraph_simple_indirect_info(int flags)
Definition cgraph.h:1780
unsigned fnptr_loaded_from_record
Definition cgraph.h:1805
tree rec_type
Definition cgraph.h:1792
Definition lto-streamer.h:788
Definition genoutput.cc:151
Definition symbol-summary.h:163
Definition hash-map.h:40
Definition hash-set.h:37
Definition hash-table.h:375
Definition tree-pass.h:142
Definition ipa-param-manipulation.h:211
Definition cgraph.h:1629
void dump(FILE *f, bool newline=true) const
Definition ipa-polymorphic-call.cc:621
bool combine_speculation_with(tree, HOST_WIDE_INT, bool, tree)
Definition ipa-polymorphic-call.cc:1924
void offset_by(HOST_WIDE_INT)
Definition cgraph.h:3867
bool speculation_consistent_p(tree, HOST_WIDE_INT, bool, tree) const
Definition ipa-polymorphic-call.cc:1866
tree outer_type
Definition cgraph.h:1636
unsigned invalid
Definition cgraph.h:1647
unsigned speculative_maybe_derived_type
Definition cgraph.h:1644
HOST_WIDE_INT speculative_offset
Definition cgraph.h:1635
void DEBUG_FUNCTION debug() const
Definition ipa-polymorphic-call.cc:660
unsigned dynamic
Definition cgraph.h:1649
void clear_speculation()
Definition cgraph.h:3844
void clear_outer_type(tree otr_type=NULL)
Definition cgraph.h:3855
unsigned maybe_in_construction
Definition cgraph.h:1639
bool useless_p() const
Definition cgraph.h:3878
ipa_polymorphic_call_context()
Definition cgraph.h:3834
bool meet_with(ipa_polymorphic_call_context, tree otr_type=NULL)
Definition ipa-polymorphic-call.cc:2448
bool set_by_invariant(tree, tree, HOST_WIDE_INT)
Definition ipa-polymorphic-call.cc:765
tree speculative_outer_type
Definition cgraph.h:1637
void make_speculative(tree otr_type=NULL)
Definition ipa-polymorphic-call.cc:2347
bool equal_to(const ipa_polymorphic_call_context &x) const
Definition ipa-polymorphic-call.cc:2396
HOST_WIDE_INT offset
Definition cgraph.h:1634
void possible_dynamic_type_change(bool, tree otr_type=NULL)
Definition ipa-polymorphic-call.cc:2372
bool get_dynamic_type(tree, tree, tree, gimple *, unsigned *)
Definition ipa-polymorphic-call.cc:1571
void set_by_decl(tree, HOST_WIDE_INT)
Definition ipa-polymorphic-call.cc:736
void stream_in(class lto_input_block *, class data_in *data_in)
Definition ipa-polymorphic-call.cc:698
void stream_out(struct output_block *) const
Definition ipa-polymorphic-call.cc:668
bool restrict_to_inner_class(tree otr_type, bool consider_placement_new=true, bool consider_bases=true)
Definition ipa-polymorphic-call.cc:132
bool meet_speculation_with(tree, HOST_WIDE_INT, bool, tree)
Definition ipa-polymorphic-call.cc:2021
unsigned maybe_derived_type
Definition cgraph.h:1641
bool combine_with(ipa_polymorphic_call_context, tree otr_type=NULL)
Definition ipa-polymorphic-call.cc:2117
Definition lto-streamer.h:349
Definition sreal.h:41
Definition cgraph.h:2560
varpool_node_hook_list * add_varpool_removal_hook(varpool_node_hook hook, void *data)
Definition varpool.cc:53
varpool_node * next_defined_variable(varpool_node *node)
Definition cgraph.h:3313
int order
Definition cgraph.h:2828
varpool_node * first_variable(void)
Definition cgraph.h:3239
cgraph_node * first_defined_function(void)
Definition cgraph.h:3331
varpool_node * next_static_initializer(varpool_node *node)
Definition cgraph.h:3280
hash_table< asmname_hasher > * assembler_name_hash
Definition cgraph.h:2846
void free_edge(cgraph_edge *e)
Definition cgraph.cc:1236
vec< int > edge_released_summary_ids
Definition cgraph.h:2816
int assign_summary_id(cgraph_edge *edge)
Definition cgraph.h:2790
cgraph_2edge_hook_list * add_edge_duplication_hook(cgraph_2edge_hook hook, void *data)
Definition cgraph.cc:572
static char symbol_suffix_separator()
Definition symtab.cc:2576
void remove_cgraph_duplication_hook(cgraph_2node_hook_list *entry)
Definition cgraph.cc:630
void DEBUG_FUNCTION debug(void)
Definition symtab.cc:1068
varpool_node_hook_list * m_first_varpool_insertion_hook
Definition cgraph.h:2900
static bool decl_assembler_name_equal(tree decl, const_tree asmname)
Definition symtab.cc:142
symbol_table()
Definition cgraph.h:2566
cgraph_edge * create_edge(cgraph_node *caller, cgraph_node *callee, gcall *call_stmt, profile_count count, bool indir_unknown_callee, bool cloning_p)
Definition cgraph.cc:1066
symtab_node * first_defined_symbol(void)
Definition cgraph.h:3220
bool global_info_ready
Definition cgraph.h:2834
void clear_asm_symbols(void)
Definition cgraph.h:2611
bool function_flags_ready
Definition cgraph.h:2838
thunk_summary * m_thunks
Definition cgraph.h:2858
friend struct cgraph_edge
Definition cgraph.h:2564
bool output_variables(void)
Definition varpool.cc:764
void remove_varpool_removal_hook(varpool_node_hook_list *entry)
Definition varpool.cc:70
cgraph_edge_hook_list * m_first_edge_removal_hook
Definition cgraph.h:2890
asm_node * asmnodes
Definition cgraph.h:2822
void call_cgraph_duplication_hooks(cgraph_node *node, cgraph_node *node2)
Definition cgraph.cc:642
friend struct symtab_node
Definition cgraph.h:2562
int edges_count
Definition cgraph.h:2808
void compile(void)
Definition cgraphunit.cc:2344
static bool assembler_names_equal_p(const char *name1, const char *name2)
Definition symtab.cc:104
FILE * ipa_clones_dump_file
Definition cgraph.h:2853
cgraph_node * next_defined_function(cgraph_node *node)
Definition cgraph.h:3345
void remove_varpool_insertion_hook(varpool_node_hook_list *entry)
Definition varpool.cc:111
void call_edge_removal_hooks(cgraph_edge *e)
Definition cgraph.cc:477
asm_node * first_asm_symbol(void)
Definition cgraph.h:2647
void release_symbol(cgraph_node *node)
Definition cgraph.h:3198
cgraph_2node_hook_list * m_first_cgraph_duplicated_hook
Definition cgraph.h:2896
cgraph_node_hook_list * add_cgraph_insertion_hook(cgraph_node_hook hook, void *data)
Definition cgraph.cc:543
cgraph_node * next_function(cgraph_node *node)
Definition cgraph.h:3375
hash_table< section_name_hasher > * section_hash
Definition cgraph.h:2843
void output_weakrefs(void)
Definition cgraphunit.cc:2314
bool remove_unreachable_nodes(FILE *file)
Definition ipa.cc:309
void remove_cgraph_insertion_hook(cgraph_node_hook_list *entry)
Definition cgraph.cc:560
void unregister(symtab_node *node)
Definition cgraph.h:3181
cgraph_2node_hook_list * add_cgraph_duplication_hook(cgraph_2node_hook hook, void *data)
Definition cgraph.cc:613
void process_same_body_aliases(void)
Definition cgraphunit.cc:725
varpool_node_hook_list * m_first_varpool_removal_hook
Definition cgraph.h:2902
cgraph_node_hook_list * add_cgraph_removal_hook(cgraph_node_hook hook, void *data)
Definition cgraph.cc:489
clone_summary * m_clones
Definition cgraph.h:2861
hash_set< const cgraph_node * > cloned_nodes
Definition cgraph.h:2855
void initialize(void)
Definition cgraph.cc:428
cgraph_node * next_function_with_gimple_body(cgraph_node *node)
Definition cgraph.h:3400
int cgraph_max_summary_id
Definition cgraph.h:2806
void call_cgraph_insertion_hooks(cgraph_node *node)
Definition cgraph.cc:530
FILE * dump_file
Definition cgraph.h:2851
static hashval_t decl_assembler_name_hash(const_tree asmname)
Definition symtab.cc:82
varpool_node_hook_list * add_varpool_insertion_hook(varpool_node_hook hook, void *data)
Definition varpool.cc:94
void finalize_compilation_unit(void)
Definition cgraphunit.cc:2563
void process_new_functions(void)
Definition cgraphunit.cc:301
void symtab_initialize_asm_name_hash(void)
Definition symtab.cc:260
friend struct asmname_hasher
Definition cgraph.h:2887
int cgraph_max_uid
Definition cgraph.h:2805
void dump_graphviz(FILE *f)
Definition symtab.cc:1058
bool cpp_implicit_aliases_done
Definition cgraph.h:2840
cgraph_node_hook_list * m_first_cgraph_removal_hook
Definition cgraph.h:2892
asm_node * finalize_toplevel_asm(tree asm_str)
Definition cgraph.h:3163
cgraph_node * create_empty(void)
Definition cgraph.cc:440
symtab_node * first_symbol(void)
Definition cgraph.h:3208
int cgraph_count
Definition cgraph.h:2804
cgraph_node * first_function(void)
Definition cgraph.h:3364
void call_cgraph_removal_hooks(cgraph_node *node)
Definition cgraph.cc:518
int max_unit
Definition cgraph.h:2831
vec< int > cgraph_released_summary_ids
Definition cgraph.h:2813
enum symtab_state state
Definition cgraph.h:2836
void remove_edge_removal_hook(cgraph_edge_hook_list *entry)
Definition cgraph.cc:465
cgraph_edge_hook_list * add_edge_removal_hook(cgraph_edge_hook hook, void *data)
Definition cgraph.cc:448
varpool_node * first_static_initializer(void)
Definition cgraph.h:3266
int assign_summary_id(cgraph_node *node)
Definition cgraph.h:2779
cgraph_node_hook_list * m_first_cgraph_insertion_hook
Definition cgraph.h:2898
symtab_node * nodes
Definition cgraph.h:2821
void dump(FILE *f)
Definition symtab.cc:1049
void register_symbol(symtab_node *node)
Definition cgraph.h:3145
void call_varpool_insertion_hooks(varpool_node *node)
Definition varpool.cc:123
varpool_node * first_defined_variable(void)
Definition cgraph.h:3299
int edges_max_uid
Definition cgraph.h:2809
void remove_cgraph_removal_hook(cgraph_node_hook_list *entry)
Definition cgraph.cc:506
void symtab_prevail_in_asm_name_hash(symtab_node *node)
Definition symtab.cc:251
cgraph_2edge_hook_list * m_first_edge_duplicated_hook
Definition cgraph.h:2894
cgraph_node * first_function_with_gimple_body(void)
Definition cgraph.h:3386
void insert_to_assembler_name_hash(symtab_node *node, bool with_clones)
Definition symtab.cc:162
void call_edge_duplication_hooks(cgraph_edge *cs1, cgraph_edge *cs2)
Definition cgraph.cc:601
void remove_edge_duplication_hook(cgraph_2edge_hook_list *entry)
Definition cgraph.cc:589
varpool_node * next_variable(varpool_node *node)
Definition cgraph.h:3250
void unlink_from_assembler_name_hash(symtab_node *node, bool with_clones)
Definition symtab.cc:203
friend struct cgraph_node
Definition cgraph.h:2563
void call_varpool_removal_hooks(varpool_node *node)
Definition varpool.cc:82
asm_node * asm_last_node
Definition cgraph.h:2823
hash_map< symtab_node *, symbol_priority_map > * init_priority_hash
Definition cgraph.h:2849
int edges_max_summary_id
Definition cgraph.h:2810
void remove_unreferenced_decls(void)
Definition varpool.cc:660
bool debug
Definition collect-utils.cc:34
struct basic_block_def * basic_block
Definition coretypes.h:359
struct rtx_def * rtx
Definition coretypes.h:57
optimize_size_level
Definition coretypes.h:464
@ OPTIMIZE_SIZE_BALANCED
Definition coretypes.h:468
@ OPTIMIZE_SIZE_NO
Definition coretypes.h:466
@ OPTIMIZE_SIZE_MAX
Definition coretypes.h:470
class edge_def * edge
Definition coretypes.h:356
@ TLS_MODEL_NONE
Definition coretypes.h:216
union section section
Definition coretypes.h:164
node_frequency
Definition coretypes.h:274
@ NODE_FREQUENCY_NORMAL
Definition coretypes.h:282
@ NODE_FREQUENCY_UNLIKELY_EXECUTED
Definition coretypes.h:277
const union tree_node * const_tree
Definition coretypes.h:98
#define GTY(x)
Definition coretypes.h:41
class bitmap_head * bitmap
Definition coretypes.h:51
union tree_node * tree
Definition coretypes.h:97
void change_decl_assembler_name(tree, tree)
void ggc_free(void *)
Definition genmatch.cc:52
T * ggc_cleared_alloc(ALONE_CXX_MEM_STAT_INFO)
Definition ggc.h:217
#define ggc_strdup(S)
Definition ggc.h:281
bool set_comdat_group(symtab_node *symbol, void *head_p)
Definition ipa-comdats.cc:208
ipa_ref_use
Definition ipa-ref.h:31
@ IPA_REF_ALIAS
Definition ipa-ref.h:35
@ IPA_REF_ADDR
Definition ipa-ref.h:34
bool is_a(U *p)
Definition is-a.h:230
T safe_as_a(U *p)
Definition is-a.h:264
T as_a(U *p)
Definition is-a.h:253
T dyn_cast(U *p)
Definition is-a.h:280
Definition custom-sarif-properties/state-graphs.h:33
const json::string_property function
@ n
Definition graphviz.h:249
Definition dump-context.h:31
void dump(const T &obj)
Definition dump.h:70
section * get_section(const char *, unsigned int, tree, bool not_existing=false)
Definition varasm.cc:289
poly_int< NUM_POLY_INT_COEFFS, unsigned HOST_WIDE_INT > poly_uint64
Definition poly-int-types.h:25
poly_int< N, C > r
Definition poly-int.h:774
i
Definition poly-int.h:776
profile_quality
Definition profile-count.h:30
#define REG_BR_PROB_BASE
Definition profile-count.h:75
rtx find_replacement(rtx *loc)
Definition reload.cc:6390
Definition cgraph.h:2386
tree asm_str
Definition cgraph.h:2391
vec< symtab_node * > symbols_referenced
Definition cgraph.h:2394
asm_node(tree asm_str)
Definition cgraph.h:2387
Definition cgraph.h:2542
static bool equal(symtab_node *n, const_tree t)
Definition cgraph.h:2917
static hashval_t hash(symtab_node *n)
Definition cgraph.h:2910
const_tree compare_type
Definition cgraph.h:2543
Definition cgraph.cc:96
Definition cgraph.cc:103
Definition cgraph.h:908
static bool equal(cgraph_edge *, gimple *)
Definition cgraph.cc:849
static hashval_t hash(cgraph_edge *)
Definition cgraph.cc:829
gimple * compare_type
Definition cgraph.h:909
Definition cgraph.cc:82
Definition cgraph.h:865
tree assembler_name
Definition cgraph.h:888
cgraph_node * this_node
Definition cgraph.h:867
cgraph_function_version_info * next
Definition cgraph.h:875
cgraph_function_version_info * prev
Definition cgraph.h:871
tree dispatcher_resolver
Definition cgraph.h:885
Definition cgraph.cc:89
Definition cgraph.h:1593
hash_map< cgraph_node *, size_t > * map
Definition cgraph.h:1594
vec< cgraph_node * > nodes
Definition cgraph.h:1595
Definition cgraph.h:1613
cgraph_node_set set
Definition cgraph.h:1614
unsigned index
Definition cgraph.h:1615
Definition cgraph.h:920
static cgraph_node * get(const_tree decl)
Definition cgraph.h:1406
cgraph_edge * indirect_calls
Definition cgraph.h:1464
void scale_profile_to(profile_count ipa_count)
Definition cgraph.cc:284
unsigned only_called_at_startup
Definition cgraph.h:1518
cgraph_node()
Definition cgraph.h:924
void DEBUG_FUNCTION debug(void)
Definition cgraph.cc:2770
void create_wrapper(cgraph_node *target)
Definition cgraphunit.cc:2651
struct cgraph_rtl_info * rtl
Definition cgraph.h:1490
bool can_remove_if_no_direct_calls_p(bool will_inline=false)
Definition cgraph.cc:3551
static void dump_cgraph(FILE *f)
Definition cgraph.cc:2778
enum node_frequency frequency
Definition cgraph.h:1516
void make_local(void)
Definition cgraph.cc:3006
enum availability get_availability(symtab_node *ref=NULL)
Definition cgraph.cc:2851
unsigned split_part
Definition cgraph.h:1552
unsigned nonfreeing_fn
Definition cgraph.h:1544
bool former_thunk_p(void)
Definition cgraph.cc:4908
void DEBUG_FUNCTION verify_node(void)
Definition cgraph.cc:4013
cgraph_node * create_thunk(tree alias, tree, bool this_adjusting, HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value, HOST_WIDE_INT indirect_offset, tree virtual_offset, tree real_alias)
Definition cgraph.cc:767
int count_materialization_scale
Definition cgraph.h:1496
unsigned int profile_id
Definition cgraph.h:1498
cgraph_edge * create_edge(cgraph_node *callee, gcall *call_stmt, profile_count count, bool cloning_p=false)
Definition cgraph.cc:1142
unsigned thunk
Definition cgraph.h:1505
void analyze(void)
Definition cgraphunit.cc:632
cgraph_function_version_info * insert_new_function_version(void)
Definition cgraph.cc:319
bool set_const_flag(bool set_const, bool looping)
Definition cgraph.cc:3334
unsigned tm_clone
Definition cgraph.h:1525
bool can_remove_if_no_direct_calls_and_refs_p(void)
Definition cgraph.h:3481
static cgraph_node * finalize_function(tree, bool)
Definition cgraphunit.cc:452
static cgraph_node * add_new_function(tree fndecl, bool lowered)
Definition cgraphunit.cc:533
bool get_body()
Definition cgraph.cc:4715
unsigned lowered
Definition cgraph.h:1510
int unit_id
Definition cgraph.h:1500
cgraph_edge * callers
Definition cgraph.h:1461
void set_call_stmt_including_clones(gimple *old_stmt, gcall *new_stmt, bool update_speculative=true)
Definition cgraphclones.cc:850
void expand_all_artificial_thunks()
Definition cgraphclones.cc:307
void remove(void)
Definition cgraph.cc:2320
unsigned icf_merged
Definition cgraph.h:1538
cgraph_node * next_sibling_clone
Definition cgraph.h:1465
cgraph_node * find_replacement(struct clone_info *)
Definition cgraphclones.cc:755
void remove_callees(void)
Definition cgraph.cc:2175
static void checking_verify_cgraph_nodes(void)
Definition cgraph.h:3505
cgraph_node * clones
Definition cgraph.h:1467
unsigned can_change_signature
Definition cgraph.h:1562
unsigned is_target_clone
Definition cgraph.h:1533
static void DEBUG_FUNCTION verify_cgraph_nodes(void)
Definition cgraph.cc:4575
static void add_function_version(cgraph_function_version_info *fn_v, tree decl)
Definition cgraph.cc:373
cgraph_node * get_alias_target(void)
Definition cgraph.h:3555
bool check_calls_comdat_local_p()
Definition cgraph.cc:4895
static cgraph_node * create_same_body_alias(tree alias, tree decl)
Definition cgraph.cc:742
void record_stmt_references(gimple *stmt)
Definition cgraphbuild.cc:290
cgraph_node * function_or_virtual_thunk_symbol(enum availability *avail=NULL, struct symtab_node *ref=NULL)
Definition cgraph.cc:4624
bool has_gimple_body_p(void)
Definition cgraph.h:3431
static bool has_thunk_p(cgraph_node *node, void *)
Definition cgraph.cc:4811
void remove_from_clone_tree()
Definition cgraphclones.cc:1200
unsigned calls_comdat_local
Definition cgraph.h:1536
cgraph_node * inlined_to
Definition cgraph.h:1488
cgraph_edge * create_indirect_edge(gcall *call_stmt, int ecf_flags, profile_count count, bool cloning_p=false)
Definition cgraph.cc:1170
friend class symbol_table
Definition cgraph.h:921
void make_profile_local()
Definition cgraph.cc:182
bool local_p(void)
Definition ipa-visibility.cc:113
cgraph_node * clone_of
Definition cgraph.h:1468
bool cannot_return_p(void)
Definition cgraph.cc:3431
static void delete_function_version_by_decl(tree decl)
Definition cgraph.cc:357
void dump(FILE *f)
Definition cgraph.cc:2573
priority_type get_fini_priority(void)
Definition symtab.cc:1859
bool set_malloc_flag(bool malloc_p)
Definition cgraph.cc:3101
bool call_for_symbol_and_aliases(bool(*callback)(cgraph_node *, void *), void *data, bool include_overwritable)
Definition cgraph.h:3770
unsigned gc_candidate
Definition cgraph.h:1573
void apply_scale(profile_count num, profile_count den)
Definition cgraph.cc:262
cgraph_node * function_symbol(enum availability *avail=NULL, struct symtab_node *ref=NULL)
Definition cgraph.cc:4597
struct function * get_fun() const
Definition cgraph.cc:4757
void mark_force_output(void)
Definition cgraph.h:3701
void create_edge_including_clones(cgraph_node *callee, gimple *old_stmt, gcall *stmt, profile_count count, cgraph_inline_failed_t reason)
Definition cgraphclones.cc:910
unsigned only_called_at_exit
Definition cgraph.h:1520
void dump_graphviz(FILE *f)
Definition cgraph.cc:2754
void release_body(bool keep_arguments=false)
Definition cgraph.cc:2287
profile_count count
Definition cgraph.h:1493
static cgraph_node * get_create(tree)
Definition cgraph.cc:685
bool set_nothrow_flag(bool nothrow)
Definition cgraph.cc:3053
cgraph_simd_clone * simdclone
Definition cgraph.h:1477
unsigned called_by_ifunc_resolver
Definition cgraph.h:1575
bool set_noreturn_flag(bool noreturn_p)
Definition cgraph.cc:3196
cgraph_node * create_version_clone_with_body(vec< cgraph_edge * > redirect_callers, vec< ipa_replace_map *, va_gc > *tree_map, ipa_param_adjustments *param_adjustments, bitmap bbs_to_copy, basic_block new_entry_block, const char *suffix, tree target_attributes=NULL_TREE, bool version_decl=true)
Definition cgraphclones.cc:1095
void expand(void)
Definition cgraphunit.cc:1828
vec< ipa_opt_pass, va_heap, vl_ptr > ipa_transforms_to_apply
Definition cgraph.h:1484
static cgraph_node * create_alias(tree alias, tree target)
Definition cgraph.cc:716
cgraph_edge * callees
Definition cgraph.h:1460
bool remove_symbol_and_inline_clones(cgraph_node *forbidden_node=NULL)
Definition cgraphclones.cc:963
hash_table< cgraph_edge_hasher > * call_site_hash
Definition cgraph.h:1471
unsigned indirect_call_target
Definition cgraph.h:1554
bool call_for_symbol_and_aliases_1(bool(*callback)(cgraph_node *, void *), void *data, bool include_overwritable)
Definition cgraph.cc:4790
bool only_called_directly_p(void)
Definition cgraph.cc:3682
void assemble_thunks_and_aliases(void)
Definition cgraphunit.cc:1785
unsigned assume_function
Definition cgraph.h:1540
unsigned ipcp_clone
Definition cgraph.h:1569
cgraph_function_version_info * function_version(void)
Definition cgraph.cc:169
bool can_be_local_p(void)
Definition cgraph.cc:2926
bool call_for_symbol_thunks_and_aliases(bool(*callback)(cgraph_node *node, void *data), void *data, bool include_overwritable, bool exclude_virtual_thunks=false)
Definition cgraph.cc:2938
unsigned merged_comdat
Definition cgraph.h:1546
unsigned dispatcher_resolver_function
Definition cgraph.h:1529
static cgraph_node * local_info_node(tree decl)
Definition cgraph.cc:2454
void materialize_clone(void)
Definition cgraphclones.cc:1216
unsigned parallelized_function
Definition cgraph.h:1550
static void debug_cgraph(void)
Definition cgraph.h:1369
unsigned versionable
Definition cgraph.h:1559
int m_summary_id
Definition cgraph.h:1582
unsigned has_omp_variant_constructs
Definition cgraph.h:1577
auto_vec< cgraph_edge * > collect_callers(void)
Definition cgraph.cc:3722
cgraph_node * prev_sibling_clone
Definition cgraph.h:1466
cgraph_edge * get_edge(gimple *call_stmt)
Definition cgraph.cc:904
unsigned local
Definition cgraph.h:1557
unsigned process
Definition cgraph.h:1513
static void delete_function_version(cgraph_function_version_info *)
Definition cgraph.cc:336
void make_profile_global0(profile_quality quality)
Definition cgraph.cc:204
void mark_address_taken(void)
Definition cgraph.cc:2430
unsigned redefined_extern_inline
Definition cgraph.h:1565
cgraph_node * create_virtual_clone(const vec< cgraph_edge * > &redirect_callers, vec< ipa_replace_map *, va_gc > *tree_map, ipa_param_adjustments *param_adjustments, const char *suffix, unsigned num_suffix)
Definition cgraphclones.cc:663
int tp_first_run
Definition cgraph.h:1502
static cgraph_node * create(tree decl)
Definition cgraph.cc:656
bool will_be_removed_from_program_if_no_direct_calls_p(bool will_inline=false)
Definition cgraph.cc:3623
tree former_clone_of
Definition cgraph.h:1473
bool get_untransformed_body()
Definition cgraph.cc:4646
bool is_clone_of(cgraph_node *n) const
Definition cgraph.cc:3692
bool only_called_directly_or_aliased_p(void)
Definition cgraph.h:3463
cgraph_node * create_version_clone(tree new_decl, vec< cgraph_edge * > redirect_callers, bitmap bbs_to_copy, const char *suffix=NULL)
Definition cgraphclones.cc:1016
cgraph_node * ultimate_alias_target(availability *availability=NULL, symtab_node *ref=NULL)
Definition cgraph.h:3595
static cgraph_node * get_for_asmname(tree asmname)
Definition cgraph.cc:812
cgraph_node * simd_clones
Definition cgraph.h:1479
unsigned merged_extern_inline
Definition cgraph.h:1548
bool add_detected_attribute(const char *attr)
Definition cgraph.cc:3149
int get_summary_id()
Definition cgraph.h:1375
cgraph_node * create_clone(tree decl, profile_count count, bool update_original, vec< cgraph_edge * > redirect_callers, bool call_duplication_hook, cgraph_node *new_inlined_to, ipa_param_adjustments *param_adjustments, const char *suffix)
Definition cgraphclones.cc:401
void set_fini_priority(priority_type priority)
Definition symtab.cc:1910
unsigned dispatcher_function
Definition cgraph.h:1527
enum optimize_size_level optimize_for_size_p(void)
Definition cgraph.h:3710
bool set_pure_flag(bool pure, bool looping)
Definition cgraph.cc:3417
void remove_callers(void)
Definition cgraph.cc:2212
unsigned used_as_abstract_origin
Definition cgraph.h:1508
unsigned tm_may_enter_irr
Definition cgraph.h:1567
static struct cgraph_rtl_info * rtl_info(const_tree)
Definition cgraph.cc:2466
Definition rtl.h:4761
Definition cgraph.h:779
unsigned int alignment
Definition cgraph.h:813
tree orig_arg
Definition cgraph.h:782
HOST_WIDE_INT linear_step
Definition cgraph.h:821
enum cgraph_simd_clone_arg_type arg_type
Definition cgraph.h:810
tree orig_type
Definition cgraph.h:786
tree vector_arg
Definition cgraph.h:794
tree vector_type
Definition cgraph.h:797
tree simd_array
Definition cgraph.h:806
Definition cgraph.h:826
cgraph_node * next_clone
Definition cgraph.h:855
poly_uint64 vecsize_int
Definition cgraph.h:835
unsigned int inbranch
Definition cgraph.h:852
poly_uint64 vecsize_float
Definition cgraph.h:838
machine_mode mask_mode
Definition cgraph.h:843
cgraph_simd_clone_arg args[1]
Definition cgraph.h:861
cgraph_node * prev_clone
Definition cgraph.h:855
poly_uint64 simdlen
Definition cgraph.h:828
cgraph_node * origin
Definition cgraph.h:858
unsigned int nargs
Definition cgraph.h:832
unsigned char vecsize_mangle
Definition cgraph.h:848
Definition symtab-clones.h:25
Definition cgraph.h:3445
hashval_t hash
Definition cgraph.h:3455
rtx rtl
Definition cgraph.h:3447
tree value
Definition cgraph.h:3450
Definition genautomata.cc:499
Definition gimple.h:356
Definition hash-traits.h:321
Definition gimple-iterator.h:26
Definition gimple.h:225
Definition ipa-ref.h:75
vec< ipa_ref_t *, va_heap, vl_ptr > referring
Definition ipa-ref.h:136
vec< ipa_ref_t, va_heap, vl_ptr > references
Definition ipa-ref.h:133
Definition ipa-ref.h:40
unsigned int speculative
Definition ipa-ref.h:67
enum ipa_ref_use use
Definition ipa-ref.h:66
gimple * stmt
Definition ipa-ref.h:60
symtab_node * referred
Definition ipa-ref.h:59
unsigned int speculative_id
Definition ipa-ref.h:65
bool address_matters_p()
Definition cgraph.h:3810
unsigned int lto_stmt_uid
Definition ipa-ref.h:61
symtab_node * referring
Definition ipa-ref.h:58
Definition cgraph.h:747
unsigned force_load_ref
Definition cgraph.h:755
tree new_tree
Definition cgraph.h:749
int parm_num
Definition cgraph.h:751
static bool test(const U *p)
Definition is-a.h:211
static bool test(U *p)
Definition lto-streamer.h:586
Definition lto-streamer.h:745
Definition profile-count.h:789
static profile_count zero()
Definition profile-count.h:837
Definition cgraph.h:58
int ref_count
Definition cgraph.h:59
char * name
Definition cgraph.h:60
Definition cgraph.h:66
const char * compare_type
Definition cgraph.h:67
static hashval_t hash(section_hash_entry *)
Definition symtab.cc:365
static bool equal(section_hash_entry *, const char *)
Definition symtab.cc:373
Definition cgraph.h:2515
priority_type fini
Definition cgraph.h:2517
priority_type init
Definition cgraph.h:2516
Definition cgraph.h:133
static bool set_implicit_section(symtab_node *n, void *)
Definition symtab.cc:1926
unsigned in_init_priority_hash
Definition cgraph.h:634
void dump_graphviz(FILE *f)
Definition symtab.cc:1042
symtab_node * get_alias_target(void)
Definition cgraph.h:3032
tree get_alias_target_tree()
Definition cgraph.h:3044
unsigned used_from_other_partition
Definition cgraph.h:621
const char * get_visibility_string() const
Definition symtab.cc:890
tree get_comdat_group_id()
Definition cgraph.h:283
tree x_comdat_group
Definition cgraph.h:676
void add_to_same_comdat_group(symtab_node *old_node)
Definition symtab.cc:495
tree alias_target
Definition cgraph.h:671
bool native_rtl_p() const
Definition cgraphunit.cc:226
ipa_ref * iterate_reference(unsigned i, ipa_ref *&ref)
Definition cgraph.h:3068
void dump(FILE *f)
Definition symtab.cc:1033
unsigned weakref
Definition cgraph.h:563
unsigned address_taken
Definition cgraph.h:632
bool address_matters_p()
Definition symtab.cc:2464
unsigned definition
Definition cgraph.h:536
static symtab_node * get(const_tree decl)
Definition cgraph.h:490
bool referred_to_p(bool include_self=true)
Definition cgraphunit.cc:425
priority_type get_init_priority()
Definition symtab.cc:1847
unsigned num_references(void)
Definition cgraph.h:255
ipa_ref * clone_reference(ipa_ref *ref, gimple *stmt)
Definition symtab.cc:743
void clone_references(symtab_node *node)
Definition symtab.cc:703
bool output_to_lto_symbol_table_p(void)
Definition symtab.cc:2648
const char * dump_asm_name() const
Definition symtab.cc:599
section_hash_entry * x_section
Definition cgraph.h:679
unsigned externally_visible
Definition cgraph.h:585
static DEBUG_FUNCTION void verify_symtab_nodes(void)
Definition symtab.cc:1482
void copy_visibility_from(symtab_node *n)
Definition symtab.cc:1601
bool has_aliases_p(void)
Definition cgraph.h:3101
struct symbol_priority_map * priority_info(void)
Definition symtab.cc:1872
const char * get_dump_name(bool asm_name_p) const
Definition symtab.cc:580
void unregister(struct clone_info *)
Definition symtab.cc:452
unsigned unique_name
Definition cgraph.h:606
void set_section(const char *section)
Definition symtab.cc:1830
const char * get_section() const
Definition cgraph.h:299
unsigned need_lto_streaming
Definition cgraph.h:638
symtab_node * next_defined_symbol(void)
Definition cgraph.h:3054
unsigned cpp_implicit_alias
Definition cgraph.h:570
void set_comdat_group(tree group)
Definition cgraph.h:291
void dump_base(FILE *)
Definition symtab.cc:907
void DEBUG_FUNCTION verify(void)
Definition symtab.cc:1370
bool call_for_symbol_and_aliases_1(bool(*callback)(symtab_node *, void *), void *data, bool include_overwrite)
Definition symtab.cc:2424
const char * name() const
Definition symtab.cc:567
void clear_stmts_in_references(void)
Definition symtab.cc:801
static void check_ifunc_callee_symtab_nodes(void)
Definition symtab.cc:1450
unsigned forced_by_abi
Definition cgraph.h:594
ipa_ref * find_reference(symtab_node *referred_node, gimple *stmt, unsigned int lto_stmt_uid, enum ipa_ref_use use_type)
Definition symtab.cc:761
enum availability get_availability(symtab_node *ref=NULL)
Definition cgraph.h:3737
void set_section_for_node(const char *section)
Definition symtab.cc:1754
symtab_node * ultimate_alias_target_1(enum availability *avail=NULL, symtab_node *ref=NULL)
Definition symtab.cc:1656
void remove_from_same_comdat_group(void)
Definition symtab.cc:429
friend class symbol_table
Definition cgraph.h:135
ipa_ref * maybe_create_reference(tree val, gimple *stmt)
Definition symtab.cc:672
int get_uid() const
Definition cgraph.h:524
symtab_node * same_comdat_group
Definition cgraph.h:663
void remove_all_references(void)
Definition symtab.cc:825
bool prevailing_p(void)
Definition cgraph.h:3914
unsigned ref_by_asm
Definition cgraph.h:598
unsigned no_reorder
Definition cgraph.h:587
void * aux
Definition cgraph.h:673
int equal_address_to(symtab_node *s2, bool memory_accessed=false)
Definition symtab.cc:2312
unsigned transparent_alias
Definition cgraph.h:561
unsigned implicit_section
Definition cgraph.h:609
bool address_can_be_compared_p(void)
Definition cgraph.cc:147
enum ld_plugin_symbol_resolution resolution
Definition cgraph.h:530
void clone_referring(symtab_node *node)
Definition symtab.cc:723
bool resolve_alias(symtab_node *target, bool transparent=false)
Definition symtab.cc:1938
symtab_node * previous_sharing_asm_name
Definition cgraph.h:660
bool can_be_discarded_p(void)
Definition cgraph.h:438
void remove_stmt_references(gimple *stmt)
Definition symtab.cc:782
unsigned semantic_interposition
Definition cgraph.h:614
static symtab_node * get_for_asmname(const_tree asmname)
Definition symtab.cc:1077
static symtab_node * get_create(tree node)
Definition cgraph.h:3726
unsigned refuse_visibility_changes
Definition cgraph.h:580
symtab_node(toplevel_type t)
Definition cgraph.h:138
ipa_ref * create_reference(symtab_node *referred_node, enum ipa_ref_use use_type)
Definition symtab.cc:609
void dump_references(FILE *file)
Definition symtab.cc:845
enum symbol_partitioning_class get_partitioning_class(void)
Definition symtab.cc:2167
tree decl
Definition cgraph.h:648
void dissolve_same_comdat_group_list(void)
Definition symtab.cc:530
unsigned must_remain_in_tu_name
Definition cgraph.h:601
unsigned symver
Definition cgraph.h:572
unsigned alias
Definition cgraph.h:539
void increase_alignment(unsigned int align)
Definition symtab.cc:2541
void make_decl_local(void)
Definition symtab.cc:1536
bool binds_to_current_def_p(symtab_node *ref=NULL)
Definition symtab.cc:2591
ipa_ref * iterate_direct_aliases(unsigned i, ipa_ref *&ref)
Definition cgraph.h:3088
bool semantically_equivalent_p(symtab_node *target)
Definition symtab.cc:2133
void remove_all_referring(void)
Definition symtab.cc:835
void reset(bool preserve_comdat_group=false)
Definition cgraphunit.cc:392
unsigned offloadable
Definition cgraph.h:641
void fixup_same_cpp_alias_visibility(symtab_node *target)
Definition symtab.cc:1718
bool in_same_comdat_group_p(symtab_node *target)
Definition cgraph.h:3011
const char * dump_name() const
Definition symtab.cc:593
unsigned must_remain_in_tu_body
Definition cgraph.h:604
static bool set_section_from_node(symtab_node *n, void *o)
Definition symtab.cc:1820
unsigned writeonly
Definition cgraph.h:577
const char * asm_name() const
Definition symtab.cc:557
unsigned int definition_alignment()
Definition symtab.cc:2565
void dump_referring(FILE *)
Definition symtab.cc:862
unsigned body_removed
Definition cgraph.h:612
symtab_node * noninterposable_alias(void)
Definition symtab.cc:2056
static void checking_verify_symtab_nodes(void)
Definition cgraph.h:724
ipa_ref_list ref_list
Definition cgraph.h:666
bool DEBUG_FUNCTION verify_base(void)
Definition symtab.cc:1115
unsigned force_output
Definition cgraph.h:590
static bool set_section_from_string(symtab_node *n, void *s)
Definition symtab.cc:1810
void register_symbol(void)
Definition symtab.cc:412
tree get_comdat_group()
Definition cgraph.h:277
symtab_node * ultimate_alias_target(enum availability *avail=NULL, struct symtab_node *ref=NULL)
Definition cgraph.h:3575
const char * get_symtab_type_string() const
Definition symtab.cc:899
bool real_symbol_p(void)
Definition cgraph.h:2983
unsigned analyzed
Definition cgraph.h:575
bool nonzero_address()
Definition symtab.cc:2298
void remove(void)
Definition symtab.cc:484
bool call_for_symbol_and_aliases(bool(*callback)(symtab_node *, void *), void *data, bool include_overwrite)
Definition cgraph.h:3749
int m_uid
Definition cgraph.h:703
bool comdat_local_p(void)
Definition cgraph.h:454
bool needed_p(void)
Definition cgraphunit.cc:239
unsigned in_other_partition
Definition cgraph.h:625
ipa_ref * iterate_referring(unsigned i, ipa_ref *&ref)
Definition cgraph.h:3078
symtab_node * next_sharing_asm_name
Definition cgraph.h:659
void set_init_priority(priority_type priority)
Definition symtab.cc:1893
bool used_from_object_file_p(void)
Definition cgraph.h:3124
bool can_increase_alignment_p()
Definition symtab.cc:2473
unsigned ifunc_resolver
Definition cgraph.h:644
Definition symtab-thunks.h:36
Definition gengtype-parse.cc:40
Definition cgraph.h:110
enum toplevel_type type
Definition cgraph.h:127
toplevel_node * next
Definition cgraph.h:120
int order
Definition cgraph.h:124
toplevel_node * previous
Definition cgraph.h:121
struct lto_file_decl_data * lto_file_data
Definition cgraph.h:117
toplevel_node(toplevel_type t)
Definition cgraph.h:112
struct symtab_node * symtab_node
Definition tree-core.h:2080
Definition cgraph.h:3544
static bool equal(constant_descriptor_tree *, constant_descriptor_tree *)
Definition varasm.cc:3492
static hashval_t hash(constant_descriptor_tree *)
Definition varasm.cc:3369
Definition gengtype.h:252
Definition loop-invariant.cc:78
Definition vec.h:283
Definition varpool.cc:45
Definition cgraph.h:1606
hash_map< varpool_node *, size_t > * map
Definition cgraph.h:1607
vec< varpool_node * > nodes
Definition cgraph.h:1608
Definition cgraph.h:1620
varpool_node_set set
Definition cgraph.h:1621
unsigned index
Definition cgraph.h:1622
Definition cgraph.h:2250
bool can_remove_if_no_refs_p(void)
Definition cgraph.h:3515
static void dump_varpool(FILE *f)
Definition varpool.cc:275
void remove_initializer(void)
Definition varpool.cc:223
static varpool_node * create_extra_name_alias(tree alias, tree decl)
Definition varpool.cc:827
void dump(FILE *f)
Definition varpool.cc:241
bool call_for_symbol_and_aliases_1(bool(*callback)(varpool_node *, void *), void *data, bool include_overwritable)
Definition varpool.cc:850
bool externally_visible_p(void)
Definition ipa-visibility.cc:265
void analyze(void)
Definition varpool.cc:553
static varpool_node * create_empty(void)
Definition varpool.cc:136
void DEBUG_FUNCTION debug(void)
Definition varpool.cc:268
static varpool_node * get_create(tree decl)
Definition varpool.cc:143
static varpool_node * get_for_asmname(tree asmname)
Definition varpool.cc:294
bool call_for_symbol_and_aliases(bool(*callback)(varpool_node *, void *), void *data, bool include_overwritable)
Definition cgraph.h:3791
unsigned output
Definition cgraph.h:2360
varpool_node()
Definition cgraph.h:2252
varpool_node * ultimate_alias_target(availability *availability=NULL, symtab_node *ref=NULL)
Definition cgraph.h:3612
static varpool_node * create_alias(tree, tree)
Definition varpool.cc:807
static void add(tree decl)
Definition varpool.cc:505
tree get_constructor(void)
Definition varpool.cc:306
varpool_node * get_alias_target(void)
Definition cgraph.h:3563
static varpool_node * get(const_tree decl)
Definition cgraph.h:3136
bool assemble_decl(void)
Definition varpool.cc:595
bool all_refs_explicit_p()
Definition cgraph.h:3534
void assemble_aliases(void)
Definition varpool.cc:575
static void finalize_decl(tree decl)
Definition cgraphunit.cc:969
availability get_availability(symtab_node *ref=NULL)
Definition varpool.cc:520
enum tls_model tls_model
Definition cgraph.h:2366
bool ctor_useable_for_folding_p(void)
Definition varpool.cc:350
void remove(void)
Definition varpool.cc:203
unsigned dynamically_initialized
Definition cgraph.h:2364
unsigned used_by_single_function
Definition cgraph.h:2372
static void DEBUG_FUNCTION debug_varpool(void)
Definition varpool.cc:287
void finalize_named_section_flags(void)
Definition varpool.cc:750
Definition vec.h:450
Definition vec.h:271
#define NULL
Definition system.h:55
#define gcc_assert(EXPR)
Definition system.h:772
#define gcc_unreachable()
Definition system.h:799
#define true
Definition system.h:845
#define false
Definition system.h:846
#define DEBUG_FUNCTION
Definition system.h:1145
#define gcc_checking_assert(EXPR)
Definition system.h:779
unsigned short priority_type
Definition tree-core.h:1178
use_type
Definition tree-ssa-loop-ivopts.cc:196
#define DECL_ASSEMBLER_NAME(NODE)
Definition tree.h:3624
#define DECL_HAS_VALUE_EXPR_P(NODE)
Definition tree.h:3387
#define DECL_SECTION_NAME(NODE)
Definition tree.h:3661
#define DECL_STATIC_CONSTRUCTOR(NODE)
Definition tree.h:3864
#define TYPE_MAIN_VARIANT(NODE)
Definition tree.h:2449
#define DECL_WEAK(NODE)
Definition tree.h:3591
#define DECL_STATIC_DESTRUCTOR(NODE)
Definition tree.h:3867
#define TREE_CODE(NODE)
Definition tree.h:327
#define DECL_ABSTRACT_P(NODE)
Definition tree.h:3290
#define DECL_COMDAT(NODE)
Definition tree.h:3606
#define opt_for_fn(fndecl, opt)
Definition tree.h:6700
#define DECL_INITIAL(NODE)
Definition tree.h:3210
#define TREE_STATIC(NODE)
Definition tree.h:787
#define DECL_COMMON(NODE)
Definition tree.h:3582
#define DECL_EXTERNAL(NODE)
Definition tree.h:3304
#define TREE_PUBLIC(NODE)
Definition tree.h:877
#define DECL_VIRTUAL_P(NODE)
Definition tree.h:3319
#define VAR_P(NODE)
Definition tree.h:238
#define NULL_TREE
Definition tree.h:320
#define DECL_P(NODE)
Definition tree.h:234
Definition output.h:519
struct tree_decl_with_vis decl_with_vis
Definition tree-core.h:2272
constexpr vnull vNULL
Definition vec.h:569