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