2014-01-24 Ed Smith-Rowland <3dw4rd@verizon.net>
[official-gcc.git] / gcc / cgraph.h
blobe9e93cd3481f1837f65df8188617708da0717729
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
24 #include "is-a.h"
25 #include "plugin-api.h"
26 #include "vec.h"
27 #include "basic-block.h"
28 #include "function.h"
29 #include "ipa-ref.h"
31 /* Symbol table consists of functions and variables.
32 TODO: add labels and CONST_DECLs. */
33 enum symtab_type
35 SYMTAB_SYMBOL,
36 SYMTAB_FUNCTION,
37 SYMTAB_VARIABLE
40 /* Base of all entries in the symbol table.
41 The symtab_node is inherited by cgraph and varpol nodes. */
42 class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
43 chain_next ("%h.next"), chain_prev ("%h.previous")))
44 symtab_node
46 public:
47 /* Return name. */
48 const char *name () const;
50 /* Return asm name. */
51 const char * asm_name () const;
53 /* Type of the symbol. */
54 ENUM_BITFIELD (symtab_type) type : 8;
56 /* The symbols resolution. */
57 ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8;
59 /*** Flags representing the symbol type. ***/
61 /* True when symbol corresponds to a definition in current unit.
62 set via cgraph_finalize_function or varpool_finalize_decl */
63 unsigned definition : 1;
64 /* True when symbol is an alias.
65 Set by assemble_alias. */
66 unsigned alias : 1;
67 /* True when alias is a weakref. */
68 unsigned weakref : 1;
69 /* C++ frontend produce same body aliases and extra name aliases for
70 virtual functions and vtables that are obviously equivalent.
71 Those aliases are bit special, especially because C++ frontend
72 visibility code is so ugly it can not get them right at first time
73 and their visibility needs to be copied from their "masters" at
74 the end of parsing. */
75 unsigned cpp_implicit_alias : 1;
76 /* Set once the definition was analyzed. The list of references and
77 other properties are built during analysis. */
78 unsigned analyzed : 1;
81 /*** Visibility and linkage flags. ***/
83 /* Set when function is visible by other units. */
84 unsigned externally_visible : 1;
85 /* The symbol will be assumed to be used in an invisible way (like
86 by an toplevel asm statement). */
87 unsigned force_output : 1;
88 /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
89 exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
90 to static and it does not inhibit optimization. */
91 unsigned forced_by_abi : 1;
92 /* True when the name is known to be unique and thus it does not need mangling. */
93 unsigned unique_name : 1;
96 /*** WHOPR Partitioning flags.
97 These flags are used at ltrans stage when only part of the callgraph is
98 available. ***/
100 /* Set when variable is used from other LTRANS partition. */
101 unsigned used_from_other_partition : 1;
102 /* Set when function is available in the other LTRANS partition.
103 During WPA output it is used to mark nodes that are present in
104 multiple partitions. */
105 unsigned in_other_partition : 1;
109 /*** other flags. ***/
111 /* Set when symbol has address taken. */
112 unsigned address_taken : 1;
115 /* Ordering of all symtab entries. */
116 int order;
118 /* Declaration representing the symbol. */
119 tree decl;
121 /* Linked list of symbol table entries starting with symtab_nodes. */
122 symtab_node *next;
123 symtab_node *previous;
125 /* Linked list of symbols with the same asm name. There may be multiple
126 entries for single symbol name during LTO, because symbols are renamed
127 only after partitioning.
129 Because inline clones are kept in the assembler name has, they also produce
130 duplicate entries.
132 There are also several long standing bugs where frontends and builtin
133 code produce duplicated decls. */
134 symtab_node *next_sharing_asm_name;
135 symtab_node *previous_sharing_asm_name;
137 /* Circular list of nodes in the same comdat group if non-NULL. */
138 symtab_node *same_comdat_group;
140 /* Vectors of referring and referenced entities. */
141 struct ipa_ref_list ref_list;
143 /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
144 depending to what was known to frontend on the creation time.
145 Once alias is resolved, this pointer become NULL. */
146 tree alias_target;
148 /* File stream where this node is being written to. */
149 struct lto_file_decl_data * lto_file_data;
151 PTR GTY ((skip)) aux;
154 enum availability
156 /* Not yet set by cgraph_function_body_availability. */
157 AVAIL_UNSET,
158 /* Function body/variable initializer is unknown. */
159 AVAIL_NOT_AVAILABLE,
160 /* Function body/variable initializer is known but might be replaced
161 by a different one from other compilation unit and thus needs to
162 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have
163 arbitrary side effects on escaping variables and functions, while
164 like AVAILABLE it might access static variables. */
165 AVAIL_OVERWRITABLE,
166 /* Function body/variable initializer is known and will be used in final
167 program. */
168 AVAIL_AVAILABLE,
169 /* Function body/variable initializer is known and all it's uses are explicitly
170 visible within current unit (ie it's address is never taken and it is not
171 exported to other units).
172 Currently used only for functions. */
173 AVAIL_LOCAL
176 /* This is the information that is put into the cgraph local structure
177 to recover a function. */
178 struct lto_file_decl_data;
180 extern const char * const cgraph_availability_names[];
181 extern const char * const ld_plugin_symbol_resolution_names[];
183 /* Information about thunk, used only for same body aliases. */
185 struct GTY(()) cgraph_thunk_info {
186 /* Information about the thunk. */
187 HOST_WIDE_INT fixed_offset;
188 HOST_WIDE_INT virtual_value;
189 tree alias;
190 bool this_adjusting;
191 bool virtual_offset_p;
192 /* Set to true when alias node is thunk. */
193 bool thunk_p;
196 /* Information about the function collected locally.
197 Available after function is analyzed. */
199 struct GTY(()) cgraph_local_info {
200 /* Set when function function is visible in current compilation unit only
201 and its address is never taken. */
202 unsigned local : 1;
204 /* False when there is something makes versioning impossible. */
205 unsigned versionable : 1;
207 /* False when function calling convention and signature can not be changed.
208 This is the case when __builtin_apply_args is used. */
209 unsigned can_change_signature : 1;
211 /* True when the function has been originally extern inline, but it is
212 redefined now. */
213 unsigned redefined_extern_inline : 1;
215 /* True if the function may enter serial irrevocable mode. */
216 unsigned tm_may_enter_irr : 1;
219 /* Information about the function that needs to be computed globally
220 once compilation is finished. Available only with -funit-at-a-time. */
222 struct GTY(()) cgraph_global_info {
223 /* For inline clones this points to the function they will be
224 inlined into. */
225 struct cgraph_node *inlined_to;
228 /* Information about the function that is propagated by the RTL backend.
229 Available only for functions that has been already assembled. */
231 struct GTY(()) cgraph_rtl_info {
232 unsigned int preferred_incoming_stack_boundary;
235 /* Represent which DECL tree (or reference to such tree)
236 will be replaced by another tree while versioning. */
237 struct GTY(()) ipa_replace_map
239 /* The tree that will be replaced. */
240 tree old_tree;
241 /* The new (replacing) tree. */
242 tree new_tree;
243 /* Parameter number to replace, when old_tree is NULL. */
244 int parm_num;
245 /* True when a substitution should be done, false otherwise. */
246 bool replace_p;
247 /* True when we replace a reference to old_tree. */
248 bool ref_p;
250 typedef struct ipa_replace_map *ipa_replace_map_p;
252 struct GTY(()) cgraph_clone_info
254 vec<ipa_replace_map_p, va_gc> *tree_map;
255 bitmap args_to_skip;
256 bitmap combined_args_to_skip;
259 enum cgraph_simd_clone_arg_type
261 SIMD_CLONE_ARG_TYPE_VECTOR,
262 SIMD_CLONE_ARG_TYPE_UNIFORM,
263 SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
264 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
265 SIMD_CLONE_ARG_TYPE_MASK
268 /* Function arguments in the original function of a SIMD clone.
269 Supplementary data for `struct simd_clone'. */
271 struct GTY(()) cgraph_simd_clone_arg {
272 /* Original function argument as it originally existed in
273 DECL_ARGUMENTS. */
274 tree orig_arg;
276 /* orig_arg's function (or for extern functions type from
277 TYPE_ARG_TYPES). */
278 tree orig_type;
280 /* If argument is a vector, this holds the vector version of
281 orig_arg that after adjusting the argument types will live in
282 DECL_ARGUMENTS. Otherwise, this is NULL.
284 This basically holds:
285 vector(simdlen) __typeof__(orig_arg) new_arg. */
286 tree vector_arg;
288 /* vector_arg's type (or for extern functions new vector type. */
289 tree vector_type;
291 /* If argument is a vector, this holds the array where the simd
292 argument is held while executing the simd clone function. This
293 is a local variable in the cloned function. Its content is
294 copied from vector_arg upon entry to the clone.
296 This basically holds:
297 __typeof__(orig_arg) simd_array[simdlen]. */
298 tree simd_array;
300 /* A SIMD clone's argument can be either linear (constant or
301 variable), uniform, or vector. */
302 enum cgraph_simd_clone_arg_type arg_type;
304 /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is
305 the constant linear step, if arg_type is
306 SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of
307 the uniform argument holding the step, otherwise 0. */
308 HOST_WIDE_INT linear_step;
310 /* Variable alignment if available, otherwise 0. */
311 unsigned int alignment;
314 /* Specific data for a SIMD function clone. */
316 struct GTY(()) cgraph_simd_clone {
317 /* Number of words in the SIMD lane associated with this clone. */
318 unsigned int simdlen;
320 /* Number of annotated function arguments in `args'. This is
321 usually the number of named arguments in FNDECL. */
322 unsigned int nargs;
324 /* Max hardware vector size in bits for integral vectors. */
325 unsigned int vecsize_int;
327 /* Max hardware vector size in bits for floating point vectors. */
328 unsigned int vecsize_float;
330 /* The mangling character for a given vector size. This is is used
331 to determine the ISA mangling bit as specified in the Intel
332 Vector ABI. */
333 unsigned char vecsize_mangle;
335 /* True if this is the masked, in-branch version of the clone,
336 otherwise false. */
337 unsigned int inbranch : 1;
339 /* True if this is a Cilk Plus variant. */
340 unsigned int cilk_elemental : 1;
342 /* Doubly linked list of SIMD clones. */
343 struct cgraph_node *prev_clone, *next_clone;
345 /* Original cgraph node the SIMD clones were created for. */
346 struct cgraph_node *origin;
348 /* Annotated function arguments for the original function. */
349 struct cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
353 /* The cgraph data structure.
354 Each function decl has assigned cgraph_node listing callees and callers. */
356 struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node {
357 public:
358 struct cgraph_edge *callees;
359 struct cgraph_edge *callers;
360 /* List of edges representing indirect calls with a yet undetermined
361 callee. */
362 struct cgraph_edge *indirect_calls;
363 /* For nested functions points to function the node is nested in. */
364 struct cgraph_node *origin;
365 /* Points to first nested function, if any. */
366 struct cgraph_node *nested;
367 /* Pointer to the next function with same origin, if any. */
368 struct cgraph_node *next_nested;
369 /* Pointer to the next clone. */
370 struct cgraph_node *next_sibling_clone;
371 struct cgraph_node *prev_sibling_clone;
372 struct cgraph_node *clones;
373 struct cgraph_node *clone_of;
374 /* For functions with many calls sites it holds map from call expression
375 to the edge to speed up cgraph_edge function. */
376 htab_t GTY((param_is (struct cgraph_edge))) call_site_hash;
377 /* Declaration node used to be clone of. */
378 tree former_clone_of;
380 /* If this is a SIMD clone, this points to the SIMD specific
381 information for it. */
382 struct cgraph_simd_clone *simdclone;
383 /* If this function has SIMD clones, this points to the first clone. */
384 struct cgraph_node *simd_clones;
386 /* Interprocedural passes scheduled to have their transform functions
387 applied next time we execute local pass on them. We maintain it
388 per-function in order to allow IPA passes to introduce new functions. */
389 vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
391 struct cgraph_local_info local;
392 struct cgraph_global_info global;
393 struct cgraph_rtl_info rtl;
394 struct cgraph_clone_info clone;
395 struct cgraph_thunk_info thunk;
397 /* Expected number of executions: calculated in profile.c. */
398 gcov_type count;
399 /* How to scale counts at materialization time; used to merge
400 LTO units with different number of profile runs. */
401 int count_materialization_scale;
402 /* Unique id of the node. */
403 int uid;
404 /* ID assigned by the profiling. */
405 unsigned int profile_id;
406 /* Time profiler: first run of function. */
407 int tp_first_run;
409 /* Set when decl is an abstract function pointed to by the
410 ABSTRACT_DECL_ORIGIN of a reachable function. */
411 unsigned used_as_abstract_origin : 1;
412 /* Set once the function is lowered (i.e. its CFG is built). */
413 unsigned lowered : 1;
414 /* Set once the function has been instantiated and its callee
415 lists created. */
416 unsigned process : 1;
417 /* How commonly executed the node is. Initialized during branch
418 probabilities pass. */
419 ENUM_BITFIELD (node_frequency) frequency : 2;
420 /* True when function can only be called at startup (from static ctor). */
421 unsigned only_called_at_startup : 1;
422 /* True when function can only be called at startup (from static dtor). */
423 unsigned only_called_at_exit : 1;
424 /* True when function is the transactional clone of a function which
425 is called only from inside transactions. */
426 /* ?? We should be able to remove this. We have enough bits in
427 cgraph to calculate it. */
428 unsigned tm_clone : 1;
429 /* True if this decl is a dispatcher for function versions. */
430 unsigned dispatcher_function : 1;
431 /* True if this decl calls a COMDAT-local function. This is set up in
432 compute_inline_parameters and inline_call. */
433 unsigned calls_comdat_local : 1;
437 typedef struct cgraph_node *cgraph_node_ptr;
440 /* Function Multiversioning info. */
441 struct GTY(()) cgraph_function_version_info {
442 /* The cgraph_node for which the function version info is stored. */
443 struct cgraph_node *this_node;
444 /* Chains all the semantically identical function versions. The
445 first function in this chain is the version_info node of the
446 default function. */
447 struct cgraph_function_version_info *prev;
448 /* If this version node corresponds to a dispatcher for function
449 versions, this points to the version info node of the default
450 function, the first node in the chain. */
451 struct cgraph_function_version_info *next;
452 /* If this node corresponds to a function version, this points
453 to the dispatcher function decl, which is the function that must
454 be called to execute the right function version at run-time.
456 If this cgraph node is a dispatcher (if dispatcher_function is
457 true, in the cgraph_node struct) for function versions, this
458 points to resolver function, which holds the function body of the
459 dispatcher. The dispatcher decl is an alias to the resolver
460 function decl. */
461 tree dispatcher_resolver;
464 /* Get the cgraph_function_version_info node corresponding to node. */
465 struct cgraph_function_version_info *
466 get_cgraph_node_version (struct cgraph_node *node);
468 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
469 corresponding to cgraph_node NODE. */
470 struct cgraph_function_version_info *
471 insert_new_cgraph_node_version (struct cgraph_node *node);
473 /* Record that DECL1 and DECL2 are semantically identical function
474 versions. */
475 void record_function_versions (tree decl1, tree decl2);
477 /* Remove the cgraph_function_version_info and cgraph_node for DECL. This
478 DECL is a duplicate declaration. */
479 void delete_function_version (tree decl);
481 /* A cgraph node set is a collection of cgraph nodes. A cgraph node
482 can appear in multiple sets. */
483 struct cgraph_node_set_def
485 struct pointer_map_t *map;
486 vec<cgraph_node_ptr> nodes;
489 class varpool_node;
490 typedef varpool_node *varpool_node_ptr;
493 /* A varpool node set is a collection of varpool nodes. A varpool node
494 can appear in multiple sets. */
495 struct varpool_node_set_def
497 struct pointer_map_t * map;
498 vec<varpool_node_ptr> nodes;
501 typedef struct cgraph_node_set_def *cgraph_node_set;
504 typedef struct varpool_node_set_def *varpool_node_set;
507 /* Iterator structure for cgraph node sets. */
508 struct cgraph_node_set_iterator
510 cgraph_node_set set;
511 unsigned index;
514 /* Iterator structure for varpool node sets. */
515 struct varpool_node_set_iterator
517 varpool_node_set set;
518 unsigned index;
521 #define DEFCIFCODE(code, type, string) CIF_ ## code,
522 /* Reasons for inlining failures. */
523 enum cgraph_inline_failed_t {
524 #include "cif-code.def"
525 CIF_N_REASONS
528 enum cgraph_inline_failed_type_t
530 CIF_FINAL_NORMAL = 0,
531 CIF_FINAL_ERROR
534 /* Structure containing additional information about an indirect call. */
536 struct GTY(()) cgraph_indirect_call_info
538 /* When polymorphic is set, this field contains offset where the object which
539 was actually used in the polymorphic resides within a larger structure.
540 If agg_contents is set, the field contains the offset within the aggregate
541 from which the address to call was loaded. */
542 HOST_WIDE_INT offset;
543 /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
544 HOST_WIDE_INT otr_token;
545 /* Type of the object from OBJ_TYPE_REF_OBJECT. */
546 tree otr_type, outer_type;
547 /* Index of the parameter that is called. */
548 int param_index;
549 /* ECF flags determined from the caller. */
550 int ecf_flags;
551 /* Profile_id of common target obtrained from profile. */
552 int common_target_id;
553 /* Probability that call will land in function with COMMON_TARGET_ID. */
554 int common_target_probability;
556 /* Set when the call is a virtual call with the parameter being the
557 associated object pointer rather than a simple direct call. */
558 unsigned polymorphic : 1;
559 /* Set when the call is a call of a pointer loaded from contents of an
560 aggregate at offset. */
561 unsigned agg_contents : 1;
562 /* Set when this is a call through a member pointer. */
563 unsigned member_ptr : 1;
564 /* When the previous bit is set, this one determines whether the destination
565 is loaded from a parameter passed by reference. */
566 unsigned by_ref : 1;
567 unsigned int maybe_in_construction : 1;
568 unsigned int maybe_derived_type : 1;
571 struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
572 /* Expected number of executions: calculated in profile.c. */
573 gcov_type count;
574 struct cgraph_node *caller;
575 struct cgraph_node *callee;
576 struct cgraph_edge *prev_caller;
577 struct cgraph_edge *next_caller;
578 struct cgraph_edge *prev_callee;
579 struct cgraph_edge *next_callee;
580 gimple call_stmt;
581 /* Additional information about an indirect call. Not cleared when an edge
582 becomes direct. */
583 struct cgraph_indirect_call_info *indirect_info;
584 PTR GTY ((skip (""))) aux;
585 /* When equal to CIF_OK, inline this call. Otherwise, points to the
586 explanation why function was not inlined. */
587 enum cgraph_inline_failed_t inline_failed;
588 /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt
589 when the function is serialized in. */
590 unsigned int lto_stmt_uid;
591 /* Expected frequency of executions within the function.
592 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
593 per function call. The range is 0 to CGRAPH_FREQ_MAX. */
594 int frequency;
595 /* Unique id of the edge. */
596 int uid;
597 /* Whether this edge was made direct by indirect inlining. */
598 unsigned int indirect_inlining_edge : 1;
599 /* Whether this edge describes an indirect call with an undetermined
600 callee. */
601 unsigned int indirect_unknown_callee : 1;
602 /* Whether this edge is still a dangling */
603 /* True if the corresponding CALL stmt cannot be inlined. */
604 unsigned int call_stmt_cannot_inline_p : 1;
605 /* Can this call throw externally? */
606 unsigned int can_throw_external : 1;
607 /* Edges with SPECULATIVE flag represents indirect calls that was
608 speculatively turned into direct (i.e. by profile feedback).
609 The final code sequence will have form:
611 if (call_target == expected_fn)
612 expected_fn ();
613 else
614 call_target ();
616 Every speculative call is represented by three components attached
617 to a same call statement:
618 1) a direct call (to expected_fn)
619 2) an indirect call (to call_target)
620 3) a IPA_REF_ADDR refrence to expected_fn.
622 Optimizers may later redirect direct call to clone, so 1) and 3)
623 do not need to necesarily agree with destination. */
624 unsigned int speculative : 1;
627 #define CGRAPH_FREQ_BASE 1000
628 #define CGRAPH_FREQ_MAX 100000
630 typedef struct cgraph_edge *cgraph_edge_p;
633 /* The varpool data structure.
634 Each static variable decl has assigned varpool_node. */
636 class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
637 public:
638 /* Set when variable is scheduled to be assembled. */
639 unsigned output : 1;
641 /* Set if the variable is dynamically initialized, except for
642 function local statics. */
643 unsigned dynamically_initialized : 1;
646 /* Every top level asm statement is put into a asm_node. */
648 struct GTY(()) asm_node {
649 /* Next asm node. */
650 struct asm_node *next;
651 /* String for this asm node. */
652 tree asm_str;
653 /* Ordering of all cgraph nodes. */
654 int order;
657 /* Report whether or not THIS symtab node is a function, aka cgraph_node. */
659 template <>
660 template <>
661 inline bool
662 is_a_helper <cgraph_node>::test (symtab_node *p)
664 return p->type == SYMTAB_FUNCTION;
667 /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */
669 template <>
670 template <>
671 inline bool
672 is_a_helper <varpool_node>::test (symtab_node *p)
674 return p->type == SYMTAB_VARIABLE;
677 extern GTY(()) symtab_node *symtab_nodes;
678 extern GTY(()) int cgraph_n_nodes;
679 extern GTY(()) int cgraph_max_uid;
680 extern GTY(()) int cgraph_edge_max_uid;
681 extern bool cgraph_global_info_ready;
682 enum cgraph_state
684 /* Frontend is parsing and finalizing functions. */
685 CGRAPH_STATE_PARSING,
686 /* Callgraph is being constructed. It is safe to add new functions. */
687 CGRAPH_STATE_CONSTRUCTION,
688 /* Callgraph is being at LTO time. */
689 CGRAPH_LTO_STREAMING,
690 /* Callgraph is built and IPA passes are being run. */
691 CGRAPH_STATE_IPA,
692 /* Callgraph is built and all functions are transformed to SSA form. */
693 CGRAPH_STATE_IPA_SSA,
694 /* Functions are now ordered and being passed to RTL expanders. */
695 CGRAPH_STATE_EXPANSION,
696 /* All cgraph expansion is done. */
697 CGRAPH_STATE_FINISHED
699 extern enum cgraph_state cgraph_state;
700 extern bool cgraph_function_flags_ready;
701 extern cgraph_node_set cgraph_new_nodes;
703 extern GTY(()) struct asm_node *asm_nodes;
704 extern GTY(()) int symtab_order;
705 extern bool cpp_implicit_aliases_done;
707 /* In symtab.c */
708 void symtab_register_node (symtab_node *);
709 void symtab_unregister_node (symtab_node *);
710 void symtab_remove_node (symtab_node *);
711 symtab_node *symtab_get_node (const_tree);
712 symtab_node *symtab_node_for_asm (const_tree asmname);
713 void symtab_insert_node_to_hashtable (symtab_node *);
714 void symtab_add_to_same_comdat_group (symtab_node *, symtab_node *);
715 void symtab_dissolve_same_comdat_group_list (symtab_node *node);
716 void dump_symtab (FILE *);
717 void debug_symtab (void);
718 void dump_symtab_node (FILE *, symtab_node *);
719 void debug_symtab_node (symtab_node *);
720 void dump_symtab_base (FILE *, symtab_node *);
721 void verify_symtab (void);
722 void verify_symtab_node (symtab_node *);
723 bool verify_symtab_base (symtab_node *);
724 bool symtab_used_from_object_file_p (symtab_node *);
725 void symtab_make_decl_local (tree);
726 symtab_node *symtab_alias_ultimate_target (symtab_node *,
727 enum availability *avail = NULL);
728 bool symtab_resolve_alias (symtab_node *node, symtab_node *target);
729 void fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target);
730 bool symtab_for_node_and_aliases (symtab_node *,
731 bool (*) (symtab_node *, void *),
732 void *,
733 bool);
734 symtab_node *symtab_nonoverwritable_alias (symtab_node *);
735 enum availability symtab_node_availability (symtab_node *);
736 bool symtab_semantically_equivalent_p (symtab_node *, symtab_node *);
738 /* In cgraph.c */
739 void dump_cgraph (FILE *);
740 void debug_cgraph (void);
741 void dump_cgraph_node (FILE *, struct cgraph_node *);
742 void debug_cgraph_node (struct cgraph_node *);
743 void cgraph_remove_edge (struct cgraph_edge *);
744 void cgraph_remove_node (struct cgraph_node *);
745 void cgraph_release_function_body (struct cgraph_node *);
746 void release_function_body (tree);
747 void cgraph_node_remove_callees (struct cgraph_node *node);
748 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
749 struct cgraph_node *,
750 gimple, gcov_type, int);
751 struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple,
752 int, gcov_type, int);
753 struct cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);
754 struct cgraph_node * cgraph_create_node (tree);
755 struct cgraph_node * cgraph_create_empty_node (void);
756 struct cgraph_node * cgraph_get_create_node (tree);
757 struct cgraph_node * cgraph_same_body_alias (struct cgraph_node *, tree, tree);
758 struct cgraph_node * cgraph_add_thunk (struct cgraph_node *, tree, tree, bool, HOST_WIDE_INT,
759 HOST_WIDE_INT, tree, tree);
760 struct cgraph_node *cgraph_node_for_asm (tree);
761 struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
762 void cgraph_set_call_stmt (struct cgraph_edge *, gimple, bool update_speculative = true);
763 void cgraph_update_edges_for_call_stmt (gimple, tree, gimple);
764 struct cgraph_local_info *cgraph_local_info (tree);
765 struct cgraph_global_info *cgraph_global_info (tree);
766 struct cgraph_rtl_info *cgraph_rtl_info (tree);
767 struct cgraph_node *cgraph_create_function_alias (tree, tree);
768 void cgraph_call_node_duplication_hooks (struct cgraph_node *,
769 struct cgraph_node *);
770 void cgraph_call_edge_duplication_hooks (struct cgraph_edge *,
771 struct cgraph_edge *);
773 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
774 struct cgraph_edge *cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *);
775 bool cgraph_only_called_directly_p (struct cgraph_node *);
777 bool cgraph_function_possibly_inlined_p (tree);
778 void cgraph_unnest_node (struct cgraph_node *);
780 enum availability cgraph_function_body_availability (struct cgraph_node *);
781 void cgraph_add_new_function (tree, bool);
782 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
783 cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);
785 void cgraph_set_nothrow_flag (struct cgraph_node *, bool);
786 void cgraph_set_const_flag (struct cgraph_node *, bool, bool);
787 void cgraph_set_pure_flag (struct cgraph_node *, bool, bool);
788 bool cgraph_node_cannot_return (struct cgraph_node *);
789 bool cgraph_edge_cannot_lead_to_return (struct cgraph_edge *);
790 bool cgraph_will_be_removed_from_program_if_no_direct_calls
791 (struct cgraph_node *node);
792 bool cgraph_can_remove_if_no_direct_calls_and_refs_p
793 (struct cgraph_node *node);
794 bool cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node);
795 bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution);
796 bool cgraph_for_node_thunks_and_aliases (struct cgraph_node *,
797 bool (*) (struct cgraph_node *, void *),
798 void *,
799 bool);
800 bool cgraph_for_node_and_aliases (struct cgraph_node *,
801 bool (*) (struct cgraph_node *, void *),
802 void *, bool);
803 vec<cgraph_edge_p> collect_callers_of_node (struct cgraph_node *node);
804 void verify_cgraph (void);
805 void verify_cgraph_node (struct cgraph_node *);
806 void cgraph_mark_address_taken_node (struct cgraph_node *);
808 typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
809 typedef void (*cgraph_node_hook)(struct cgraph_node *, void *);
810 typedef void (*varpool_node_hook)(varpool_node *, void *);
811 typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
812 void *);
813 typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *,
814 void *);
815 struct cgraph_edge_hook_list;
816 struct cgraph_node_hook_list;
817 struct varpool_node_hook_list;
818 struct cgraph_2edge_hook_list;
819 struct cgraph_2node_hook_list;
820 struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *);
821 void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *);
822 struct cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook,
823 void *);
824 void cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *);
825 struct varpool_node_hook_list *varpool_add_node_removal_hook (varpool_node_hook,
826 void *);
827 void varpool_remove_node_removal_hook (struct varpool_node_hook_list *);
828 struct cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook,
829 void *);
830 void cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *);
831 struct varpool_node_hook_list *varpool_add_variable_insertion_hook (varpool_node_hook,
832 void *);
833 void varpool_remove_variable_insertion_hook (struct varpool_node_hook_list *);
834 void cgraph_call_function_insertion_hooks (struct cgraph_node *node);
835 struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *);
836 void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *);
837 struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *);
838 void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *);
839 gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
840 struct cgraph_node * cgraph_function_node (struct cgraph_node *,
841 enum availability *avail = NULL);
842 bool cgraph_get_body (struct cgraph_node *node);
843 struct cgraph_edge *
844 cgraph_turn_edge_to_speculative (struct cgraph_edge *,
845 struct cgraph_node *,
846 gcov_type, int);
847 void cgraph_speculative_call_info (struct cgraph_edge *,
848 struct cgraph_edge *&,
849 struct cgraph_edge *&,
850 struct ipa_ref *&);
851 extern bool gimple_check_call_matching_types (gimple, tree, bool);
853 /* In cgraphunit.c */
854 struct asm_node *add_asm_node (tree);
855 extern FILE *cgraph_dump_file;
856 void cgraph_finalize_function (tree, bool);
857 void finalize_compilation_unit (void);
858 void compile (void);
859 void init_cgraph (void);
860 void cgraph_process_new_functions (void);
861 void cgraph_process_same_body_aliases (void);
862 void fixup_same_cpp_alias_visibility (symtab_node *, symtab_node *target, tree);
863 /* Initialize datastructures so DECL is a function in lowered gimple form.
864 IN_SSA is true if the gimple is in SSA. */
865 basic_block init_lowered_empty_function (tree, bool);
866 void cgraph_reset_node (struct cgraph_node *);
867 bool expand_thunk (struct cgraph_node *, bool);
869 /* In cgraphclones.c */
871 struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
872 struct cgraph_node *, gimple,
873 unsigned, gcov_type, int, bool);
874 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type,
875 int, bool, vec<cgraph_edge_p>,
876 bool, struct cgraph_node *);
877 tree clone_function_name (tree decl, const char *);
878 struct cgraph_node * cgraph_create_virtual_clone (struct cgraph_node *old_node,
879 vec<cgraph_edge_p>,
880 vec<ipa_replace_map_p, va_gc> *tree_map,
881 bitmap args_to_skip,
882 const char *clone_name);
883 struct cgraph_node *cgraph_find_replacement_node (struct cgraph_node *);
884 bool cgraph_remove_node_and_inline_clones (struct cgraph_node *, struct cgraph_node *);
885 void cgraph_set_call_stmt_including_clones (struct cgraph_node *, gimple, gimple,
886 bool update_speculative = true);
887 void cgraph_create_edge_including_clones (struct cgraph_node *,
888 struct cgraph_node *,
889 gimple, gimple, gcov_type, int,
890 cgraph_inline_failed_t);
891 void cgraph_materialize_all_clones (void);
892 struct cgraph_node * cgraph_copy_node_for_versioning (struct cgraph_node *,
893 tree, vec<cgraph_edge_p>, bitmap);
894 struct cgraph_node *cgraph_function_versioning (struct cgraph_node *,
895 vec<cgraph_edge_p>,
896 vec<ipa_replace_map_p, va_gc> *,
897 bitmap, bool, bitmap,
898 basic_block, const char *);
899 void tree_function_versioning (tree, tree, vec<ipa_replace_map_p, va_gc> *,
900 bool, bitmap, bool, bitmap, basic_block);
901 struct cgraph_edge *cgraph_resolve_speculation (struct cgraph_edge *, tree);
903 /* In cgraphbuild.c */
904 unsigned int rebuild_cgraph_edges (void);
905 void cgraph_rebuild_references (void);
906 int compute_call_stmt_bb_frequency (tree, basic_block bb);
907 void record_references_in_initializer (tree, bool);
908 void ipa_record_stmt_references (struct cgraph_node *, gimple);
910 /* In ipa.c */
911 bool symtab_remove_unreachable_nodes (bool, FILE *);
912 cgraph_node_set cgraph_node_set_new (void);
913 cgraph_node_set_iterator cgraph_node_set_find (cgraph_node_set,
914 struct cgraph_node *);
915 void cgraph_node_set_add (cgraph_node_set, struct cgraph_node *);
916 void cgraph_node_set_remove (cgraph_node_set, struct cgraph_node *);
917 void dump_cgraph_node_set (FILE *, cgraph_node_set);
918 void debug_cgraph_node_set (cgraph_node_set);
919 void free_cgraph_node_set (cgraph_node_set);
920 void cgraph_build_static_cdtor (char which, tree body, int priority);
922 varpool_node_set varpool_node_set_new (void);
923 varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
924 varpool_node *);
925 void varpool_node_set_add (varpool_node_set, varpool_node *);
926 void varpool_node_set_remove (varpool_node_set, varpool_node *);
927 void dump_varpool_node_set (FILE *, varpool_node_set);
928 void debug_varpool_node_set (varpool_node_set);
929 void free_varpool_node_set (varpool_node_set);
930 void ipa_discover_readonly_nonaddressable_vars (void);
931 bool varpool_externally_visible_p (varpool_node *);
933 /* In predict.c */
934 bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
935 bool cgraph_optimize_for_size_p (struct cgraph_node *);
937 /* In varpool.c */
938 varpool_node *varpool_create_empty_node (void);
939 varpool_node *varpool_node_for_decl (tree);
940 varpool_node *varpool_node_for_asm (tree asmname);
941 void varpool_mark_needed_node (varpool_node *);
942 void debug_varpool (void);
943 void dump_varpool (FILE *);
944 void dump_varpool_node (FILE *, varpool_node *);
946 void varpool_finalize_decl (tree);
947 enum availability cgraph_variable_initializer_availability (varpool_node *);
948 void cgraph_make_node_local (struct cgraph_node *);
949 bool cgraph_node_can_be_local_p (struct cgraph_node *);
952 void varpool_remove_node (varpool_node *node);
953 void varpool_finalize_named_section_flags (varpool_node *node);
954 bool varpool_output_variables (void);
955 bool varpool_assemble_decl (varpool_node *node);
956 void varpool_analyze_node (varpool_node *);
957 varpool_node * varpool_extra_name_alias (tree, tree);
958 varpool_node * varpool_create_variable_alias (tree, tree);
959 void varpool_reset_queue (void);
960 tree ctor_for_folding (tree);
961 bool varpool_for_node_and_aliases (varpool_node *,
962 bool (*) (varpool_node *, void *),
963 void *, bool);
964 void varpool_add_new_variable (tree);
965 void symtab_initialize_asm_name_hash (void);
966 void symtab_prevail_in_asm_name_hash (symtab_node *node);
967 void varpool_remove_initializer (varpool_node *);
969 /* In cgraph.c */
970 extern void change_decl_assembler_name (tree, tree);
972 /* Return callgraph node for given symbol and check it is a function. */
973 static inline struct cgraph_node *
974 cgraph (symtab_node *node)
976 gcc_checking_assert (!node || node->type == SYMTAB_FUNCTION);
977 return (struct cgraph_node *)node;
980 /* Return varpool node for given symbol and check it is a variable. */
981 static inline varpool_node *
982 varpool (symtab_node *node)
984 gcc_checking_assert (!node || node->type == SYMTAB_VARIABLE);
985 return (varpool_node *)node;
988 /* Return callgraph node for given symbol and check it is a function. */
989 static inline struct cgraph_node *
990 cgraph_get_node (const_tree decl)
992 gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL);
993 return cgraph (symtab_get_node (decl));
996 /* Return varpool node for given symbol and check it is a function. */
997 static inline varpool_node *
998 varpool_get_node (const_tree decl)
1000 gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
1001 return varpool (symtab_get_node (decl));
1004 /* Walk all symbols. */
1005 #define FOR_EACH_SYMBOL(node) \
1006 for ((node) = symtab_nodes; (node); (node) = (node)->next)
1009 /* Return first variable. */
1010 static inline varpool_node *
1011 varpool_first_variable (void)
1013 symtab_node *node;
1014 for (node = symtab_nodes; node; node = node->next)
1015 if (varpool_node *vnode = dyn_cast <varpool_node> (node))
1016 return vnode;
1017 return NULL;
1020 /* Return next variable after NODE. */
1021 static inline varpool_node *
1022 varpool_next_variable (varpool_node *node)
1024 symtab_node *node1 = node->next;
1025 for (; node1; node1 = node1->next)
1026 if (varpool_node *vnode1 = dyn_cast <varpool_node> (node1))
1027 return vnode1;
1028 return NULL;
1030 /* Walk all variables. */
1031 #define FOR_EACH_VARIABLE(node) \
1032 for ((node) = varpool_first_variable (); \
1033 (node); \
1034 (node) = varpool_next_variable ((node)))
1036 /* Return first reachable static variable with initializer. */
1037 static inline varpool_node *
1038 varpool_first_static_initializer (void)
1040 symtab_node *node;
1041 for (node = symtab_nodes; node; node = node->next)
1043 varpool_node *vnode = dyn_cast <varpool_node> (node);
1044 if (vnode && DECL_INITIAL (node->decl))
1045 return vnode;
1047 return NULL;
1050 /* Return next reachable static variable with initializer after NODE. */
1051 static inline varpool_node *
1052 varpool_next_static_initializer (varpool_node *node)
1054 symtab_node *node1 = node->next;
1055 for (; node1; node1 = node1->next)
1057 varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
1058 if (vnode1 && DECL_INITIAL (node1->decl))
1059 return vnode1;
1061 return NULL;
1064 /* Walk all static variables with initializer set. */
1065 #define FOR_EACH_STATIC_INITIALIZER(node) \
1066 for ((node) = varpool_first_static_initializer (); (node); \
1067 (node) = varpool_next_static_initializer (node))
1069 /* Return first reachable static variable with initializer. */
1070 static inline varpool_node *
1071 varpool_first_defined_variable (void)
1073 symtab_node *node;
1074 for (node = symtab_nodes; node; node = node->next)
1076 varpool_node *vnode = dyn_cast <varpool_node> (node);
1077 if (vnode && vnode->definition)
1078 return vnode;
1080 return NULL;
1083 /* Return next reachable static variable with initializer after NODE. */
1084 static inline varpool_node *
1085 varpool_next_defined_variable (varpool_node *node)
1087 symtab_node *node1 = node->next;
1088 for (; node1; node1 = node1->next)
1090 varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
1091 if (vnode1 && vnode1->definition)
1092 return vnode1;
1094 return NULL;
1096 /* Walk all variables with definitions in current unit. */
1097 #define FOR_EACH_DEFINED_VARIABLE(node) \
1098 for ((node) = varpool_first_defined_variable (); (node); \
1099 (node) = varpool_next_defined_variable (node))
1101 /* Return first function with body defined. */
1102 static inline struct cgraph_node *
1103 cgraph_first_defined_function (void)
1105 symtab_node *node;
1106 for (node = symtab_nodes; node; node = node->next)
1108 cgraph_node *cn = dyn_cast <cgraph_node> (node);
1109 if (cn && cn->definition)
1110 return cn;
1112 return NULL;
1115 /* Return next function with body defined after NODE. */
1116 static inline struct cgraph_node *
1117 cgraph_next_defined_function (struct cgraph_node *node)
1119 symtab_node *node1 = node->next;
1120 for (; node1; node1 = node1->next)
1122 cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
1123 if (cn1 && cn1->definition)
1124 return cn1;
1126 return NULL;
1129 /* Walk all functions with body defined. */
1130 #define FOR_EACH_DEFINED_FUNCTION(node) \
1131 for ((node) = cgraph_first_defined_function (); (node); \
1132 (node) = cgraph_next_defined_function ((node)))
1134 /* Return first function. */
1135 static inline struct cgraph_node *
1136 cgraph_first_function (void)
1138 symtab_node *node;
1139 for (node = symtab_nodes; node; node = node->next)
1140 if (cgraph_node *cn = dyn_cast <cgraph_node> (node))
1141 return cn;
1142 return NULL;
1145 /* Return next function. */
1146 static inline struct cgraph_node *
1147 cgraph_next_function (struct cgraph_node *node)
1149 symtab_node *node1 = node->next;
1150 for (; node1; node1 = node1->next)
1151 if (cgraph_node *cn1 = dyn_cast <cgraph_node> (node1))
1152 return cn1;
1153 return NULL;
1155 /* Walk all functions. */
1156 #define FOR_EACH_FUNCTION(node) \
1157 for ((node) = cgraph_first_function (); (node); \
1158 (node) = cgraph_next_function ((node)))
1160 /* Return true when NODE is a function with Gimple body defined
1161 in current unit. Functions can also be define externally or they
1162 can be thunks with no Gimple representation.
1164 Note that at WPA stage, the function body may not be present in memory. */
1166 static inline bool
1167 cgraph_function_with_gimple_body_p (struct cgraph_node *node)
1169 return node->definition && !node->thunk.thunk_p && !node->alias;
1172 /* Return first function with body defined. */
1173 static inline struct cgraph_node *
1174 cgraph_first_function_with_gimple_body (void)
1176 symtab_node *node;
1177 for (node = symtab_nodes; node; node = node->next)
1179 cgraph_node *cn = dyn_cast <cgraph_node> (node);
1180 if (cn && cgraph_function_with_gimple_body_p (cn))
1181 return cn;
1183 return NULL;
1186 /* Return next reachable static variable with initializer after NODE. */
1187 static inline struct cgraph_node *
1188 cgraph_next_function_with_gimple_body (struct cgraph_node *node)
1190 symtab_node *node1 = node->next;
1191 for (; node1; node1 = node1->next)
1193 cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
1194 if (cn1 && cgraph_function_with_gimple_body_p (cn1))
1195 return cn1;
1197 return NULL;
1200 /* Walk all functions with body defined. */
1201 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
1202 for ((node) = cgraph_first_function_with_gimple_body (); (node); \
1203 (node) = cgraph_next_function_with_gimple_body (node))
1205 /* Create a new static variable of type TYPE. */
1206 tree add_new_static_var (tree type);
1208 /* Return true if iterator CSI points to nothing. */
1209 static inline bool
1210 csi_end_p (cgraph_node_set_iterator csi)
1212 return csi.index >= csi.set->nodes.length ();
1215 /* Advance iterator CSI. */
1216 static inline void
1217 csi_next (cgraph_node_set_iterator *csi)
1219 csi->index++;
1222 /* Return the node pointed to by CSI. */
1223 static inline struct cgraph_node *
1224 csi_node (cgraph_node_set_iterator csi)
1226 return csi.set->nodes[csi.index];
1229 /* Return an iterator to the first node in SET. */
1230 static inline cgraph_node_set_iterator
1231 csi_start (cgraph_node_set set)
1233 cgraph_node_set_iterator csi;
1235 csi.set = set;
1236 csi.index = 0;
1237 return csi;
1240 /* Return true if SET contains NODE. */
1241 static inline bool
1242 cgraph_node_in_set_p (struct cgraph_node *node, cgraph_node_set set)
1244 cgraph_node_set_iterator csi;
1245 csi = cgraph_node_set_find (set, node);
1246 return !csi_end_p (csi);
1249 /* Return number of nodes in SET. */
1250 static inline size_t
1251 cgraph_node_set_size (cgraph_node_set set)
1253 return set->nodes.length ();
1256 /* Return true if iterator VSI points to nothing. */
1257 static inline bool
1258 vsi_end_p (varpool_node_set_iterator vsi)
1260 return vsi.index >= vsi.set->nodes.length ();
1263 /* Advance iterator VSI. */
1264 static inline void
1265 vsi_next (varpool_node_set_iterator *vsi)
1267 vsi->index++;
1270 /* Return the node pointed to by VSI. */
1271 static inline varpool_node *
1272 vsi_node (varpool_node_set_iterator vsi)
1274 return vsi.set->nodes[vsi.index];
1277 /* Return an iterator to the first node in SET. */
1278 static inline varpool_node_set_iterator
1279 vsi_start (varpool_node_set set)
1281 varpool_node_set_iterator vsi;
1283 vsi.set = set;
1284 vsi.index = 0;
1285 return vsi;
1288 /* Return true if SET contains NODE. */
1289 static inline bool
1290 varpool_node_in_set_p (varpool_node *node, varpool_node_set set)
1292 varpool_node_set_iterator vsi;
1293 vsi = varpool_node_set_find (set, node);
1294 return !vsi_end_p (vsi);
1297 /* Return number of nodes in SET. */
1298 static inline size_t
1299 varpool_node_set_size (varpool_node_set set)
1301 return set->nodes.length ();
1304 /* Uniquize all constants that appear in memory.
1305 Each constant in memory thus far output is recorded
1306 in `const_desc_table'. */
1308 struct GTY(()) constant_descriptor_tree {
1309 /* A MEM for the constant. */
1310 rtx rtl;
1312 /* The value of the constant. */
1313 tree value;
1315 /* Hash of value. Computing the hash from value each time
1316 hashfn is called can't work properly, as that means recursive
1317 use of the hash table during hash table expansion. */
1318 hashval_t hash;
1321 /* Return true if set is nonempty. */
1322 static inline bool
1323 cgraph_node_set_nonempty_p (cgraph_node_set set)
1325 return !set->nodes.is_empty ();
1328 /* Return true if set is nonempty. */
1329 static inline bool
1330 varpool_node_set_nonempty_p (varpool_node_set set)
1332 return !set->nodes.is_empty ();
1335 /* Return true when function NODE is only called directly or it has alias.
1336 i.e. it is not externally visible, address was not taken and
1337 it is not used in any other non-standard way. */
1339 static inline bool
1340 cgraph_only_called_directly_or_aliased_p (struct cgraph_node *node)
1342 gcc_assert (!node->global.inlined_to);
1343 return (!node->force_output && !node->address_taken
1344 && !node->used_from_other_partition
1345 && !DECL_VIRTUAL_P (node->decl)
1346 && !DECL_STATIC_CONSTRUCTOR (node->decl)
1347 && !DECL_STATIC_DESTRUCTOR (node->decl)
1348 && !node->externally_visible);
1351 /* Return true when function NODE can be removed from callgraph
1352 if all direct calls are eliminated. */
1354 static inline bool
1355 varpool_can_remove_if_no_refs (varpool_node *node)
1357 if (DECL_EXTERNAL (node->decl))
1358 return true;
1359 return (!node->force_output && !node->used_from_other_partition
1360 && ((DECL_COMDAT (node->decl)
1361 && !node->forced_by_abi
1362 && !symtab_used_from_object_file_p (node))
1363 || !node->externally_visible
1364 || DECL_HAS_VALUE_EXPR_P (node->decl)));
1367 /* Return true when all references to VNODE must be visible in ipa_ref_list.
1368 i.e. if the variable is not externally visible or not used in some magic
1369 way (asm statement or such).
1370 The magic uses are all summarized in force_output flag. */
1372 static inline bool
1373 varpool_all_refs_explicit_p (varpool_node *vnode)
1375 return (vnode->definition
1376 && !vnode->externally_visible
1377 && !vnode->used_from_other_partition
1378 && !vnode->force_output);
1381 /* Constant pool accessor function. */
1382 htab_t constant_pool_htab (void);
1384 /* FIXME: inappropriate dependency of cgraph on IPA. */
1385 #include "ipa-ref-inline.h"
1387 /* Return node that alias N is aliasing. */
1389 static inline symtab_node *
1390 symtab_alias_target (symtab_node *n)
1392 struct ipa_ref *ref;
1393 ipa_ref_list_reference_iterate (&n->ref_list, 0, ref);
1394 gcc_checking_assert (ref->use == IPA_REF_ALIAS);
1395 return ref->referred;
1398 static inline struct cgraph_node *
1399 cgraph_alias_target (struct cgraph_node *n)
1401 return dyn_cast <cgraph_node> (symtab_alias_target (n));
1404 static inline varpool_node *
1405 varpool_alias_target (varpool_node *n)
1407 return dyn_cast <varpool_node> (symtab_alias_target (n));
1410 /* Given NODE, walk the alias chain to return the function NODE is alias of.
1411 Do not walk through thunks.
1412 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
1414 static inline struct cgraph_node *
1415 cgraph_function_or_thunk_node (struct cgraph_node *node,
1416 enum availability *availability = NULL)
1418 struct cgraph_node *n;
1420 n = dyn_cast <cgraph_node> (symtab_alias_ultimate_target (node,
1421 availability));
1422 if (!n && availability)
1423 *availability = AVAIL_NOT_AVAILABLE;
1424 return n;
1426 /* Given NODE, walk the alias chain to return the function NODE is alias of.
1427 Do not walk through thunks.
1428 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
1430 static inline varpool_node *
1431 varpool_variable_node (varpool_node *node,
1432 enum availability *availability = NULL)
1434 varpool_node *n;
1436 if (node)
1437 n = dyn_cast <varpool_node> (symtab_alias_ultimate_target (node,
1438 availability));
1439 else
1440 n = NULL;
1442 if (!n && availability)
1443 *availability = AVAIL_NOT_AVAILABLE;
1444 return n;
1447 /* Return true when the edge E represents a direct recursion. */
1448 static inline bool
1449 cgraph_edge_recursive_p (struct cgraph_edge *e)
1451 struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
1452 if (e->caller->global.inlined_to)
1453 return e->caller->global.inlined_to->decl == callee->decl;
1454 else
1455 return e->caller->decl == callee->decl;
1458 /* Return true if the TM_CLONE bit is set for a given FNDECL. */
1459 static inline bool
1460 decl_is_tm_clone (const_tree fndecl)
1462 struct cgraph_node *n = cgraph_get_node (fndecl);
1463 if (n)
1464 return n->tm_clone;
1465 return false;
1468 /* Likewise indicate that a node is needed, i.e. reachable via some
1469 external means. */
1471 static inline void
1472 cgraph_mark_force_output_node (struct cgraph_node *node)
1474 node->force_output = 1;
1475 gcc_checking_assert (!node->global.inlined_to);
1478 /* Return true when the symbol is real symbol, i.e. it is not inline clone
1479 or abstract function kept for debug info purposes only. */
1481 static inline bool
1482 symtab_real_symbol_p (symtab_node *node)
1484 struct cgraph_node *cnode;
1486 if (DECL_ABSTRACT (node->decl))
1487 return false;
1488 if (!is_a <cgraph_node> (node))
1489 return true;
1490 cnode = cgraph (node);
1491 if (cnode->global.inlined_to)
1492 return false;
1493 return true;
1496 /* Return true if NODE can be discarded by linker from the binary. */
1498 static inline bool
1499 symtab_can_be_discarded (symtab_node *node)
1501 return (DECL_EXTERNAL (node->decl)
1502 || (DECL_ONE_ONLY (node->decl)
1503 && node->resolution != LDPR_PREVAILING_DEF
1504 && node->resolution != LDPR_PREVAILING_DEF_IRONLY
1505 && node->resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
1508 /* Return true if NODE is local to a particular COMDAT group, and must not
1509 be named from outside the COMDAT. This is used for C++ decloned
1510 constructors. */
1512 static inline bool
1513 symtab_comdat_local_p (symtab_node *node)
1515 return (node->same_comdat_group && !TREE_PUBLIC (node->decl));
1518 /* Return true if ONE and TWO are part of the same COMDAT group. */
1520 static inline bool
1521 symtab_in_same_comdat_p (symtab_node *one, symtab_node *two)
1523 return DECL_COMDAT_GROUP (one->decl) == DECL_COMDAT_GROUP (two->decl);
1525 #endif /* GCC_CGRAPH_H */