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