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