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