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