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

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

source code of gcc/cgraph.h