* ipa-polymorphic-call.c
[official-gcc.git] / gcc / cgraph.h
blobfc5fe82d1bec97f103561eac7ae96c5329062ac2
1 /* Callgraph handling code.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #ifndef GCC_CGRAPH_H
22 #define GCC_CGRAPH_H
25 /* Symbol table consists of functions and variables.
26 TODO: add labels and CONST_DECLs. */
27 enum symtab_type
29 SYMTAB_SYMBOL,
30 SYMTAB_FUNCTION,
31 SYMTAB_VARIABLE
34 /* Section names are stored as reference counted strings in GGC safe hashtable
35 (to make them survive through PCH). */
37 struct GTY((for_user)) section_hash_entry_d
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 */
45 typedef struct section_hash_entry_d section_hash_entry;
47 struct section_name_hasher : ggc_hasher<section_hash_entry *>
49 typedef const char *compare_type;
51 static hashval_t hash (section_hash_entry *);
52 static bool equal (section_hash_entry *, const char *);
55 enum availability
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
76 /* Classification of symbols WRT partitioning. */
77 enum symbol_partitioning_class
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
89 /* Base of all entries in the symbol table.
90 The symtab_node is inherited by cgraph and varpol nodes. */
91 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
92 chain_next ("%h.next"), chain_prev ("%h.previous")))
93 symtab_node
95 public:
96 /* Return name. */
97 const char *name () const;
99 /* Return asm name. */
100 const char * asm_name () const;
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);
106 /* Remove symbol from symbol table. */
107 void remove (void);
109 /* Dump symtab node to F. */
110 void dump (FILE *f);
112 /* Dump symtab node to stderr. */
113 void DEBUG_FUNCTION debug (void);
115 /* Verify consistency of node. */
116 void DEBUG_FUNCTION verify (void);
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);
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);
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);
137 /* Clone all references from symtab NODE to this symtab_node. */
138 void clone_references (symtab_node *node);
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);
146 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
147 ipa_ref *clone_reference (ipa_ref *ref, gimple stmt);
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);
154 /* Remove all references that are associated with statement STMT. */
155 void remove_stmt_references (gimple stmt);
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);
163 /* Remove all references in ref list. */
164 void remove_all_references (void);
166 /* Remove all referring items in ref list. */
167 void remove_all_referring (void);
169 /* Dump references in ref list to FILE. */
170 void dump_references (FILE *file);
172 /* Dump referring in list to FILE. */
173 void dump_referring (FILE *);
175 /* Get number of references for this node. */
176 inline unsigned num_references (void)
178 return ref_list.references ? ref_list.references->length () : 0;
181 /* Iterates I-th reference in the list, REF is also set. */
182 ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);
184 /* Iterates I-th referring item in the list, REF is also set. */
185 ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);
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);
190 /* Return true if symtab node and TARGET represents
191 semantically equivalent symbols. */
192 bool semantically_equivalent_p (symtab_node *target);
194 /* Classify symbol symtab node for partitioning. */
195 enum symbol_partitioning_class get_partitioning_class (void);
197 /* Return comdat group. */
198 tree get_comdat_group ()
200 return x_comdat_group;
203 /* Return comdat group as identifier_node. */
204 tree get_comdat_group_id ()
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;
211 /* Set comdat group. */
212 void set_comdat_group (tree group)
214 gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE
215 || DECL_P (group));
216 x_comdat_group = group;
219 /* Return section as string. */
220 const char * get_section ()
222 if (!x_section)
223 return NULL;
224 return x_section->name;
227 /* Remove node from same comdat group. */
228 void remove_from_same_comdat_group (void);
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);
233 /* Dissolve the same_comdat_group list in which NODE resides. */
234 void dissolve_same_comdat_group_list (void);
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);
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);
245 /* Return next reachable static symbol with initializer after NODE. */
246 inline symtab_node *next_defined_symbol (void);
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);
253 /* C++ FE sometimes change linkage flags after producing same
254 body aliases. */
255 void fixup_same_cpp_alias_visibility (symtab_node *target);
257 /* Call calback 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 *),
261 void *data,
262 bool include_overwrite);
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);
269 /* Return node that alias is aliasing. */
270 inline symtab_node *get_alias_target (void);
272 /* Set section for symbol and its aliases. */
273 void set_section (const char *section);
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);
280 /* Set initialization priority to PRIORITY. */
281 void set_init_priority (priority_type priority);
283 /* Return the initialization priority. */
284 priority_type get_init_priority ();
286 /* Return availability of NODE. */
287 enum availability get_availability (void);
289 /* Make DECL local. */
290 void make_decl_local (void);
292 /* Return true if list contains an alias. */
293 bool has_aliases_p (void);
295 /* Return true when the symbol is real symbol, i.e. it is not inline clone
296 or abstract function kept for debug info purposes only. */
297 bool real_symbol_p (void);
299 /* Determine if symbol declaration is needed. That is, visible to something
300 either outside this translation unit, something magic in the system
301 configury. This function is used just during symbol creation. */
302 bool needed_p (void);
304 /* Return true when there are references to the node. */
305 bool referred_to_p (void);
307 /* Return true if NODE can be discarded by linker from the binary. */
308 inline bool
309 can_be_discarded_p (void)
311 return (DECL_EXTERNAL (decl)
312 || (get_comdat_group ()
313 && resolution != LDPR_PREVAILING_DEF
314 && resolution != LDPR_PREVAILING_DEF_IRONLY
315 && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
318 /* Return true if NODE is local to a particular COMDAT group, and must not
319 be named from outside the COMDAT. This is used for C++ decloned
320 constructors. */
321 inline bool comdat_local_p (void)
323 return (same_comdat_group && !TREE_PUBLIC (decl));
326 /* Return true if ONE and TWO are part of the same COMDAT group. */
327 inline bool in_same_comdat_group_p (symtab_node *target);
329 /* Return true when there is a reference to node and it is not vtable. */
330 bool address_taken_from_non_vtable_p (void);
332 /* Return true if symbol is known to be nonzero. */
333 bool nonzero_address ();
335 /* Return symbol table node associated with DECL, if any,
336 and NULL otherwise. */
337 static inline symtab_node *get (const_tree decl)
339 #ifdef ENABLE_CHECKING
340 /* Check that we are called for sane type of object - functions
341 and static or external variables. */
342 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
343 || (TREE_CODE (decl) == VAR_DECL
344 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
345 || in_lto_p)));
346 /* Check that the mapping is sane - perhaps this check can go away,
347 but at the moment frontends tends to corrupt the mapping by calling
348 memcpy/memset on the tree nodes. */
349 gcc_checking_assert (!decl->decl_with_vis.symtab_node
350 || decl->decl_with_vis.symtab_node->decl == decl);
351 #endif
352 return decl->decl_with_vis.symtab_node;
355 /* Try to find a symtab node for declaration DECL and if it does not
356 exist or if it corresponds to an inline clone, create a new one. */
357 static inline symtab_node * get_create (tree node);
359 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
360 Return NULL if there's no such node. */
361 static symtab_node *get_for_asmname (const_tree asmname);
363 /* Dump symbol table to F. */
364 static void dump_table (FILE *);
366 /* Dump symbol table to stderr. */
367 static inline DEBUG_FUNCTION void debug_symtab (void)
369 dump_table (stderr);
372 /* Verify symbol table for internal consistency. */
373 static DEBUG_FUNCTION void verify_symtab_nodes (void);
375 /* Return true when NODE is known to be used from other (non-LTO)
376 object file. Known only when doing LTO via linker plugin. */
377 static bool used_from_object_file_p_worker (symtab_node *node);
379 /* Type of the symbol. */
380 ENUM_BITFIELD (symtab_type) type : 8;
382 /* The symbols resolution. */
383 ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
385 /*** Flags representing the symbol type. ***/
387 /* True when symbol corresponds to a definition in current unit.
388 set via finalize_function or finalize_decl */
389 unsigned definition : 1;
390 /* True when symbol is an alias.
391 Set by ssemble_alias. */
392 unsigned alias : 1;
393 /* True when alias is a weakref. */
394 unsigned weakref : 1;
395 /* C++ frontend produce same body aliases and extra name aliases for
396 virtual functions and vtables that are obviously equivalent.
397 Those aliases are bit special, especially because C++ frontend
398 visibility code is so ugly it can not get them right at first time
399 and their visibility needs to be copied from their "masters" at
400 the end of parsing. */
401 unsigned cpp_implicit_alias : 1;
402 /* Set once the definition was analyzed. The list of references and
403 other properties are built during analysis. */
404 unsigned analyzed : 1;
405 /* Set for write-only variables. */
406 unsigned writeonly : 1;
407 /* Visibility of symbol was used for further optimization; do not
408 permit further changes. */
409 unsigned refuse_visibility_changes : 1;
411 /*** Visibility and linkage flags. ***/
413 /* Set when function is visible by other units. */
414 unsigned externally_visible : 1;
415 /* Don't reorder to other symbols having this set. */
416 unsigned no_reorder : 1;
417 /* The symbol will be assumed to be used in an invisible way (like
418 by an toplevel asm statement). */
419 unsigned force_output : 1;
420 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
421 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
422 to static and it does not inhibit optimization. */
423 unsigned forced_by_abi : 1;
424 /* True when the name is known to be unique and thus it does not need mangling. */
425 unsigned unique_name : 1;
426 /* Specify whether the section was set by user or by
427 compiler via -ffunction-sections. */
428 unsigned implicit_section : 1;
429 /* True when body and other characteristics have been removed by
430 symtab_remove_unreachable_nodes. */
431 unsigned body_removed : 1;
433 /*** WHOPR Partitioning flags.
434 These flags are used at ltrans stage when only part of the callgraph is
435 available. ***/
437 /* Set when variable is used from other LTRANS partition. */
438 unsigned used_from_other_partition : 1;
439 /* Set when function is available in the other LTRANS partition.
440 During WPA output it is used to mark nodes that are present in
441 multiple partitions. */
442 unsigned in_other_partition : 1;
446 /*** other flags. ***/
448 /* Set when symbol has address taken. */
449 unsigned address_taken : 1;
450 /* Set when init priority is set. */
451 unsigned in_init_priority_hash : 1;
453 /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
454 of offloading, for separate compilation for a different target. */
455 unsigned need_lto_streaming : 1;
457 /* Set when symbol can be streamed into bytecode for offloading. */
458 unsigned offloadable : 1;
461 /* Ordering of all symtab entries. */
462 int order;
464 /* Declaration representing the symbol. */
465 tree decl;
467 /* Linked list of symbol table entries starting with symtab_nodes. */
468 symtab_node *next;
469 symtab_node *previous;
471 /* Linked list of symbols with the same asm name. There may be multiple
472 entries for single symbol name during LTO, because symbols are renamed
473 only after partitioning.
475 Because inline clones are kept in the assembler name has, they also produce
476 duplicate entries.
478 There are also several long standing bugs where frontends and builtin
479 code produce duplicated decls. */
480 symtab_node *next_sharing_asm_name;
481 symtab_node *previous_sharing_asm_name;
483 /* Circular list of nodes in the same comdat group if non-NULL. */
484 symtab_node *same_comdat_group;
486 /* Vectors of referring and referenced entities. */
487 ipa_ref_list ref_list;
489 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
490 depending to what was known to frontend on the creation time.
491 Once alias is resolved, this pointer become NULL. */
492 tree alias_target;
494 /* File stream where this node is being written to. */
495 struct lto_file_decl_data * lto_file_data;
497 PTR GTY ((skip)) aux;
499 /* Comdat group the symbol is in. Can be private if GGC allowed that. */
500 tree x_comdat_group;
502 /* Section name. Again can be private, if allowed. */
503 section_hash_entry *x_section;
505 protected:
506 /* Dump base fields of symtab nodes to F. Not to be used directly. */
507 void dump_base (FILE *);
509 /* Verify common part of symtab node. */
510 bool DEBUG_FUNCTION verify_base (void);
512 /* Remove node from symbol table. This function is not used directly, but via
513 cgraph/varpool node removal routines. */
514 void unregister (void);
516 /* Return the initialization and finalization priority information for
517 DECL. If there is no previous priority information, a freshly
518 allocated structure is returned. */
519 struct symbol_priority_map *priority_info (void);
521 private:
522 /* Worker for set_section. */
523 static bool set_section (symtab_node *n, void *s);
525 /* Worker for symtab_resolve_alias. */
526 static bool set_implicit_section (symtab_node *n, void *);
528 /* Worker searching noninterposable alias. */
529 static bool noninterposable_alias (symtab_node *node, void *data);
532 /* Walk all aliases for NODE. */
533 #define FOR_EACH_ALIAS(node, alias) \
534 for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++)
536 /* This is the information that is put into the cgraph local structure
537 to recover a function. */
538 struct lto_file_decl_data;
540 extern const char * const cgraph_availability_names[];
541 extern const char * const ld_plugin_symbol_resolution_names[];
542 extern const char * const tls_model_names[];
544 /* Information about thunk, used only for same body aliases. */
546 struct GTY(()) cgraph_thunk_info {
547 /* Information about the thunk. */
548 HOST_WIDE_INT fixed_offset;
549 HOST_WIDE_INT virtual_value;
550 tree alias;
551 bool this_adjusting;
552 bool virtual_offset_p;
553 bool add_pointer_bounds_args;
554 /* Set to true when alias node is thunk. */
555 bool thunk_p;
558 /* Information about the function collected locally.
559 Available after function is analyzed. */
561 struct GTY(()) cgraph_local_info {
562 /* Set when function function is visible in current compilation unit only
563 and its address is never taken. */
564 unsigned local : 1;
566 /* False when there is something makes versioning impossible. */
567 unsigned versionable : 1;
569 /* False when function calling convention and signature can not be changed.
570 This is the case when __builtin_apply_args is used. */
571 unsigned can_change_signature : 1;
573 /* True when the function has been originally extern inline, but it is
574 redefined now. */
575 unsigned redefined_extern_inline : 1;
577 /* True if the function may enter serial irrevocable mode. */
578 unsigned tm_may_enter_irr : 1;
581 /* Information about the function that needs to be computed globally
582 once compilation is finished. Available only with -funit-at-a-time. */
584 struct GTY(()) cgraph_global_info {
585 /* For inline clones this points to the function they will be
586 inlined into. */
587 cgraph_node *inlined_to;
590 /* Information about the function that is propagated by the RTL backend.
591 Available only for functions that has been already assembled. */
593 struct GTY(()) cgraph_rtl_info {
594 unsigned int preferred_incoming_stack_boundary;
596 /* Call unsaved hard registers really used by the corresponding
597 function (including ones used by functions called by the
598 function). */
599 HARD_REG_SET function_used_regs;
600 /* Set if function_used_regs is valid. */
601 unsigned function_used_regs_valid: 1;
604 /* Represent which DECL tree (or reference to such tree)
605 will be replaced by another tree while versioning. */
606 struct GTY(()) ipa_replace_map
608 /* The tree that will be replaced. */
609 tree old_tree;
610 /* The new (replacing) tree. */
611 tree new_tree;
612 /* Parameter number to replace, when old_tree is NULL. */
613 int parm_num;
614 /* True when a substitution should be done, false otherwise. */
615 bool replace_p;
616 /* True when we replace a reference to old_tree. */
617 bool ref_p;
620 struct GTY(()) cgraph_clone_info
622 vec<ipa_replace_map *, va_gc> *tree_map;
623 bitmap args_to_skip;
624 bitmap combined_args_to_skip;
627 enum cgraph_simd_clone_arg_type
629 SIMD_CLONE_ARG_TYPE_VECTOR,
630 SIMD_CLONE_ARG_TYPE_UNIFORM,
631 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
632 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
633 SIMD_CLONE_ARG_TYPE_MASK
636 /* Function arguments in the original function of a SIMD clone.
637 Supplementary data for `struct simd_clone'. */
639 struct GTY(()) cgraph_simd_clone_arg {
640 /* Original function argument as it originally existed in
641 DECL_ARGUMENTS. */
642 tree orig_arg;
644 /* orig_arg's function (or for extern functions type from
645 TYPE_ARG_TYPES). */
646 tree orig_type;
648 /* If argument is a vector, this holds the vector version of
649 orig_arg that after adjusting the argument types will live in
650 DECL_ARGUMENTS. Otherwise, this is NULL.
652 This basically holds:
653 vector(simdlen) __typeof__(orig_arg) new_arg. */
654 tree vector_arg;
656 /* vector_arg's type (or for extern functions new vector type. */
657 tree vector_type;
659 /* If argument is a vector, this holds the array where the simd
660 argument is held while executing the simd clone function. This
661 is a local variable in the cloned function. Its content is
662 copied from vector_arg upon entry to the clone.
664 This basically holds:
665 __typeof__(orig_arg) simd_array[simdlen]. */
666 tree simd_array;
668 /* A SIMD clone's argument can be either linear (constant or
669 variable), uniform, or vector. */
670 enum cgraph_simd_clone_arg_type arg_type;
672 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is
673 the constant linear step, if arg_type is
674 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of
675 the uniform argument holding the step, otherwise 0. */
676 HOST_WIDE_INT linear_step;
678 /* Variable alignment if available, otherwise 0. */
679 unsigned int alignment;
682 /* Specific data for a SIMD function clone. */
684 struct GTY(()) cgraph_simd_clone {
685 /* Number of words in the SIMD lane associated with this clone. */
686 unsigned int simdlen;
688 /* Number of annotated function arguments in `args'. This is
689 usually the number of named arguments in FNDECL. */
690 unsigned int nargs;
692 /* Max hardware vector size in bits for integral vectors. */
693 unsigned int vecsize_int;
695 /* Max hardware vector size in bits for floating point vectors. */
696 unsigned int vecsize_float;
698 /* The mangling character for a given vector size. This is is used
699 to determine the ISA mangling bit as specified in the Intel
700 Vector ABI. */
701 unsigned char vecsize_mangle;
703 /* True if this is the masked, in-branch version of the clone,
704 otherwise false. */
705 unsigned int inbranch : 1;
707 /* True if this is a Cilk Plus variant. */
708 unsigned int cilk_elemental : 1;
710 /* Doubly linked list of SIMD clones. */
711 cgraph_node *prev_clone, *next_clone;
713 /* Original cgraph node the SIMD clones were created for. */
714 cgraph_node *origin;
716 /* Annotated function arguments for the original function. */
717 cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
720 /* Function Multiversioning info. */
721 struct GTY((for_user)) cgraph_function_version_info {
722 /* The cgraph_node for which the function version info is stored. */
723 cgraph_node *this_node;
724 /* Chains all the semantically identical function versions. The
725 first function in this chain is the version_info node of the
726 default function. */
727 cgraph_function_version_info *prev;
728 /* If this version node corresponds to a dispatcher for function
729 versions, this points to the version info node of the default
730 function, the first node in the chain. */
731 cgraph_function_version_info *next;
732 /* If this node corresponds to a function version, this points
733 to the dispatcher function decl, which is the function that must
734 be called to execute the right function version at run-time.
736 If this cgraph node is a dispatcher (if dispatcher_function is
737 true, in the cgraph_node struct) for function versions, this
738 points to resolver function, which holds the function body of the
739 dispatcher. The dispatcher decl is an alias to the resolver
740 function decl. */
741 tree dispatcher_resolver;
744 #define DEFCIFCODE(code, type, string) CIF_ ## code,
745 /* Reasons for inlining failures. */
747 enum cgraph_inline_failed_t {
748 #include "cif-code.def"
749 CIF_N_REASONS
752 enum cgraph_inline_failed_type_t
754 CIF_FINAL_NORMAL = 0,
755 CIF_FINAL_ERROR
758 struct cgraph_edge;
760 struct cgraph_edge_hasher : ggc_hasher<cgraph_edge *>
762 typedef gimple compare_type;
764 static hashval_t hash (cgraph_edge *);
765 static bool equal (cgraph_edge *, gimple);
768 /* The cgraph data structure.
769 Each function decl has assigned cgraph_node listing callees and callers. */
771 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
772 public:
773 /* Remove the node from cgraph and all inline clones inlined into it.
774 Skip however removal of FORBIDDEN_NODE and return true if it needs to be
775 removed. This allows to call the function from outer loop walking clone
776 tree. */
777 bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL);
779 /* Record all references from cgraph_node that are taken
780 in statement STMT. */
781 void record_stmt_references (gimple stmt);
783 /* Like cgraph_set_call_stmt but walk the clone tree and update all
784 clones sharing the same function body.
785 When WHOLE_SPECULATIVE_EDGES is true, all three components of
786 speculative edge gets updated. Otherwise we update only direct
787 call. */
788 void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt,
789 bool update_speculative = true);
791 /* Walk the alias chain to return the function cgraph_node is alias of.
792 Walk through thunk, too.
793 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
794 cgraph_node *function_symbol (enum availability *avail = NULL);
796 /* Create node representing clone of N executed COUNT times. Decrease
797 the execution counts from original node too.
798 The new clone will have decl set to DECL that may or may not be the same
799 as decl of N.
801 When UPDATE_ORIGINAL is true, the counts are subtracted from the original
802 function's profile to reflect the fact that part of execution is handled
803 by node.
804 When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about
805 the new clone. Otherwise the caller is responsible for doing so later.
807 If the new node is being inlined into another one, NEW_INLINED_TO should be
808 the outline function the new one is (even indirectly) inlined to.
809 All hooks will see this in node's global.inlined_to, when invoked.
810 Can be NULL if the node is not inlined. */
811 cgraph_node *create_clone (tree decl, gcov_type count, int freq,
812 bool update_original,
813 vec<cgraph_edge *> redirect_callers,
814 bool call_duplication_hook,
815 cgraph_node *new_inlined_to,
816 bitmap args_to_skip);
818 /* Create callgraph node clone with new declaration. The actual body will
819 be copied later at compilation stage. */
820 cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers,
821 vec<ipa_replace_map *, va_gc> *tree_map,
822 bitmap args_to_skip, const char * suffix);
824 /* cgraph node being removed from symbol table; see if its entry can be
825 replaced by other inline clone. */
826 cgraph_node *find_replacement (void);
828 /* Create a new cgraph node which is the new version of
829 callgraph node. REDIRECT_CALLERS holds the callers
830 edges which should be redirected to point to
831 NEW_VERSION. ALL the callees edges of the node
832 are cloned to the new version node. Return the new
833 version node.
835 If non-NULL BLOCK_TO_COPY determine what basic blocks
836 was copied to prevent duplications of calls that are dead
837 in the clone. */
839 cgraph_node *create_version_clone (tree new_decl,
840 vec<cgraph_edge *> redirect_callers,
841 bitmap bbs_to_copy);
843 /* Perform function versioning.
844 Function versioning includes copying of the tree and
845 a callgraph update (creating a new cgraph node and updating
846 its callees and callers).
848 REDIRECT_CALLERS varray includes the edges to be redirected
849 to the new version.
851 TREE_MAP is a mapping of tree nodes we want to replace with
852 new ones (according to results of prior analysis).
854 If non-NULL ARGS_TO_SKIP determine function parameters to remove
855 from new version.
856 If SKIP_RETURN is true, the new version will return void.
857 If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
858 If non_NULL NEW_ENTRY determine new entry BB of the clone.
860 Return the new version's cgraph node. */
861 cgraph_node *create_version_clone_with_body
862 (vec<cgraph_edge *> redirect_callers,
863 vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip,
864 bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block,
865 const char *clone_name);
867 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
868 corresponding to cgraph_node. */
869 cgraph_function_version_info *insert_new_function_version (void);
871 /* Get the cgraph_function_version_info node corresponding to node. */
872 cgraph_function_version_info *function_version (void);
874 /* Discover all functions and variables that are trivially needed, analyze
875 them as well as all functions and variables referred by them */
876 void analyze (void);
878 /* Add thunk alias into callgraph. The alias declaration is ALIAS and it
879 aliases DECL with an adjustments made into the first parameter.
880 See comments in thunk_adjust for detail on the parameters. */
881 cgraph_node * create_thunk (tree alias, tree, bool this_adjusting,
882 HOST_WIDE_INT fixed_offset,
883 HOST_WIDE_INT virtual_value,
884 tree virtual_offset,
885 tree real_alias);
888 /* Return node that alias is aliasing. */
889 inline cgraph_node *get_alias_target (void);
891 /* Given function symbol, walk the alias chain to return the function node
892 is alias of. Do not walk through thunks.
893 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
895 cgraph_node *ultimate_alias_target (availability *availability = NULL);
897 /* Expand thunk NODE to gimple if possible.
898 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
899 no assembler is produced.
900 When OUTPUT_ASM_THUNK is true, also produce assembler for
901 thunks that are not lowered. */
902 bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk);
904 /* Assemble thunks and aliases associated to node. */
905 void assemble_thunks_and_aliases (void);
907 /* Expand function specified by node. */
908 void expand (void);
910 /* As an GCC extension we allow redefinition of the function. The
911 semantics when both copies of bodies differ is not well defined.
912 We replace the old body with new body so in unit at a time mode
913 we always use new body, while in normal mode we may end up with
914 old body inlined into some functions and new body expanded and
915 inlined in others. */
916 void reset (void);
918 /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
919 kind of wrapper method. */
920 void create_wrapper (cgraph_node *target);
922 /* Verify cgraph nodes of the cgraph node. */
923 void DEBUG_FUNCTION verify_node (void);
925 /* Remove function from symbol table. */
926 void remove (void);
928 /* Dump call graph node to file F. */
929 void dump (FILE *f);
931 /* Dump call graph node to stderr. */
932 void DEBUG_FUNCTION debug (void);
934 /* When doing LTO, read cgraph_node's body from disk if it is not already
935 present. */
936 bool get_untransformed_body (void);
938 /* Prepare function body. When doing LTO, read cgraph_node's body from disk
939 if it is not already present. When some IPA transformations are scheduled,
940 apply them. */
941 bool get_body (void);
943 /* Release memory used to represent body of function.
944 Use this only for functions that are released before being translated to
945 target code (i.e. RTL). Functions that are compiled to RTL and beyond
946 are free'd in final.c via free_after_compilation(). */
947 void release_body (bool keep_arguments = false);
949 /* Return the DECL_STRUCT_FUNCTION of the function. */
950 struct function *get_fun (void);
952 /* cgraph_node is no longer nested function; update cgraph accordingly. */
953 void unnest (void);
955 /* Bring cgraph node local. */
956 void make_local (void);
958 /* Likewise indicate that a node is having address taken. */
959 void mark_address_taken (void);
961 /* Set fialization priority to PRIORITY. */
962 void set_fini_priority (priority_type priority);
964 /* Return the finalization priority. */
965 priority_type get_fini_priority (void);
967 /* Create edge from a given function to CALLEE in the cgraph. */
968 cgraph_edge *create_edge (cgraph_node *callee,
969 gimple call_stmt, gcov_type count,
970 int freq);
972 /* Create an indirect edge with a yet-undetermined callee where the call
973 statement destination is a formal parameter of the caller with index
974 PARAM_INDEX. */
975 cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags,
976 gcov_type count, int freq,
977 bool compute_indirect_info = true);
979 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
980 same function body. If clones already have edge for OLD_STMT; only
981 update the edge same way as cgraph_set_call_stmt_including_clones does. */
982 void create_edge_including_clones (cgraph_node *callee,
983 gimple old_stmt, gimple stmt,
984 gcov_type count,
985 int freq,
986 cgraph_inline_failed_t reason);
988 /* Return the callgraph edge representing the GIMPLE_CALL statement
989 CALL_STMT. */
990 cgraph_edge *get_edge (gimple call_stmt);
992 /* Collect all callers of cgraph_node and its aliases that are known to lead
993 to NODE (i.e. are not overwritable). */
994 vec<cgraph_edge *> collect_callers (void);
996 /* Remove all callers from the node. */
997 void remove_callers (void);
999 /* Remove all callees from the node. */
1000 void remove_callees (void);
1002 /* Return function availability. See cgraph.h for description of individual
1003 return values. */
1004 enum availability get_availability (void);
1006 /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
1007 if any to NOTHROW. */
1008 void set_nothrow_flag (bool nothrow);
1010 /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
1011 if any to READONLY. */
1012 void set_const_flag (bool readonly, bool looping);
1014 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
1015 if any to PURE. */
1016 void set_pure_flag (bool pure, bool looping);
1018 /* Call calback on function and aliases associated to the function.
1019 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1020 skipped. */
1022 bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
1023 void *),
1024 void *data, bool include_overwritable);
1026 /* Call calback on cgraph_node, thunks and aliases associated to NODE.
1027 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1028 skipped. */
1029 bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
1030 void *data),
1031 void *data,
1032 bool include_overwritable);
1034 /* Likewise indicate that a node is needed, i.e. reachable via some
1035 external means. */
1036 inline void mark_force_output (void);
1038 /* Return true when function can be marked local. */
1039 bool local_p (void);
1041 /* Return true if cgraph_node can be made local for API change.
1042 Extern inline functions and C++ COMDAT functions can be made local
1043 at the expense of possible code size growth if function is used in multiple
1044 compilation units. */
1045 bool can_be_local_p (void);
1047 /* Return true when cgraph_node can not return or throw and thus
1048 it is safe to ignore its side effects for IPA analysis. */
1049 bool cannot_return_p (void);
1051 /* Return true when function cgraph_node and all its aliases are only called
1052 directly.
1053 i.e. it is not externally visible, address was not taken and
1054 it is not used in any other non-standard way. */
1055 bool only_called_directly_p (void);
1057 /* Return true when function is only called directly or it has alias.
1058 i.e. it is not externally visible, address was not taken and
1059 it is not used in any other non-standard way. */
1060 inline bool only_called_directly_or_aliased_p (void);
1062 /* Return true when function cgraph_node can be expected to be removed
1063 from program when direct calls in this compilation unit are removed.
1065 As a special case COMDAT functions are
1066 cgraph_can_remove_if_no_direct_calls_p while the are not
1067 cgraph_only_called_directly_p (it is possible they are called from other
1068 unit)
1070 This function behaves as cgraph_only_called_directly_p because eliminating
1071 all uses of COMDAT function does not make it necessarily disappear from
1072 the program unless we are compiling whole program or we do LTO. In this
1073 case we know we win since dynamic linking will not really discard the
1074 linkonce section. */
1075 bool will_be_removed_from_program_if_no_direct_calls_p (void);
1077 /* Return true when function can be removed from callgraph
1078 if all direct calls are eliminated. */
1079 bool can_remove_if_no_direct_calls_and_refs_p (void);
1081 /* Return true when function cgraph_node and its aliases can be removed from
1082 callgraph if all direct calls are eliminated. */
1083 bool can_remove_if_no_direct_calls_p (void);
1085 /* Return true when callgraph node is a function with Gimple body defined
1086 in current unit. Functions can also be define externally or they
1087 can be thunks with no Gimple representation.
1089 Note that at WPA stage, the function body may not be present in memory. */
1090 inline bool has_gimple_body_p (void);
1092 /* Return true if function should be optimized for size. */
1093 bool optimize_for_size_p (void);
1095 /* Dump the callgraph to file F. */
1096 static void dump_cgraph (FILE *f);
1098 /* Dump the call graph to stderr. */
1099 static inline
1100 void debug_cgraph (void)
1102 dump_cgraph (stderr);
1105 /* Record that DECL1 and DECL2 are semantically identical function
1106 versions. */
1107 static void record_function_versions (tree decl1, tree decl2);
1109 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
1110 DECL is a duplicate declaration. */
1111 static void delete_function_version (tree decl);
1113 /* Add the function FNDECL to the call graph.
1114 Unlike finalize_function, this function is intended to be used
1115 by middle end and allows insertion of new function at arbitrary point
1116 of compilation. The function can be either in high, low or SSA form
1117 GIMPLE.
1119 The function is assumed to be reachable and have address taken (so no
1120 API breaking optimizations are performed on it).
1122 Main work done by this function is to enqueue the function for later
1123 processing to avoid need the passes to be re-entrant. */
1124 static void add_new_function (tree fndecl, bool lowered);
1126 /* Return callgraph node for given symbol and check it is a function. */
1127 static inline cgraph_node *get (const_tree decl)
1129 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
1130 return dyn_cast <cgraph_node *> (symtab_node::get (decl));
1133 /* DECL has been parsed. Take it, queue it, compile it at the whim of the
1134 logic in effect. If NO_COLLECT is true, then our caller cannot stand to
1135 have the garbage collector run at the moment. We would need to either
1136 create a new GC context, or just not compile right now. */
1137 static void finalize_function (tree, bool);
1139 /* Return cgraph node assigned to DECL. Create new one when needed. */
1140 static cgraph_node * create (tree decl);
1142 /* Try to find a call graph node for declaration DECL and if it does not
1143 exist or if it corresponds to an inline clone, create a new one. */
1144 static cgraph_node * get_create (tree);
1146 /* Return local info for the compiled function. */
1147 static cgraph_local_info *local_info (tree decl);
1149 /* Return global info for the compiled function. */
1150 static cgraph_global_info *global_info (tree);
1152 /* Return local info for the compiled function. */
1153 static cgraph_rtl_info *rtl_info (tree);
1155 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1156 Return NULL if there's no such node. */
1157 static cgraph_node *get_for_asmname (tree asmname);
1159 /* Attempt to mark ALIAS as an alias to DECL. Return alias node if
1160 successful and NULL otherwise.
1161 Same body aliases are output whenever the body of DECL is output,
1162 and cgraph_node::get (ALIAS) transparently
1163 returns cgraph_node::get (DECL). */
1164 static cgraph_node * create_same_body_alias (tree alias, tree decl);
1166 /* Worker for cgraph_can_remove_if_no_direct_calls_p. */
1167 static bool used_from_object_file_p_worker (cgraph_node *node, void *)
1169 return node->used_from_object_file_p ();
1172 /* Return true when cgraph_node can not be local.
1173 Worker for cgraph_local_node_p. */
1174 static bool non_local_p (cgraph_node *node, void *);
1176 /* Verify whole cgraph structure. */
1177 static void DEBUG_FUNCTION verify_cgraph_nodes (void);
1179 /* Worker to bring NODE local. */
1180 static bool make_local (cgraph_node *node, void *);
1182 /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
1183 the function body is associated
1184 with (not necessarily cgraph_node (DECL). */
1185 static cgraph_node *create_alias (tree alias, tree target);
1187 cgraph_edge *callees;
1188 cgraph_edge *callers;
1189 /* List of edges representing indirect calls with a yet undetermined
1190 callee. */
1191 cgraph_edge *indirect_calls;
1192 /* For nested functions points to function the node is nested in. */
1193 cgraph_node *origin;
1194 /* Points to first nested function, if any. */
1195 cgraph_node *nested;
1196 /* Pointer to the next function with same origin, if any. */
1197 cgraph_node *next_nested;
1198 /* Pointer to the next clone. */
1199 cgraph_node *next_sibling_clone;
1200 cgraph_node *prev_sibling_clone;
1201 cgraph_node *clones;
1202 cgraph_node *clone_of;
1203 /* If instrumentation_clone is 1 then instrumented_version points
1204 to the original function used to make instrumented version.
1205 Otherwise points to instrumented version of the function. */
1206 cgraph_node *instrumented_version;
1207 /* If instrumentation_clone is 1 then orig_decl is the original
1208 function declaration. */
1209 tree orig_decl;
1210 /* For functions with many calls sites it holds map from call expression
1211 to the edge to speed up cgraph_edge function. */
1212 hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
1213 /* Declaration node used to be clone of. */
1214 tree former_clone_of;
1216 /* If this is a SIMD clone, this points to the SIMD specific
1217 information for it. */
1218 cgraph_simd_clone *simdclone;
1219 /* If this function has SIMD clones, this points to the first clone. */
1220 cgraph_node *simd_clones;
1222 /* Interprocedural passes scheduled to have their transform functions
1223 applied next time we execute local pass on them. We maintain it
1224 per-function in order to allow IPA passes to introduce new functions. */
1225 vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
1227 cgraph_local_info local;
1228 cgraph_global_info global;
1229 cgraph_rtl_info rtl;
1230 cgraph_clone_info clone;
1231 cgraph_thunk_info thunk;
1233 /* Expected number of executions: calculated in profile.c. */
1234 gcov_type count;
1235 /* How to scale counts at materialization time; used to merge
1236 LTO units with different number of profile runs. */
1237 int count_materialization_scale;
1238 /* Unique id of the node. */
1239 int uid;
1240 /* ID assigned by the profiling. */
1241 unsigned int profile_id;
1242 /* Time profiler: first run of function. */
1243 int tp_first_run;
1245 /* Set when decl is an abstract function pointed to by the
1246 ABSTRACT_DECL_ORIGIN of a reachable function. */
1247 unsigned used_as_abstract_origin : 1;
1248 /* Set once the function is lowered (i.e. its CFG is built). */
1249 unsigned lowered : 1;
1250 /* Set once the function has been instantiated and its callee
1251 lists created. */
1252 unsigned process : 1;
1253 /* How commonly executed the node is. Initialized during branch
1254 probabilities pass. */
1255 ENUM_BITFIELD (node_frequency) frequency : 2;
1256 /* True when function can only be called at startup (from static ctor). */
1257 unsigned only_called_at_startup : 1;
1258 /* True when function can only be called at startup (from static dtor). */
1259 unsigned only_called_at_exit : 1;
1260 /* True when function is the transactional clone of a function which
1261 is called only from inside transactions. */
1262 /* ?? We should be able to remove this. We have enough bits in
1263 cgraph to calculate it. */
1264 unsigned tm_clone : 1;
1265 /* True if this decl is a dispatcher for function versions. */
1266 unsigned dispatcher_function : 1;
1267 /* True if this decl calls a COMDAT-local function. This is set up in
1268 compute_inline_parameters and inline_call. */
1269 unsigned calls_comdat_local : 1;
1270 /* True if node has been created by merge operation in IPA-ICF. */
1271 unsigned icf_merged: 1;
1272 /* True when function is clone created for Pointer Bounds Checker
1273 instrumentation. */
1274 unsigned instrumentation_clone : 1;
1275 /* True if call to node can't result in a call to free, munmap or
1276 other operation that could make previously non-trapping memory
1277 accesses trapping. */
1278 unsigned nonfreeing_fn : 1;
1281 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
1282 can appear in multiple sets. */
1283 struct cgraph_node_set_def
1285 hash_map<cgraph_node *, size_t> *map;
1286 vec<cgraph_node *> nodes;
1289 typedef cgraph_node_set_def *cgraph_node_set;
1290 typedef struct varpool_node_set_def *varpool_node_set;
1292 class varpool_node;
1294 /* A varpool node set is a collection of varpool nodes. A varpool node
1295 can appear in multiple sets. */
1296 struct varpool_node_set_def
1298 hash_map<varpool_node *, size_t> * map;
1299 vec<varpool_node *> nodes;
1302 /* Iterator structure for cgraph node sets. */
1303 struct cgraph_node_set_iterator
1305 cgraph_node_set set;
1306 unsigned index;
1309 /* Iterator structure for varpool node sets. */
1310 struct varpool_node_set_iterator
1312 varpool_node_set set;
1313 unsigned index;
1316 /* Context of polymorphic call. It represent information about the type of
1317 instance that may reach the call. This is used by ipa-devirt walkers of the
1318 type inheritance graph. */
1320 class GTY(()) ipa_polymorphic_call_context {
1321 public:
1322 /* The called object appears in an object of type OUTER_TYPE
1323 at offset OFFSET. When information is not 100% reliable, we
1324 use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
1325 HOST_WIDE_INT offset;
1326 HOST_WIDE_INT speculative_offset;
1327 tree outer_type;
1328 tree speculative_outer_type;
1329 /* True if outer object may be in construction or destruction. */
1330 unsigned maybe_in_construction : 1;
1331 /* True if outer object may be of derived type. */
1332 unsigned maybe_derived_type : 1;
1333 /* True if speculative outer object may be of derived type. We always
1334 speculate that construction does not happen. */
1335 unsigned speculative_maybe_derived_type : 1;
1336 /* True if the context is invalid and all calls should be redirected
1337 to BUILTIN_UNREACHABLE. */
1338 unsigned invalid : 1;
1339 /* True if the outer type is dynamic. */
1340 unsigned dynamic : 1;
1342 /* Build empty "I know nothing" context. */
1343 ipa_polymorphic_call_context ();
1344 /* Build polymorphic call context for indirect call E. */
1345 ipa_polymorphic_call_context (cgraph_edge *e);
1346 /* Build polymorphic call context for IP invariant CST.
1347 If specified, OTR_TYPE specify the type of polymorphic call
1348 that takes CST+OFFSET as a prameter. */
1349 ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
1350 HOST_WIDE_INT offset = 0);
1351 /* Build context for pointer REF contained in FNDECL at statement STMT.
1352 if INSTANCE is non-NULL, return pointer to the object described by
1353 the context. */
1354 ipa_polymorphic_call_context (tree fndecl, tree ref, gimple stmt,
1355 tree *instance = NULL);
1357 /* Look for vtable stores or constructor calls to work out dynamic type
1358 of memory location. */
1359 bool get_dynamic_type (tree, tree, tree, gimple);
1361 /* Make context non-speculative. */
1362 void clear_speculation ();
1364 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
1365 NULL, the context is set to dummy "I know nothing" setting. */
1366 void clear_outer_type (tree otr_type = NULL);
1368 /* Walk container types and modify context to point to actual class
1369 containing OTR_TYPE (if non-NULL) as base class.
1370 Return true if resulting context is valid.
1372 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
1373 valid only via alocation of new polymorphic type inside by means
1374 of placement new.
1376 When CONSIDER_BASES is false, only look for actual fields, not base types
1377 of TYPE. */
1378 bool restrict_to_inner_class (tree otr_type,
1379 bool consider_placement_new = true,
1380 bool consider_bases = true);
1382 /* Adjust all offsets in contexts by given number of bits. */
1383 void offset_by (HOST_WIDE_INT);
1384 /* Use when we can not track dynamic type change. This speculatively assume
1385 type change is not happening. */
1386 void possible_dynamic_type_change (bool, tree otr_type = NULL);
1387 /* Assume that both THIS and a given context is valid and strenghten THIS
1388 if possible. Return true if any strenghtening was made.
1389 If actual type the context is being used in is known, OTR_TYPE should be
1390 set accordingly. This improves quality of combined result. */
1391 bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1392 bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL);
1394 /* Return TRUE if context is fully useless. */
1395 bool useless_p () const;
1396 /* Return TRUE if this context conveys the same information as X. */
1397 bool equal_to (const ipa_polymorphic_call_context &x) const;
1399 /* Dump human readable context to F. If NEWLINE is true, it will be
1400 terminated by a newline. */
1401 void dump (FILE *f, bool newline = true) const;
1402 void DEBUG_FUNCTION debug () const;
1404 /* LTO streaming. */
1405 void stream_out (struct output_block *) const;
1406 void stream_in (struct lto_input_block *, struct data_in *data_in);
1408 private:
1409 bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1410 bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree);
1411 void set_by_decl (tree, HOST_WIDE_INT);
1412 bool set_by_invariant (tree, tree, HOST_WIDE_INT);
1413 bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const;
1414 void make_speculative (tree otr_type = NULL);
1417 /* Structure containing additional information about an indirect call. */
1419 struct GTY(()) cgraph_indirect_call_info
1421 /* When agg_content is set, an offset where the call pointer is located
1422 within the aggregate. */
1423 HOST_WIDE_INT offset;
1424 /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */
1425 ipa_polymorphic_call_context context;
1426 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
1427 HOST_WIDE_INT otr_token;
1428 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
1429 tree otr_type;
1430 /* Index of the parameter that is called. */
1431 int param_index;
1432 /* ECF flags determined from the caller. */
1433 int ecf_flags;
1434 /* Profile_id of common target obtrained from profile. */
1435 int common_target_id;
1436 /* Probability that call will land in function with COMMON_TARGET_ID. */
1437 int common_target_probability;
1439 /* Set when the call is a virtual call with the parameter being the
1440 associated object pointer rather than a simple direct call. */
1441 unsigned polymorphic : 1;
1442 /* Set when the call is a call of a pointer loaded from contents of an
1443 aggregate at offset. */
1444 unsigned agg_contents : 1;
1445 /* Set when this is a call through a member pointer. */
1446 unsigned member_ptr : 1;
1447 /* When the previous bit is set, this one determines whether the destination
1448 is loaded from a parameter passed by reference. */
1449 unsigned by_ref : 1;
1450 /* For polymorphic calls this specify whether the virtual table pointer
1451 may have changed in between function entry and the call. */
1452 unsigned vptr_changed : 1;
1455 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
1456 for_user)) cgraph_edge {
1457 friend class cgraph_node;
1459 /* Remove the edge in the cgraph. */
1460 void remove (void);
1462 /* Change field call_stmt of edge to NEW_STMT.
1463 If UPDATE_SPECULATIVE and E is any component of speculative
1464 edge, then update all components. */
1465 void set_call_stmt (gimple new_stmt, bool update_speculative = true);
1467 /* Redirect callee of the edge to N. The function does not update underlying
1468 call expression. */
1469 void redirect_callee (cgraph_node *n);
1471 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1472 CALLEE. DELTA is an integer constant that is to be added to the this
1473 pointer (first parameter) to compensate for skipping
1474 a thunk adjustment. */
1475 cgraph_edge *make_direct (cgraph_node *callee);
1477 /* Turn edge into speculative call calling N2. Update
1478 the profile so the direct call is taken COUNT times
1479 with FREQUENCY. */
1480 cgraph_edge *make_speculative (cgraph_node *n2, gcov_type direct_count,
1481 int direct_frequency);
1483 /* Given speculative call edge, return all three components. */
1484 void speculative_call_info (cgraph_edge *&direct, cgraph_edge *&indirect,
1485 ipa_ref *&reference);
1487 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1488 Remove the speculative call sequence and return edge representing the call.
1489 It is up to caller to redirect the call as appropriate. */
1490 cgraph_edge *resolve_speculation (tree callee_decl = NULL);
1492 /* If necessary, change the function declaration in the call statement
1493 associated with the edge so that it corresponds to the edge callee. */
1494 gimple redirect_call_stmt_to_callee (void);
1496 /* Create clone of edge in the node N represented
1497 by CALL_EXPR the callgraph. */
1498 cgraph_edge * clone (cgraph_node *n, gimple call_stmt, unsigned stmt_uid,
1499 gcov_type count_scale, int freq_scale, bool update_original);
1501 /* Return true when call of edge can not lead to return from caller
1502 and thus it is safe to ignore its side effects for IPA analysis
1503 when computing side effects of the caller. */
1504 bool cannot_lead_to_return_p (void);
1506 /* Return true when the edge represents a direct recursion. */
1507 bool recursive_p (void);
1509 /* Return true if the call can be hot. */
1510 bool maybe_hot_p (void);
1512 /* Rebuild cgraph edges for current function node. This needs to be run after
1513 passes that don't update the cgraph. */
1514 static unsigned int rebuild_edges (void);
1516 /* Rebuild cgraph references for current function node. This needs to be run
1517 after passes that don't update the cgraph. */
1518 static void rebuild_references (void);
1520 /* Expected number of executions: calculated in profile.c. */
1521 gcov_type count;
1522 cgraph_node *caller;
1523 cgraph_node *callee;
1524 cgraph_edge *prev_caller;
1525 cgraph_edge *next_caller;
1526 cgraph_edge *prev_callee;
1527 cgraph_edge *next_callee;
1528 gimple call_stmt;
1529 /* Additional information about an indirect call. Not cleared when an edge
1530 becomes direct. */
1531 cgraph_indirect_call_info *indirect_info;
1532 PTR GTY ((skip (""))) aux;
1533 /* When equal to CIF_OK, inline this call. Otherwise, points to the
1534 explanation why function was not inlined. */
1535 enum cgraph_inline_failed_t inline_failed;
1536 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
1537 when the function is serialized in. */
1538 unsigned int lto_stmt_uid;
1539 /* Expected frequency of executions within the function.
1540 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
1541 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
1542 int frequency;
1543 /* Unique id of the edge. */
1544 int uid;
1545 /* Whether this edge was made direct by indirect inlining. */
1546 unsigned int indirect_inlining_edge : 1;
1547 /* Whether this edge describes an indirect call with an undetermined
1548 callee. */
1549 unsigned int indirect_unknown_callee : 1;
1550 /* Whether this edge is still a dangling */
1551 /* True if the corresponding CALL stmt cannot be inlined. */
1552 unsigned int call_stmt_cannot_inline_p : 1;
1553 /* Can this call throw externally? */
1554 unsigned int can_throw_external : 1;
1555 /* Edges with SPECULATIVE flag represents indirect calls that was
1556 speculatively turned into direct (i.e. by profile feedback).
1557 The final code sequence will have form:
1559 if (call_target == expected_fn)
1560 expected_fn ();
1561 else
1562 call_target ();
1564 Every speculative call is represented by three components attached
1565 to a same call statement:
1566 1) a direct call (to expected_fn)
1567 2) an indirect call (to call_target)
1568 3) a IPA_REF_ADDR refrence to expected_fn.
1570 Optimizers may later redirect direct call to clone, so 1) and 3)
1571 do not need to necesarily agree with destination. */
1572 unsigned int speculative : 1;
1573 /* Set to true when caller is a constructor or destructor of polymorphic
1574 type. */
1575 unsigned in_polymorphic_cdtor : 1;
1577 private:
1578 /* Remove the edge from the list of the callers of the callee. */
1579 void remove_caller (void);
1581 /* Remove the edge from the list of the callees of the caller. */
1582 void remove_callee (void);
1585 #define CGRAPH_FREQ_BASE 1000
1586 #define CGRAPH_FREQ_MAX 100000
1588 /* The varpool data structure.
1589 Each static variable decl has assigned varpool_node. */
1591 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
1592 public:
1593 /* Dump given varpool node to F. */
1594 void dump (FILE *f);
1596 /* Dump given varpool node to stderr. */
1597 void DEBUG_FUNCTION debug (void);
1599 /* Remove variable from symbol table. */
1600 void remove (void);
1602 /* Remove node initializer when it is no longer needed. */
1603 void remove_initializer (void);
1605 void analyze (void);
1607 /* Return variable availability. */
1608 availability get_availability (void);
1610 /* When doing LTO, read variable's constructor from disk if
1611 it is not already present. */
1612 tree get_constructor (void);
1614 /* Return true if variable has constructor that can be used for folding. */
1615 bool ctor_useable_for_folding_p (void);
1617 /* For given variable pool node, walk the alias chain to return the function
1618 the variable is alias of. Do not walk through thunks.
1619 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
1620 inline varpool_node *ultimate_alias_target
1621 (availability *availability = NULL);
1623 /* Return node that alias is aliasing. */
1624 inline varpool_node *get_alias_target (void);
1626 /* Output one variable, if necessary. Return whether we output it. */
1627 bool assemble_decl (void);
1629 /* For variables in named sections make sure get_variable_section
1630 is called before we switch to those sections. Then section
1631 conflicts between read-only and read-only requiring relocations
1632 sections can be resolved. */
1633 void finalize_named_section_flags (void);
1635 /* Call calback on varpool symbol and aliases associated to varpool symbol.
1636 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1637 skipped. */
1638 bool call_for_node_and_aliases (bool (*callback) (varpool_node *, void *),
1639 void *data,
1640 bool include_overwritable);
1642 /* Return true when variable should be considered externally visible. */
1643 bool externally_visible_p (void);
1645 /* Return true when all references to variable must be visible
1646 in ipa_ref_list.
1647 i.e. if the variable is not externally visible or not used in some magic
1648 way (asm statement or such).
1649 The magic uses are all summarized in force_output flag. */
1650 inline bool all_refs_explicit_p ();
1652 /* Return true when variable can be removed from variable pool
1653 if all direct calls are eliminated. */
1654 inline bool can_remove_if_no_refs_p (void);
1656 /* Add the variable DECL to the varpool.
1657 Unlike finalize_decl function is intended to be used
1658 by middle end and allows insertion of new variable at arbitrary point
1659 of compilation. */
1660 static void add (tree decl);
1662 /* Return varpool node for given symbol and check it is a function. */
1663 static inline varpool_node *get (const_tree decl);
1665 /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
1666 the middle end to output the variable to asm file, if needed or externally
1667 visible. */
1668 static void finalize_decl (tree decl);
1670 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1671 Extra name aliases are output whenever DECL is output. */
1672 static varpool_node * create_extra_name_alias (tree alias, tree decl);
1674 /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
1675 Extra name aliases are output whenever DECL is output. */
1676 static varpool_node * create_alias (tree, tree);
1678 /* Dump the variable pool to F. */
1679 static void dump_varpool (FILE *f);
1681 /* Dump the variable pool to stderr. */
1682 static void DEBUG_FUNCTION debug_varpool (void);
1684 /* Allocate new callgraph node and insert it into basic data structures. */
1685 static varpool_node *create_empty (void);
1687 /* Return varpool node assigned to DECL. Create new one when needed. */
1688 static varpool_node *get_create (tree decl);
1690 /* Given an assembler name, lookup node. */
1691 static varpool_node *get_for_asmname (tree asmname);
1693 /* Set when variable is scheduled to be assembled. */
1694 unsigned output : 1;
1696 /* Set when variable has statically initialized pointer
1697 or is a static bounds variable and needs initalization. */
1698 unsigned need_bounds_init : 1;
1700 /* Set if the variable is dynamically initialized, except for
1701 function local statics. */
1702 unsigned dynamically_initialized : 1;
1704 ENUM_BITFIELD(tls_model) tls_model : 3;
1706 /* Set if the variable is known to be used by single function only.
1707 This is computed by ipa_signle_use pass and used by late optimizations
1708 in places where optimization would be valid for local static variable
1709 if we did not do any inter-procedural code movement. */
1710 unsigned used_by_single_function : 1;
1712 private:
1713 /* Assemble thunks and aliases associated to varpool node. */
1714 void assemble_aliases (void);
1717 /* Every top level asm statement is put into a asm_node. */
1719 struct GTY(()) asm_node {
1722 /* Next asm node. */
1723 asm_node *next;
1724 /* String for this asm node. */
1725 tree asm_str;
1726 /* Ordering of all cgraph nodes. */
1727 int order;
1730 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
1732 template <>
1733 template <>
1734 inline bool
1735 is_a_helper <cgraph_node *>::test (symtab_node *p)
1737 return p && p->type == SYMTAB_FUNCTION;
1740 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
1742 template <>
1743 template <>
1744 inline bool
1745 is_a_helper <varpool_node *>::test (symtab_node *p)
1747 return p && p->type == SYMTAB_VARIABLE;
1750 /* Macros to access the next item in the list of free cgraph nodes and
1751 edges. */
1752 #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next)
1753 #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
1754 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
1756 typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
1757 typedef void (*cgraph_node_hook)(cgraph_node *, void *);
1758 typedef void (*varpool_node_hook)(varpool_node *, void *);
1759 typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
1760 typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);
1762 struct cgraph_edge_hook_list;
1763 struct cgraph_node_hook_list;
1764 struct varpool_node_hook_list;
1765 struct cgraph_2edge_hook_list;
1766 struct cgraph_2node_hook_list;
1768 /* Map from a symbol to initialization/finalization priorities. */
1769 struct GTY(()) symbol_priority_map {
1770 priority_type init;
1771 priority_type fini;
1774 enum symtab_state
1776 /* Frontend is parsing and finalizing functions. */
1777 PARSING,
1778 /* Callgraph is being constructed. It is safe to add new functions. */
1779 CONSTRUCTION,
1780 /* Callgraph is being at LTO time. */
1781 LTO_STREAMING,
1782 /* Callgraph is built and IPA passes are being run. */
1783 IPA,
1784 /* Callgraph is built and all functions are transformed to SSA form. */
1785 IPA_SSA,
1786 /* Functions are now ordered and being passed to RTL expanders. */
1787 EXPANSION,
1788 /* All cgraph expansion is done. */
1789 FINISHED
1792 struct asmname_hasher
1794 typedef symtab_node *value_type;
1795 typedef const_tree compare_type;
1796 typedef int store_values_directly;
1798 static hashval_t hash (symtab_node *n);
1799 static bool equal (symtab_node *n, const_tree t);
1800 static void ggc_mx (symtab_node *n);
1801 static void pch_nx (symtab_node *&);
1802 static void pch_nx (symtab_node *&, gt_pointer_operator, void *);
1803 static void remove (symtab_node *) {}
1806 class GTY((tag ("SYMTAB"))) symbol_table
1808 public:
1809 friend class symtab_node;
1810 friend class cgraph_node;
1811 friend class cgraph_edge;
1813 /* Initialize callgraph dump file. */
1814 void initialize (void);
1816 /* Register a top-level asm statement ASM_STR. */
1817 inline asm_node *finalize_toplevel_asm (tree asm_str);
1819 /* Analyze the whole compilation unit once it is parsed completely. */
1820 void finalize_compilation_unit (void);
1822 /* C++ frontend produce same body aliases all over the place, even before PCH
1823 gets streamed out. It relies on us linking the aliases with their function
1824 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
1825 first produce aliases without links, but once C++ FE is sure he won't sream
1826 PCH we build the links via this function. */
1827 void process_same_body_aliases (void);
1829 /* Perform simple optimizations based on callgraph. */
1830 void compile (void);
1832 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
1833 functions into callgraph in a way so they look like ordinary reachable
1834 functions inserted into callgraph already at construction time. */
1835 void process_new_functions (void);
1837 /* Once all functions from compilation unit are in memory, produce all clones
1838 and update all calls. We might also do this on demand if we don't want to
1839 bring all functions to memory prior compilation, but current WHOPR
1840 implementation does that and it is is bit easier to keep everything right
1841 in this order. */
1842 void materialize_all_clones (void);
1844 /* Register a symbol NODE. */
1845 inline void register_symbol (symtab_node *node);
1847 inline void
1848 clear_asm_symbols (void)
1850 asmnodes = NULL;
1851 asm_last_node = NULL;
1854 /* Perform reachability analysis and reclaim all unreachable nodes. */
1855 bool remove_unreachable_nodes (bool before_inlining_p, FILE *file);
1857 /* Optimization of function bodies might've rendered some variables as
1858 unnecessary so we want to avoid these from being compiled. Re-do
1859 reachability starting from variables that are either externally visible
1860 or was referred from the asm output routines. */
1861 void remove_unreferenced_decls (void);
1863 /* Unregister a symbol NODE. */
1864 inline void unregister (symtab_node *node);
1866 /* Allocate new callgraph node and insert it into basic data structures. */
1867 cgraph_node *create_empty (void);
1869 /* Release a callgraph NODE with UID and put in to the list
1870 of free nodes. */
1871 void release_symbol (cgraph_node *node, int uid);
1873 /* Output all variables enqueued to be assembled. */
1874 bool output_variables (void);
1876 /* Weakrefs may be associated to external decls and thus not output
1877 at expansion time. Emit all necessary aliases. */
1878 void output_weakrefs (void);
1880 /* Return first static symbol with definition. */
1881 inline symtab_node *first_symbol (void);
1883 /* Return first assembler symbol. */
1884 inline asm_node *
1885 first_asm_symbol (void)
1887 return asmnodes;
1890 /* Return first static symbol with definition. */
1891 inline symtab_node *first_defined_symbol (void);
1893 /* Return first variable. */
1894 inline varpool_node *first_variable (void);
1896 /* Return next variable after NODE. */
1897 inline varpool_node *next_variable (varpool_node *node);
1899 /* Return first static variable with initializer. */
1900 inline varpool_node *first_static_initializer (void);
1902 /* Return next static variable with initializer after NODE. */
1903 inline varpool_node *next_static_initializer (varpool_node *node);
1905 /* Return first static variable with definition. */
1906 inline varpool_node *first_defined_variable (void);
1908 /* Return next static variable with definition after NODE. */
1909 inline varpool_node *next_defined_variable (varpool_node *node);
1911 /* Return first function with body defined. */
1912 inline cgraph_node *first_defined_function (void);
1914 /* Return next function with body defined after NODE. */
1915 inline cgraph_node *next_defined_function (cgraph_node *node);
1917 /* Return first function. */
1918 inline cgraph_node *first_function (void);
1920 /* Return next function. */
1921 inline cgraph_node *next_function (cgraph_node *node);
1923 /* Return first function with body defined. */
1924 cgraph_node *first_function_with_gimple_body (void);
1926 /* Return next reachable static variable with initializer after NODE. */
1927 inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);
1929 /* Register HOOK to be called with DATA on each removed edge. */
1930 cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
1931 void *data);
1933 /* Remove ENTRY from the list of hooks called on removing edges. */
1934 void remove_edge_removal_hook (cgraph_edge_hook_list *entry);
1936 /* Register HOOK to be called with DATA on each removed node. */
1937 cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
1938 void *data);
1940 /* Remove ENTRY from the list of hooks called on removing nodes. */
1941 void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);
1943 /* Register HOOK to be called with DATA on each removed node. */
1944 varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
1945 void *data);
1947 /* Remove ENTRY from the list of hooks called on removing nodes. */
1948 void remove_varpool_removal_hook (varpool_node_hook_list *entry);
1950 /* Register HOOK to be called with DATA on each inserted node. */
1951 cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
1952 void *data);
1954 /* Remove ENTRY from the list of hooks called on inserted nodes. */
1955 void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);
1957 /* Register HOOK to be called with DATA on each inserted node. */
1958 varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
1959 void *data);
1961 /* Remove ENTRY from the list of hooks called on inserted nodes. */
1962 void remove_varpool_insertion_hook (varpool_node_hook_list *entry);
1964 /* Register HOOK to be called with DATA on each duplicated edge. */
1965 cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
1966 void *data);
1967 /* Remove ENTRY from the list of hooks called on duplicating edges. */
1968 void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);
1970 /* Register HOOK to be called with DATA on each duplicated node. */
1971 cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
1972 void *data);
1974 /* Remove ENTRY from the list of hooks called on duplicating nodes. */
1975 void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);
1977 /* Call all edge removal hooks. */
1978 void call_edge_removal_hooks (cgraph_edge *e);
1980 /* Call all node insertion hooks. */
1981 void call_cgraph_insertion_hooks (cgraph_node *node);
1983 /* Call all node removal hooks. */
1984 void call_cgraph_removal_hooks (cgraph_node *node);
1986 /* Call all node duplication hooks. */
1987 void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);
1989 /* Call all edge duplication hooks. */
1990 void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);
1992 /* Call all node removal hooks. */
1993 void call_varpool_removal_hooks (varpool_node *node);
1995 /* Call all node insertion hooks. */
1996 void call_varpool_insertion_hooks (varpool_node *node);
1998 /* Arrange node to be first in its entry of assembler_name_hash. */
1999 void symtab_prevail_in_asm_name_hash (symtab_node *node);
2001 /* Initalize asm name hash unless. */
2002 void symtab_initialize_asm_name_hash (void);
2004 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
2005 void change_decl_assembler_name (tree decl, tree name);
2007 int cgraph_count;
2008 int cgraph_max_uid;
2010 int edges_count;
2011 int edges_max_uid;
2013 symtab_node* GTY(()) nodes;
2014 asm_node* GTY(()) asmnodes;
2015 asm_node* GTY(()) asm_last_node;
2016 cgraph_node* GTY(()) free_nodes;
2018 /* Head of a linked list of unused (freed) call graph edges.
2019 Do not GTY((delete)) this list so UIDs gets reliably recycled. */
2020 cgraph_edge * GTY(()) free_edges;
2022 /* The order index of the next symtab node to be created. This is
2023 used so that we can sort the cgraph nodes in order by when we saw
2024 them, to support -fno-toplevel-reorder. */
2025 int order;
2027 /* Set when whole unit has been analyzed so we can access global info. */
2028 bool global_info_ready;
2029 /* What state callgraph is in right now. */
2030 enum symtab_state state;
2031 /* Set when the cgraph is fully build and the basic flags are computed. */
2032 bool function_flags_ready;
2034 bool cpp_implicit_aliases_done;
2036 /* Hash table used to hold sectoons. */
2037 hash_table<section_name_hasher> *GTY(()) section_hash;
2039 /* Hash table used to convert assembler names into nodes. */
2040 hash_table<asmname_hasher> *assembler_name_hash;
2042 /* Hash table used to hold init priorities. */
2043 hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;
2045 FILE* GTY ((skip)) dump_file;
2047 private:
2048 /* Allocate new callgraph node. */
2049 inline cgraph_node * allocate_cgraph_symbol (void);
2051 /* Allocate a cgraph_edge structure and fill it with data according to the
2052 parameters of which only CALLEE can be NULL (when creating an indirect call
2053 edge). */
2054 cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
2055 gimple call_stmt, gcov_type count, int freq,
2056 bool indir_unknown_callee);
2058 /* Put the edge onto the free list. */
2059 void free_edge (cgraph_edge *e);
2061 /* Insert NODE to assembler name hash. */
2062 void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);
2064 /* Remove NODE from assembler name hash. */
2065 void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);
2067 /* Hash asmnames ignoring the user specified marks. */
2068 static hashval_t decl_assembler_name_hash (const_tree asmname);
2070 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
2071 static bool decl_assembler_name_equal (tree decl, const_tree asmname);
2073 friend struct asmname_hasher;
2075 /* List of hooks triggered when an edge is removed. */
2076 cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
2077 /* List of hooks triggem_red when a cgraph node is removed. */
2078 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
2079 /* List of hooks triggered when an edge is duplicated. */
2080 cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
2081 /* List of hooks triggered when a node is duplicated. */
2082 cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
2083 /* List of hooks triggered when an function is inserted. */
2084 cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
2085 /* List of hooks triggered when an variable is inserted. */
2086 varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
2087 /* List of hooks triggered when a node is removed. */
2088 varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
2091 extern GTY(()) symbol_table *symtab;
2093 extern vec<cgraph_node *> cgraph_new_nodes;
2095 inline hashval_t
2096 asmname_hasher::hash (symtab_node *n)
2098 return symbol_table::decl_assembler_name_hash
2099 (DECL_ASSEMBLER_NAME (n->decl));
2102 inline bool
2103 asmname_hasher::equal (symtab_node *n, const_tree t)
2105 return symbol_table::decl_assembler_name_equal (n->decl, t);
2108 extern void gt_ggc_mx (symtab_node *&);
2110 inline void
2111 asmname_hasher::ggc_mx (symtab_node *n)
2113 gt_ggc_mx (n);
2116 extern void gt_pch_nx (symtab_node *&);
2118 inline void
2119 asmname_hasher::pch_nx (symtab_node *&n)
2121 gt_pch_nx (n);
2124 inline void
2125 asmname_hasher::pch_nx (symtab_node *&n, gt_pointer_operator op, void *cookie)
2127 op (&n, cookie);
2130 /* In cgraph.c */
2131 void cgraph_c_finalize (void);
2132 void release_function_body (tree);
2133 cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
2135 void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
2136 bool cgraph_function_possibly_inlined_p (tree);
2138 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
2139 cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
2141 bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution);
2142 extern bool gimple_check_call_matching_types (gimple, tree, bool);
2144 /* In cgraphunit.c */
2145 void cgraphunit_c_finalize (void);
2147 /* Initialize datastructures so DECL is a function in lowered gimple form.
2148 IN_SSA is true if the gimple is in SSA. */
2149 basic_block init_lowered_empty_function (tree, bool);
2151 /* In cgraphclones.c */
2153 tree clone_function_name (tree decl, const char *);
2155 void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
2156 bool, bitmap, bool, bitmap, basic_block);
2158 /* In cgraphbuild.c */
2159 int compute_call_stmt_bb_frequency (tree, basic_block bb);
2160 void record_references_in_initializer (tree, bool);
2162 /* In ipa.c */
2163 void cgraph_build_static_cdtor (char which, tree body, int priority);
2164 void ipa_discover_readonly_nonaddressable_vars (void);
2166 /* In varpool.c */
2167 tree ctor_for_folding (tree);
2169 /* Return true when the symbol is real symbol, i.e. it is not inline clone
2170 or abstract function kept for debug info purposes only. */
2171 inline bool
2172 symtab_node::real_symbol_p (void)
2174 cgraph_node *cnode;
2176 if (DECL_ABSTRACT_P (decl))
2177 return false;
2178 if (!is_a <cgraph_node *> (this))
2179 return true;
2180 cnode = dyn_cast <cgraph_node *> (this);
2181 if (cnode->global.inlined_to)
2182 return false;
2183 return true;
2186 /* Return true if DECL should have entry in symbol table if used.
2187 Those are functions and static & external veriables*/
2189 static inline bool
2190 decl_in_symtab_p (const_tree decl)
2192 return (TREE_CODE (decl) == FUNCTION_DECL
2193 || (TREE_CODE (decl) == VAR_DECL
2194 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))));
2197 inline bool
2198 symtab_node::in_same_comdat_group_p (symtab_node *target)
2200 symtab_node *source = this;
2202 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2204 if (cn->global.inlined_to)
2205 source = cn->global.inlined_to;
2207 if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
2209 if (cn->global.inlined_to)
2210 target = cn->global.inlined_to;
2213 return source->get_comdat_group () == target->get_comdat_group ();
2216 /* Return node that alias is aliasing. */
2218 inline symtab_node *
2219 symtab_node::get_alias_target (void)
2221 ipa_ref *ref = NULL;
2222 iterate_reference (0, ref);
2223 if (ref->use == IPA_REF_CHKP)
2224 iterate_reference (1, ref);
2225 gcc_checking_assert (ref->use == IPA_REF_ALIAS);
2226 return ref->referred;
2229 /* Return next reachable static symbol with initializer after the node. */
2230 inline symtab_node *
2231 symtab_node::next_defined_symbol (void)
2233 symtab_node *node1 = next;
2235 for (; node1; node1 = node1->next)
2236 if (node1->definition)
2237 return node1;
2239 return NULL;
2242 /* Return varpool node for given symbol and check it is a function. */
2244 inline varpool_node *
2245 varpool_node::get (const_tree decl)
2247 gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
2248 return dyn_cast<varpool_node *> (symtab_node::get (decl));
2251 /* Register a symbol NODE. */
2253 inline void
2254 symbol_table::register_symbol (symtab_node *node)
2256 node->next = nodes;
2257 node->previous = NULL;
2259 if (nodes)
2260 nodes->previous = node;
2261 nodes = node;
2263 node->order = order++;
2266 /* Register a top-level asm statement ASM_STR. */
2268 asm_node *
2269 symbol_table::finalize_toplevel_asm (tree asm_str)
2271 asm_node *node;
2273 node = ggc_cleared_alloc<asm_node> ();
2274 node->asm_str = asm_str;
2275 node->order = order++;
2276 node->next = NULL;
2278 if (asmnodes == NULL)
2279 asmnodes = node;
2280 else
2281 asm_last_node->next = node;
2283 asm_last_node = node;
2284 return node;
2287 /* Unregister a symbol NODE. */
2288 inline void
2289 symbol_table::unregister (symtab_node *node)
2291 if (node->previous)
2292 node->previous->next = node->next;
2293 else
2294 nodes = node->next;
2296 if (node->next)
2297 node->next->previous = node->previous;
2299 node->next = NULL;
2300 node->previous = NULL;
2303 /* Release a callgraph NODE with UID and put in to the list of free nodes. */
2305 inline void
2306 symbol_table::release_symbol (cgraph_node *node, int uid)
2308 cgraph_count--;
2310 /* Clear out the node to NULL all pointers and add the node to the free
2311 list. */
2312 memset (node, 0, sizeof (*node));
2313 node->type = SYMTAB_FUNCTION;
2314 node->uid = uid;
2315 SET_NEXT_FREE_NODE (node, free_nodes);
2316 free_nodes = node;
2319 /* Allocate new callgraph node. */
2321 inline cgraph_node *
2322 symbol_table::allocate_cgraph_symbol (void)
2324 cgraph_node *node;
2326 if (free_nodes)
2328 node = free_nodes;
2329 free_nodes = NEXT_FREE_NODE (node);
2331 else
2333 node = ggc_cleared_alloc<cgraph_node> ();
2334 node->uid = cgraph_max_uid++;
2337 return node;
2341 /* Return first static symbol with definition. */
2342 inline symtab_node *
2343 symbol_table::first_symbol (void)
2345 return nodes;
2348 /* Walk all symbols. */
2349 #define FOR_EACH_SYMBOL(node) \
2350 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)
2352 /* Return first static symbol with definition. */
2353 inline symtab_node *
2354 symbol_table::first_defined_symbol (void)
2356 symtab_node *node;
2358 for (node = nodes; node; node = node->next)
2359 if (node->definition)
2360 return node;
2362 return NULL;
2365 /* Walk all symbols with definitions in current unit. */
2366 #define FOR_EACH_DEFINED_SYMBOL(node) \
2367 for ((node) = symtab->first_defined_symbol (); (node); \
2368 (node) = node->next_defined_symbol ())
2370 /* Return first variable. */
2371 inline varpool_node *
2372 symbol_table::first_variable (void)
2374 symtab_node *node;
2375 for (node = nodes; node; node = node->next)
2376 if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
2377 return vnode;
2378 return NULL;
2381 /* Return next variable after NODE. */
2382 inline varpool_node *
2383 symbol_table::next_variable (varpool_node *node)
2385 symtab_node *node1 = node->next;
2386 for (; node1; node1 = node1->next)
2387 if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
2388 return vnode1;
2389 return NULL;
2391 /* Walk all variables. */
2392 #define FOR_EACH_VARIABLE(node) \
2393 for ((node) = symtab->first_variable (); \
2394 (node); \
2395 (node) = symtab->next_variable ((node)))
2397 /* Return first static variable with initializer. */
2398 inline varpool_node *
2399 symbol_table::first_static_initializer (void)
2401 symtab_node *node;
2402 for (node = nodes; node; node = node->next)
2404 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2405 if (vnode && DECL_INITIAL (node->decl))
2406 return vnode;
2408 return NULL;
2411 /* Return next static variable with initializer after NODE. */
2412 inline varpool_node *
2413 symbol_table::next_static_initializer (varpool_node *node)
2415 symtab_node *node1 = node->next;
2416 for (; node1; node1 = node1->next)
2418 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2419 if (vnode1 && DECL_INITIAL (node1->decl))
2420 return vnode1;
2422 return NULL;
2425 /* Walk all static variables with initializer set. */
2426 #define FOR_EACH_STATIC_INITIALIZER(node) \
2427 for ((node) = symtab->first_static_initializer (); (node); \
2428 (node) = symtab->next_static_initializer (node))
2430 /* Return first static variable with definition. */
2431 inline varpool_node *
2432 symbol_table::first_defined_variable (void)
2434 symtab_node *node;
2435 for (node = nodes; node; node = node->next)
2437 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2438 if (vnode && vnode->definition)
2439 return vnode;
2441 return NULL;
2444 /* Return next static variable with definition after NODE. */
2445 inline varpool_node *
2446 symbol_table::next_defined_variable (varpool_node *node)
2448 symtab_node *node1 = node->next;
2449 for (; node1; node1 = node1->next)
2451 varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
2452 if (vnode1 && vnode1->definition)
2453 return vnode1;
2455 return NULL;
2457 /* Walk all variables with definitions in current unit. */
2458 #define FOR_EACH_DEFINED_VARIABLE(node) \
2459 for ((node) = symtab->first_defined_variable (); (node); \
2460 (node) = symtab->next_defined_variable (node))
2462 /* Return first function with body defined. */
2463 inline cgraph_node *
2464 symbol_table::first_defined_function (void)
2466 symtab_node *node;
2467 for (node = nodes; node; node = node->next)
2469 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2470 if (cn && cn->definition)
2471 return cn;
2473 return NULL;
2476 /* Return next function with body defined after NODE. */
2477 inline cgraph_node *
2478 symbol_table::next_defined_function (cgraph_node *node)
2480 symtab_node *node1 = node->next;
2481 for (; node1; node1 = node1->next)
2483 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2484 if (cn1 && cn1->definition)
2485 return cn1;
2487 return NULL;
2490 /* Walk all functions with body defined. */
2491 #define FOR_EACH_DEFINED_FUNCTION(node) \
2492 for ((node) = symtab->first_defined_function (); (node); \
2493 (node) = symtab->next_defined_function ((node)))
2495 /* Return first function. */
2496 inline cgraph_node *
2497 symbol_table::first_function (void)
2499 symtab_node *node;
2500 for (node = nodes; node; node = node->next)
2501 if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
2502 return cn;
2503 return NULL;
2506 /* Return next function. */
2507 inline cgraph_node *
2508 symbol_table::next_function (cgraph_node *node)
2510 symtab_node *node1 = node->next;
2511 for (; node1; node1 = node1->next)
2512 if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
2513 return cn1;
2514 return NULL;
2517 /* Return first function with body defined. */
2518 inline cgraph_node *
2519 symbol_table::first_function_with_gimple_body (void)
2521 symtab_node *node;
2522 for (node = nodes; node; node = node->next)
2524 cgraph_node *cn = dyn_cast <cgraph_node *> (node);
2525 if (cn && cn->has_gimple_body_p ())
2526 return cn;
2528 return NULL;
2531 /* Return next reachable static variable with initializer after NODE. */
2532 inline cgraph_node *
2533 symbol_table::next_function_with_gimple_body (cgraph_node *node)
2535 symtab_node *node1 = node->next;
2536 for (; node1; node1 = node1->next)
2538 cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
2539 if (cn1 && cn1->has_gimple_body_p ())
2540 return cn1;
2542 return NULL;
2545 /* Walk all functions. */
2546 #define FOR_EACH_FUNCTION(node) \
2547 for ((node) = symtab->first_function (); (node); \
2548 (node) = symtab->next_function ((node)))
2550 /* Return true when callgraph node is a function with Gimple body defined
2551 in current unit. Functions can also be define externally or they
2552 can be thunks with no Gimple representation.
2554 Note that at WPA stage, the function body may not be present in memory. */
2556 inline bool
2557 cgraph_node::has_gimple_body_p (void)
2559 return definition && !thunk.thunk_p && !alias;
2562 /* Walk all functions with body defined. */
2563 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
2564 for ((node) = symtab->first_function_with_gimple_body (); (node); \
2565 (node) = symtab->next_function_with_gimple_body (node))
2567 /* Create a new static variable of type TYPE. */
2568 tree add_new_static_var (tree type);
2570 /* Uniquize all constants that appear in memory.
2571 Each constant in memory thus far output is recorded
2572 in `const_desc_table'. */
2574 struct GTY((for_user)) constant_descriptor_tree {
2575 /* A MEM for the constant. */
2576 rtx rtl;
2578 /* The value of the constant. */
2579 tree value;
2581 /* Hash of value. Computing the hash from value each time
2582 hashfn is called can't work properly, as that means recursive
2583 use of the hash table during hash table expansion. */
2584 hashval_t hash;
2587 /* Return true when function is only called directly or it has alias.
2588 i.e. it is not externally visible, address was not taken and
2589 it is not used in any other non-standard way. */
2591 inline bool
2592 cgraph_node::only_called_directly_or_aliased_p (void)
2594 gcc_assert (!global.inlined_to);
2595 return (!force_output && !address_taken
2596 && !used_from_other_partition
2597 && !DECL_VIRTUAL_P (decl)
2598 && !DECL_STATIC_CONSTRUCTOR (decl)
2599 && !DECL_STATIC_DESTRUCTOR (decl)
2600 && !externally_visible);
2603 /* Return true when variable can be removed from variable pool
2604 if all direct calls are eliminated. */
2606 inline bool
2607 varpool_node::can_remove_if_no_refs_p (void)
2609 if (DECL_EXTERNAL (decl))
2610 return true;
2611 return (!force_output && !used_from_other_partition
2612 && ((DECL_COMDAT (decl)
2613 && !forced_by_abi
2614 && !used_from_object_file_p ())
2615 || !externally_visible
2616 || DECL_HAS_VALUE_EXPR_P (decl)));
2619 /* Return true when all references to variable must be visible in ipa_ref_list.
2620 i.e. if the variable is not externally visible or not used in some magic
2621 way (asm statement or such).
2622 The magic uses are all summarized in force_output flag. */
2624 inline bool
2625 varpool_node::all_refs_explicit_p ()
2627 return (definition
2628 && !externally_visible
2629 && !used_from_other_partition
2630 && !force_output);
2633 struct tree_descriptor_hasher : ggc_hasher<constant_descriptor_tree *>
2635 static hashval_t hash (constant_descriptor_tree *);
2636 static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
2639 /* Constant pool accessor function. */
2640 hash_table<tree_descriptor_hasher> *constant_pool_htab (void);
2642 /* Return node that alias is aliasing. */
2644 inline cgraph_node *
2645 cgraph_node::get_alias_target (void)
2647 return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
2650 /* Return node that alias is aliasing. */
2652 inline varpool_node *
2653 varpool_node::get_alias_target (void)
2655 return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
2658 /* Given function symbol, walk the alias chain to return the function node
2659 is alias of. Do not walk through thunks.
2660 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2662 inline cgraph_node *
2663 cgraph_node::ultimate_alias_target (enum availability *availability)
2665 cgraph_node *n = dyn_cast <cgraph_node *> (symtab_node::ultimate_alias_target
2666 (availability));
2667 if (!n && availability)
2668 *availability = AVAIL_NOT_AVAILABLE;
2669 return n;
2672 /* For given variable pool node, walk the alias chain to return the function
2673 the variable is alias of. Do not walk through thunks.
2674 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
2676 inline varpool_node *
2677 varpool_node::ultimate_alias_target (availability *availability)
2679 varpool_node *n = dyn_cast <varpool_node *>
2680 (symtab_node::ultimate_alias_target (availability));
2682 if (!n && availability)
2683 *availability = AVAIL_NOT_AVAILABLE;
2684 return n;
2687 /* Return true when the edge represents a direct recursion. */
2688 inline bool
2689 cgraph_edge::recursive_p (void)
2691 cgraph_node *c = callee->ultimate_alias_target ();
2692 if (caller->global.inlined_to)
2693 return caller->global.inlined_to->decl == c->decl;
2694 else
2695 return caller->decl == c->decl;
2698 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
2699 static inline bool
2700 decl_is_tm_clone (const_tree fndecl)
2702 cgraph_node *n = cgraph_node::get (fndecl);
2703 if (n)
2704 return n->tm_clone;
2705 return false;
2708 /* Likewise indicate that a node is needed, i.e. reachable via some
2709 external means. */
2711 inline void
2712 cgraph_node::mark_force_output (void)
2714 force_output = 1;
2715 gcc_checking_assert (!global.inlined_to);
2718 /* Return true if function should be optimized for size. */
2720 inline bool
2721 cgraph_node::optimize_for_size_p (void)
2723 if (optimize_size)
2724 return true;
2725 if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2726 return true;
2727 else
2728 return false;
2731 inline symtab_node * symtab_node::get_create (tree node)
2733 if (TREE_CODE (node) == VAR_DECL)
2734 return varpool_node::get_create (node);
2735 else
2736 return cgraph_node::get_create (node);
2739 /* Build polymorphic call context for indirect call E. */
2741 inline
2742 ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
2744 gcc_checking_assert (e->indirect_info->polymorphic);
2745 *this = e->indirect_info->context;
2748 /* Build empty "I know nothing" context. */
2750 inline
2751 ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
2753 clear_speculation ();
2754 clear_outer_type ();
2755 invalid = false;
2758 /* Make context non-speculative. */
2760 inline void
2761 ipa_polymorphic_call_context::clear_speculation ()
2763 speculative_outer_type = NULL;
2764 speculative_offset = 0;
2765 speculative_maybe_derived_type = false;
2768 /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is
2769 NULL, the context is set to dummy "I know nothing" setting. */
2771 inline void
2772 ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
2774 outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL;
2775 offset = 0;
2776 maybe_derived_type = true;
2777 maybe_in_construction = true;
2778 dynamic = true;
2781 /* Adjust all offsets in contexts by OFF bits. */
2783 inline void
2784 ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off)
2786 if (outer_type)
2787 offset += off;
2788 if (speculative_outer_type)
2789 speculative_offset += off;
2792 /* Return TRUE if context is fully useless. */
2794 inline bool
2795 ipa_polymorphic_call_context::useless_p () const
2797 return (!outer_type && !speculative_outer_type);
2800 /* Return true if NODE is local. Instrumentation clones are counted as local
2801 only when original function is local. */
2803 static inline bool
2804 cgraph_local_p (cgraph_node *node)
2806 if (!node->instrumentation_clone || !node->instrumented_version)
2807 return node->local.local;
2809 return node->local.local && node->instrumented_version->local.local;
2812 #endif /* GCC_CGRAPH_H */