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