cgraph.h source code [gcc/cgraph.h]

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

source code of gcc/cgraph.h