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

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

source code of gcc/cgraph.h