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