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