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