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