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	/* This file contains basic routines manipulating call graph
22
23	The call-graph is a data structure designed for inter-procedural
24	optimization. It represents a multi-graph where nodes are functions
25	(symbols within symbol table) and edges are call sites. */
26
27	#include "config.h"
28	#include "system.h"
29	#include "coretypes.h"
30	#include "backend.h"
31	#include "target.h"
32	#include "rtl.h"
33	#include "tree.h"
34	#include "gimple.h"
35	#include "predict.h"
36	#include "alloc-pool.h"
37	#include "gimple-ssa.h"
38	#include "cgraph.h"
39	#include "lto-streamer.h"
40	#include "fold-const.h"
41	#include "varasm.h"
42	#include "calls.h"
43	#include "print-tree.h"
44	#include "langhooks.h"
45	#include "intl.h"
46	#include "tree-eh.h"
47	#include "gimple-iterator.h"
48	#include "tree-cfg.h"
49	#include "tree-ssa.h"
50	#include "value-prof.h"
51	#include "ipa-utils.h"
52	#include "symbol-summary.h"
53	#include "tree-vrp.h"
54	#include "ipa-prop.h"
55	#include "ipa-fnsummary.h"
56	#include "cfgloop.h"
57	#include "gimple-pretty-print.h"
58	#include "tree-dfa.h"
59	#include "profile.h"
60	#include "context.h"
61	#include "gimplify.h"
62	#include "stringpool.h"
63	#include "attribs.h"
64	#include "selftest.h"
65	#include "tree-into-ssa.h"
66	#include "ipa-inline.h"
67	#include "tree-nested.h"
68	#include "symtab-thunks.h"
69	#include "symtab-clones.h"
70
71	/* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this. */
72	#include "tree-pass.h"
73
74	/* Queue of cgraph nodes scheduled to be lowered. */
75	symtab_node *x_cgraph_nodes_queue;
76	#define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
77
78	/* Symbol table global context. */
79	symbol_table *symtab;
80
81	/* List of hooks triggered on cgraph_edge events. */
82	struct cgraph_edge_hook_list {
83	cgraph_edge_hook hook;
84	void *data;
85	struct cgraph_edge_hook_list *next;
86	};
87
88	/* List of hooks triggered on cgraph_node events. */
89	struct cgraph_node_hook_list {
90	cgraph_node_hook hook;
91	void *data;
92	struct cgraph_node_hook_list *next;
93	};
94
95	/* List of hooks triggered on events involving two cgraph_edges. */
96	struct cgraph_2edge_hook_list {
97	cgraph_2edge_hook hook;
98	void *data;
99	struct cgraph_2edge_hook_list *next;
100	};
101
102	/* List of hooks triggered on events involving two cgraph_nodes. */
103	struct cgraph_2node_hook_list {
104	cgraph_2node_hook hook;
105	void *data;
106	struct cgraph_2node_hook_list *next;
107	};
108
109	/* Hash descriptor for cgraph_function_version_info. */
110
111	struct function_version_hasher : ggc_ptr_hash<cgraph_function_version_info>
112	{
113	static hashval_t hash (cgraph_function_version_info *);
114	static bool equal (cgraph_function_version_info *,
115	cgraph_function_version_info *);
116	};
117
118	/* Map a cgraph_node to cgraph_function_version_info using this htab.
119	The cgraph_function_version_info has a THIS_NODE field that is the
120	corresponding cgraph_node.. */
121
122	static GTY(()) hash_table<function_version_hasher> *cgraph_fnver_htab = NULL;
123
124	/* Hash function for cgraph_fnver_htab. */
125	hashval_t
126	function_version_hasher::hash (cgraph_function_version_info *ptr)
127	{
128	int uid = ptr->this_node->get_uid ();
129	return (hashval_t)(uid);
130	}
131
132	/* eq function for cgraph_fnver_htab. */
133	bool
134	function_version_hasher::equal (cgraph_function_version_info *n1,
135	cgraph_function_version_info *n2)
136	{
137	return n1->this_node->get_uid () == n2->this_node->get_uid ();
138	}
139
140	/* Mark as GC root all allocated nodes. */
141	static GTY(()) struct cgraph_function_version_info *
142	version_info_node = NULL;
143
144	/* Return true if NODE's address can be compared. */
145
146	bool
147	symtab_node::address_can_be_compared_p ()
148	{
149	/* Address of virtual tables and functions is never compared. */
150	if (DECL_VIRTUAL_P (decl))
151	return false;
152	/* Address of C++ cdtors is never compared. */
153	if (is_a <cgraph_node *> (p: this)
154	&& (DECL_CXX_CONSTRUCTOR_P (decl)
155	|| DECL_CXX_DESTRUCTOR_P (decl)))
156	return false;
157	/* Constant pool symbols addresses are never compared.
158	flag_merge_constants permits us to assume the same on readonly vars. */
159	if (is_a <varpool_node *> (p: this)
160	&& (DECL_IN_CONSTANT_POOL (decl)
161	|| ((flag_merge_constants >= 2 || DECL_MERGEABLE (decl))
162	&& TREE_READONLY (decl) && !TREE_THIS_VOLATILE (decl))))
163	return false;
164	return true;
165	}
166
167	/* Get the cgraph_function_version_info node corresponding to node. */
168	cgraph_function_version_info *
169	cgraph_node::function_version (void)
170	{
171	cgraph_function_version_info key;
172	key.this_node = this;
173
174	if (cgraph_fnver_htab == NULL)
175	return NULL;
176
177	return cgraph_fnver_htab->find (value: &key);
178	}
179
180	/* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
181	corresponding to cgraph_node NODE. */
182	cgraph_function_version_info *
183	cgraph_node::insert_new_function_version (void)
184	{
185	version_info_node = NULL;
186	version_info_node = ggc_cleared_alloc<cgraph_function_version_info> ();
187	version_info_node->this_node = this;
188
189	if (cgraph_fnver_htab == NULL)
190	cgraph_fnver_htab = hash_table<function_version_hasher>::create_ggc (n: 2);
191
192	*cgraph_fnver_htab->find_slot (value: version_info_node, insert: INSERT)
193	= version_info_node;
194	return version_info_node;
195	}
196
197	/* Remove the cgraph_function_version_info node given by DECL_V. */
198	static void
199	delete_function_version (cgraph_function_version_info *decl_v)
200	{
201	if (decl_v == NULL)
202	return;
203
204	if (version_info_node == decl_v)
205	version_info_node = NULL;
206
207	if (decl_v->prev != NULL)
208	decl_v->prev->next = decl_v->next;
209
210	if (decl_v->next != NULL)
211	decl_v->next->prev = decl_v->prev;
212
213	if (cgraph_fnver_htab != NULL)
214	cgraph_fnver_htab->remove_elt (value: decl_v);
215	}
216
217	/* Remove the cgraph_function_version_info and cgraph_node for DECL. This
218	DECL is a duplicate declaration. */
219	void
220	cgraph_node::delete_function_version_by_decl (tree decl)
221	{
222	cgraph_node *decl_node = cgraph_node::get (decl);
223
224	if (decl_node == NULL)
225	return;
226
227	delete_function_version (decl_v: decl_node->function_version ());
228
229	decl_node->remove ();
230	}
231
232	/* Record that DECL1 and DECL2 are semantically identical function
233	versions. */
234	void
235	cgraph_node::record_function_versions (tree decl1, tree decl2)
236	{
237	cgraph_node *decl1_node = cgraph_node::get_create (decl1);
238	cgraph_node *decl2_node = cgraph_node::get_create (decl2);
239	cgraph_function_version_info *decl1_v = NULL;
240	cgraph_function_version_info *decl2_v = NULL;
241	cgraph_function_version_info *before;
242	cgraph_function_version_info *after;
243
244	gcc_assert (decl1_node != NULL && decl2_node != NULL);
245	decl1_v = decl1_node->function_version ();
246	decl2_v = decl2_node->function_version ();
247
248	if (decl1_v != NULL && decl2_v != NULL)
249	return;
250
251	if (decl1_v == NULL)
252	decl1_v = decl1_node->insert_new_function_version ();
253
254	if (decl2_v == NULL)
255	decl2_v = decl2_node->insert_new_function_version ();
256
257	/* Chain decl2_v and decl1_v. All semantically identical versions
258	will be chained together. */
259
260	before = decl1_v;
261	after = decl2_v;
262
263	while (before->next != NULL)
264	before = before->next;
265
266	while (after->prev != NULL)
267	after= after->prev;
268
269	before->next = after;
270	after->prev = before;
271	}
272
273	/* Initialize callgraph dump file. */
274
275	void
276	symbol_table::initialize (void)
277	{
278	if (!dump_file)
279	dump_file = dump_begin (TDI_cgraph, NULL);
280
281	if (!ipa_clones_dump_file)
282	ipa_clones_dump_file = dump_begin (TDI_clones, NULL);
283	}
284
285	/* Allocate new callgraph node and insert it into basic data structures. */
286
287	cgraph_node *
288	symbol_table::create_empty (void)
289	{
290	cgraph_count++;
291	return new (ggc_alloc<cgraph_node> ()) cgraph_node (cgraph_max_uid++);
292	}
293
294	/* Register HOOK to be called with DATA on each removed edge. */
295	cgraph_edge_hook_list *
296	symbol_table::add_edge_removal_hook (cgraph_edge_hook hook, void *data)
297	{
298	cgraph_edge_hook_list *entry;
299	cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
300
301	entry = (cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
302	entry->hook = hook;
303	entry->data = data;
304	entry->next = NULL;
305	while (*ptr)
306	ptr = &(*ptr)->next;
307	*ptr = entry;
308	return entry;
309	}
310
311	/* Remove ENTRY from the list of hooks called on removing edges. */
312	void
313	symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list *entry)
314	{
315	cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
316
317	while (*ptr != entry)
318	ptr = &(*ptr)->next;
319	*ptr = entry->next;
320	free (ptr: entry);
321	}
322
323	/* Call all edge removal hooks. */
324	void
325	symbol_table::call_edge_removal_hooks (cgraph_edge *e)
326	{
327	cgraph_edge_hook_list *entry = m_first_edge_removal_hook;
328	while (entry)
329	{
330	entry->hook (e, entry->data);
331	entry = entry->next;
332	}
333	}
334
335	/* Register HOOK to be called with DATA on each removed node. */
336	cgraph_node_hook_list *
337	symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook, void *data)
338	{
339	cgraph_node_hook_list *entry;
340	cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
341
342	entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
343	entry->hook = hook;
344	entry->data = data;
345	entry->next = NULL;
346	while (*ptr)
347	ptr = &(*ptr)->next;
348	*ptr = entry;
349	return entry;
350	}
351
352	/* Remove ENTRY from the list of hooks called on removing nodes. */
353	void
354	symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list *entry)
355	{
356	cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
357
358	while (*ptr != entry)
359	ptr = &(*ptr)->next;
360	*ptr = entry->next;
361	free (ptr: entry);
362	}
363
364	/* Call all node removal hooks. */
365	void
366	symbol_table::call_cgraph_removal_hooks (cgraph_node *node)
367	{
368	cgraph_node_hook_list *entry = m_first_cgraph_removal_hook;
369	while (entry)
370	{
371	entry->hook (node, entry->data);
372	entry = entry->next;
373	}
374	}
375
376	/* Call all node removal hooks. */
377	void
378	symbol_table::call_cgraph_insertion_hooks (cgraph_node *node)
379	{
380	cgraph_node_hook_list *entry = m_first_cgraph_insertion_hook;
381	while (entry)
382	{
383	entry->hook (node, entry->data);
384	entry = entry->next;
385	}
386	}
387
388
389	/* Register HOOK to be called with DATA on each inserted node. */
390	cgraph_node_hook_list *
391	symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook, void *data)
392	{
393	cgraph_node_hook_list *entry;
394	cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
395
396	entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
397	entry->hook = hook;
398	entry->data = data;
399	entry->next = NULL;
400	while (*ptr)
401	ptr = &(*ptr)->next;
402	*ptr = entry;
403	return entry;
404	}
405
406	/* Remove ENTRY from the list of hooks called on inserted nodes. */
407	void
408	symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list *entry)
409	{
410	cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
411
412	while (*ptr != entry)
413	ptr = &(*ptr)->next;
414	*ptr = entry->next;
415	free (ptr: entry);
416	}
417
418	/* Register HOOK to be called with DATA on each duplicated edge. */
419	cgraph_2edge_hook_list *
420	symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
421	{
422	cgraph_2edge_hook_list *entry;
423	cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
424
425	entry = (cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
426	entry->hook = hook;
427	entry->data = data;
428	entry->next = NULL;
429	while (*ptr)
430	ptr = &(*ptr)->next;
431	*ptr = entry;
432	return entry;
433	}
434
435	/* Remove ENTRY from the list of hooks called on duplicating edges. */
436	void
437	symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list *entry)
438	{
439	cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
440
441	while (*ptr != entry)
442	ptr = &(*ptr)->next;
443	*ptr = entry->next;
444	free (ptr: entry);
445	}
446
447	/* Call all edge duplication hooks. */
448	void
449	symbol_table::call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2)
450	{
451	cgraph_2edge_hook_list *entry = m_first_edge_duplicated_hook;
452	while (entry)
453	{
454	entry->hook (cs1, cs2, entry->data);
455	entry = entry->next;
456	}
457	}
458
459	/* Register HOOK to be called with DATA on each duplicated node. */
460	cgraph_2node_hook_list *
461	symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook, void *data)
462	{
463	cgraph_2node_hook_list *entry;
464	cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
465
466	entry = (cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
467	entry->hook = hook;
468	entry->data = data;
469	entry->next = NULL;
470	while (*ptr)
471	ptr = &(*ptr)->next;
472	*ptr = entry;
473	return entry;
474	}
475
476	/* Remove ENTRY from the list of hooks called on duplicating nodes. */
477	void
478	symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry)
479	{
480	cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
481
482	while (*ptr != entry)
483	ptr = &(*ptr)->next;
484	*ptr = entry->next;
485	free (ptr: entry);
486	}
487
488	/* Call all node duplication hooks. */
489	void
490	symbol_table::call_cgraph_duplication_hooks (cgraph_node *node,
491	cgraph_node *node2)
492	{
493	cgraph_2node_hook_list *entry = m_first_cgraph_duplicated_hook;
494	while (entry)
495	{
496	entry->hook (node, node2, entry->data);
497	entry = entry->next;
498	}
499	}
500
501	/* Return cgraph node assigned to DECL. Create new one when needed. */
502
503	cgraph_node *
504	cgraph_node::create (tree decl)
505	{
506	cgraph_node *node = symtab->create_empty ();
507	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
508
509	node->decl = decl;
510	node->semantic_interposition = opt_for_fn (decl, flag_semantic_interposition);
511
512	if ((flag_openacc || flag_openmp)
513	&& lookup_attribute (attr_name: "omp declare target", DECL_ATTRIBUTES (decl)))
514	{
515	node->offloadable = 1;
516	if (ENABLE_OFFLOADING)
517	g->have_offload = true;
518	}
519
520	if (lookup_attribute (attr_name: "ifunc", DECL_ATTRIBUTES (decl)))
521	node->ifunc_resolver = true;
522
523	node->register_symbol ();
524	maybe_record_nested_function (node);
525
526	return node;
527	}
528
529	/* Try to find a call graph node for declaration DECL and if it does not exist
530	or if it corresponds to an inline clone, create a new one. */
531
532	cgraph_node *
533	cgraph_node::get_create (tree decl)
534	{
535	cgraph_node *first_clone = cgraph_node::get (decl);
536
537	if (first_clone && !first_clone->inlined_to)
538	return first_clone;
539
540	cgraph_node *node = cgraph_node::create (decl);
541	if (first_clone)
542	{
543	first_clone->clone_of = node;
544	node->clones = first_clone;
545	node->order = first_clone->order;
546	symtab->symtab_prevail_in_asm_name_hash (node);
547	node->decl->decl_with_vis.symtab_node = node;
548	if (dump_file && symtab->state != PARSING)
549	fprintf (stream: dump_file, format: "Introduced new external node "
550	"(%s) and turned into root of the clone tree.\n",
551	node->dump_name ());
552	}
553	else if (dump_file && symtab->state != PARSING)
554	fprintf (stream: dump_file, format: "Introduced new external node "
555	"(%s).\n", node->dump_name ());
556	return node;
557	}
558
559	/* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing
560	the function body is associated with
561	(not necessarily cgraph_node (DECL)). */
562
563	cgraph_node *
564	cgraph_node::create_alias (tree alias, tree target)
565	{
566	cgraph_node *alias_node;
567
568	gcc_assert (TREE_CODE (target) == FUNCTION_DECL
569	|| TREE_CODE (target) == IDENTIFIER_NODE);
570	gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
571	alias_node = cgraph_node::get_create (decl: alias);
572	gcc_assert (!alias_node->definition);
573	alias_node->alias_target = target;
574	alias_node->definition = true;
575	alias_node->alias = true;
576	if (lookup_attribute (attr_name: "weakref", DECL_ATTRIBUTES (alias)) != NULL)
577	alias_node->transparent_alias = alias_node->weakref = true;
578	if (lookup_attribute (attr_name: "ifunc", DECL_ATTRIBUTES (alias)))
579	alias_node->ifunc_resolver = true;
580	return alias_node;
581	}
582
583	/* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
584	and NULL otherwise.
585	Same body aliases are output whenever the body of DECL is output,
586	and cgraph_node::get (ALIAS) transparently returns
587	cgraph_node::get (DECL). */
588
589	cgraph_node *
590	cgraph_node::create_same_body_alias (tree alias, tree decl)
591	{
592	cgraph_node *n;
593
594	/* If aliases aren't supported by the assembler, fail. */
595	if (!TARGET_SUPPORTS_ALIASES)
596	return NULL;
597
598	/* Langhooks can create same body aliases of symbols not defined.
599	Those are useless. Drop them on the floor. */
600	if (symtab->global_info_ready)
601	return NULL;
602
603	n = cgraph_node::create_alias (alias, target: decl);
604	n->cpp_implicit_alias = true;
605	if (symtab->cpp_implicit_aliases_done)
606	n->resolve_alias (target: cgraph_node::get (decl));
607	return n;
608	}
609
610	/* Add thunk alias into callgraph. The alias declaration is ALIAS and it
611	aliases DECL with an adjustments made into the first parameter.
612	See comments in struct cgraph_thunk_info for detail on the parameters. */
613
614	cgraph_node *
615	cgraph_node::create_thunk (tree alias, tree, bool this_adjusting,
616	HOST_WIDE_INT fixed_offset,
617	HOST_WIDE_INT virtual_value,
618	HOST_WIDE_INT indirect_offset,
619	tree virtual_offset,
620	tree real_alias)
621	{
622	cgraph_node *node;
623
624	node = cgraph_node::get (decl: alias);
625	if (node)
626	node->reset ();
627	else
628	node = cgraph_node::create (decl: alias);
629
630	/* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE. */
631	gcc_checking_assert (virtual_offset
632	? virtual_value == wi::to_wide (virtual_offset)
633	: virtual_value == 0);
634
635	node->thunk = true;
636	node->definition = true;
637
638	thunk_info *i;
639	thunk_info local_info;
640	if (symtab->state < CONSTRUCTION)
641	i = &local_info;
642	else
643	i = thunk_info::get_create (node);
644	i->fixed_offset = fixed_offset;
645	i->virtual_value = virtual_value;
646	i->indirect_offset = indirect_offset;
647	i->alias = real_alias;
648	i->this_adjusting = this_adjusting;
649	i->virtual_offset_p = virtual_offset != NULL;
650	if (symtab->state < CONSTRUCTION)
651	i->register_early (node);
652
653	return node;
654	}
655
656	/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
657	Return NULL if there's no such node. */
658
659	cgraph_node *
660	cgraph_node::get_for_asmname (tree asmname)
661	{
662	/* We do not want to look at inline clones. */
663	for (symtab_node *node = symtab_node::get_for_asmname (asmname);
664	node;
665	node = node->next_sharing_asm_name)
666	{
667	cgraph_node *cn = dyn_cast <cgraph_node *> (p: node);
668	if (cn && !cn->inlined_to)
669	return cn;
670	}
671	return NULL;
672	}
673
674	/* Returns a hash value for X (which really is a cgraph_edge). */
675
676	hashval_t
677	cgraph_edge_hasher::hash (cgraph_edge *e)
678	{
679	/* This is a really poor hash function, but it is what htab_hash_pointer
680	uses. */
681	return (hashval_t) ((intptr_t)e->call_stmt >> 3);
682	}
683
684	/* Returns a hash value for X (which really is a cgraph_edge). */
685
686	hashval_t
687	cgraph_edge_hasher::hash (gimple *call_stmt)
688	{
689	/* This is a really poor hash function, but it is what htab_hash_pointer
690	uses. */
691	return (hashval_t) ((intptr_t)call_stmt >> 3);
692	}
693
694	/* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y. */
695
696	inline bool
697	cgraph_edge_hasher::equal (cgraph_edge *x, gimple *y)
698	{
699	return x->call_stmt == y;
700	}
701
702	/* Add call graph edge E to call site hash of its caller. */
703
704	static inline void
705	cgraph_update_edge_in_call_site_hash (cgraph_edge *e)
706	{
707	gimple *call = e->call_stmt;
708	*e->caller->call_site_hash->find_slot_with_hash
709	(comparable: call, hash: cgraph_edge_hasher::hash (call_stmt: call), insert: INSERT) = e;
710	}
711
712	/* Add call graph edge E to call site hash of its caller. */
713
714	static inline void
715	cgraph_add_edge_to_call_site_hash (cgraph_edge *e)
716	{
717	/* There are two speculative edges for every statement (one direct,
718	one indirect); always hash the direct one. */
719	if (e->speculative && e->indirect_unknown_callee)
720	return;
721	cgraph_edge **slot = e->caller->call_site_hash->find_slot_with_hash
722	(comparable: e->call_stmt, hash: cgraph_edge_hasher::hash (call_stmt: e->call_stmt), insert: INSERT);
723	if (*slot)
724	{
725	gcc_assert (((cgraph_edge *)*slot)->speculative);
726	if (e->callee && (!e->prev_callee
727	|| !e->prev_callee->speculative
728	|| e->prev_callee->call_stmt != e->call_stmt))
729	*slot = e;
730	return;
731	}
732	gcc_assert (!*slot || e->speculative);
733	*slot = e;
734	}
735
736	/* Return the callgraph edge representing the GIMPLE_CALL statement
737	CALL_STMT. */
738
739	cgraph_edge *
740	cgraph_node::get_edge (gimple *call_stmt)
741	{
742	cgraph_edge *e, *e2;
743	int n = 0;
744
745	if (call_site_hash)
746	return call_site_hash->find_with_hash
747	(comparable: call_stmt, hash: cgraph_edge_hasher::hash (call_stmt));
748
749	/* This loop may turn out to be performance problem. In such case adding
750	hashtables into call nodes with very many edges is probably best
751	solution. It is not good idea to add pointer into CALL_EXPR itself
752	because we want to make possible having multiple cgraph nodes representing
753	different clones of the same body before the body is actually cloned. */
754	for (e = callees; e; e = e->next_callee)
755	{
756	if (e->call_stmt == call_stmt)
757	break;
758	n++;
759	}
760
761	if (!e)
762	for (e = indirect_calls; e; e = e->next_callee)
763	{
764	if (e->call_stmt == call_stmt)
765	break;
766	n++;
767	}
768
769	if (n > 100)
770	{
771	call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc (n: 120);
772	for (e2 = callees; e2; e2 = e2->next_callee)
773	cgraph_add_edge_to_call_site_hash (e: e2);
774	for (e2 = indirect_calls; e2; e2 = e2->next_callee)
775	cgraph_add_edge_to_call_site_hash (e: e2);
776	}
777
778	return e;
779	}
780
781
782	/* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E
783	is any component of speculative edge, then update all components.
784	Speculations can be resolved in the process and EDGE can be removed and
785	deallocated. Return the edge that now represents the call. */
786
787	cgraph_edge *
788	cgraph_edge::set_call_stmt (cgraph_edge *e, gcall *new_stmt,
789	bool update_speculative)
790	{
791	tree decl;
792
793	cgraph_node *new_direct_callee = NULL;
794	if ((e->indirect_unknown_callee || e->speculative)
795	&& (decl = gimple_call_fndecl (gs: new_stmt)))
796	{
797	/* Constant propagation and especially inlining can turn an indirect call
798	into a direct one. */
799	new_direct_callee = cgraph_node::get (decl);
800	gcc_checking_assert (new_direct_callee);
801	}
802
803	/* Speculative edges has three component, update all of them
804	when asked to. */
805	if (update_speculative && e->speculative
806	/* If we are about to resolve the speculation by calling make_direct
807	below, do not bother going over all the speculative edges now. */
808	&& !new_direct_callee)
809	{
810	cgraph_edge *direct, *indirect, *next;
811	ipa_ref *ref;
812	bool e_indirect = e->indirect_unknown_callee;
813	int n = 0;
814
815	direct = e->first_speculative_call_target ();
816	indirect = e->speculative_call_indirect_edge ();
817
818	gcall *old_stmt = direct->call_stmt;
819	for (cgraph_edge *d = direct; d; d = next)
820	{
821	next = d->next_speculative_call_target ();
822	cgraph_edge *d2 = set_call_stmt (e: d, new_stmt, update_speculative: false);
823	gcc_assert (d2 == d);
824	n++;
825	}
826	gcc_checking_assert (indirect->num_speculative_call_targets_p () == n);
827	for (unsigned int i = 0; e->caller->iterate_reference (i, ref); i++)
828	if (ref->speculative && ref->stmt == old_stmt)
829	{
830	ref->stmt = new_stmt;
831	n--;
832	}
833
834	indirect = set_call_stmt (e: indirect, new_stmt, update_speculative: false);
835	return e_indirect ? indirect : direct;
836	}
837
838	if (new_direct_callee)
839	e = make_direct (edge: e, callee: new_direct_callee);
840
841	/* Only direct speculative edges go to call_site_hash. */
842	if (e->caller->call_site_hash
843	&& (!e->speculative || !e->indirect_unknown_callee)
844	/* It is possible that edge was previously speculative. In this case
845	we have different value in call stmt hash which needs preserving. */
846	&& e->caller->get_edge (call_stmt: e->call_stmt) == e)
847	e->caller->call_site_hash->remove_elt_with_hash
848	(comparable: e->call_stmt, hash: cgraph_edge_hasher::hash (call_stmt: e->call_stmt));
849
850	e->call_stmt = new_stmt;
851
852	function *fun = DECL_STRUCT_FUNCTION (e->caller->decl);
853	e->can_throw_external = stmt_can_throw_external (fun, new_stmt);
854	/* Update call stite hash. For speculative calls we only record the first
855	direct edge. */
856	if (e->caller->call_site_hash
857	&& (!e->speculative
858	|| (e->callee
859	&& (!e->prev_callee || !e->prev_callee->speculative
860	|| e->prev_callee->call_stmt != e->call_stmt))
861	|| (e->speculative && !e->callee)))
862	cgraph_add_edge_to_call_site_hash (e);
863	return e;
864	}
865
866	/* Allocate a cgraph_edge structure and fill it with data according to the
867	parameters of which only CALLEE can be NULL (when creating an indirect call
868	edge). CLONING_P should be set if properties that are copied from an
869	original edge should not be calculated. */
870
871	cgraph_edge *
872	symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
873	gcall *call_stmt, profile_count count,
874	bool indir_unknown_callee, bool cloning_p)
875	{
876	cgraph_edge *edge;
877
878	/* LTO does not actually have access to the call_stmt since these
879	have not been loaded yet. */
880	if (call_stmt)
881	{
882	/* This is a rather expensive check possibly triggering
883	construction of call stmt hashtable. */
884	cgraph_edge *e;
885	gcc_checking_assert (!(e = caller->get_edge (call_stmt))
886	|| e->speculative);
887
888	gcc_assert (is_gimple_call (call_stmt));
889	}
890
891	edge = ggc_alloc<cgraph_edge> ();
892	edge->m_summary_id = -1;
893	edges_count++;
894
895	gcc_assert (++edges_max_uid != 0);
896	edge->m_uid = edges_max_uid;
897	edge->aux = NULL;
898	edge->caller = caller;
899	edge->callee = callee;
900	edge->prev_caller = NULL;
901	edge->next_caller = NULL;
902	edge->prev_callee = NULL;
903	edge->next_callee = NULL;
904	edge->lto_stmt_uid = 0;
905	edge->speculative_id = 0;
906
907	edge->count = count;
908	edge->call_stmt = call_stmt;
909	edge->indirect_info = NULL;
910	edge->indirect_inlining_edge = 0;
911	edge->speculative = false;
912	edge->indirect_unknown_callee = indir_unknown_callee;
913	if (call_stmt && caller->call_site_hash)
914	cgraph_add_edge_to_call_site_hash (e: edge);
915
916	if (cloning_p)
917	return edge;
918
919	edge->can_throw_external
920	= call_stmt ? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller->decl),
921	call_stmt) : false;
922	edge->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
923	edge->call_stmt_cannot_inline_p = false;
924
925	if (opt_for_fn (edge->caller->decl, flag_devirtualize)
926	&& call_stmt && DECL_STRUCT_FUNCTION (caller->decl))
927	edge->in_polymorphic_cdtor
928	= decl_maybe_in_construction_p (NULL, NULL, call_stmt,
929	caller->decl);
930	else
931	edge->in_polymorphic_cdtor = caller->thunk;
932	if (callee)
933	caller->calls_declare_variant_alt |= callee->declare_variant_alt;
934
935	if (callee && symtab->state != LTO_STREAMING
936	&& edge->callee->comdat_local_p ())
937	edge->caller->calls_comdat_local = true;
938
939	return edge;
940	}
941
942	/* Create edge from a given function to CALLEE in the cgraph. CLONING_P should
943	be set if properties that are copied from an original edge should not be
944	calculated. */
945
946	cgraph_edge *
947	cgraph_node::create_edge (cgraph_node *callee,
948	gcall *call_stmt, profile_count count, bool cloning_p)
949	{
950	cgraph_edge *edge = symtab->create_edge (caller: this, callee, call_stmt, count,
951	indir_unknown_callee: false, cloning_p);
952
953	if (!cloning_p)
954	initialize_inline_failed (edge);
955
956	edge->next_caller = callee->callers;
957	if (callee->callers)
958	callee->callers->prev_caller = edge;
959	edge->next_callee = callees;
960	if (callees)
961	callees->prev_callee = edge;
962	callees = edge;
963	callee->callers = edge;
964
965	return edge;
966	}
967
968	/* Allocate cgraph_indirect_call_info and set its fields to default values. */
969
970	cgraph_indirect_call_info *
971	cgraph_allocate_init_indirect_info (void)
972	{
973	cgraph_indirect_call_info *ii;
974
975	ii = ggc_cleared_alloc<cgraph_indirect_call_info> ();
976	ii->param_index = -1;
977	return ii;
978	}
979
980	/* Create an indirect edge with a yet-undetermined callee where the call
981	statement destination is a formal parameter of the caller with index
982	PARAM_INDEX. CLONING_P should be set if properties that are copied from an
983	original edge should not be calculated and indirect_info structure should
984	not be calculated. */
985
986	cgraph_edge *
987	cgraph_node::create_indirect_edge (gcall *call_stmt, int ecf_flags,
988	profile_count count,
989	bool cloning_p)
990	{
991	cgraph_edge *edge = symtab->create_edge (caller: this, NULL, call_stmt, count, indir_unknown_callee: true,
992	cloning_p);
993	tree target;
994
995	if (!cloning_p)
996	initialize_inline_failed (edge);
997
998	edge->indirect_info = cgraph_allocate_init_indirect_info ();
999	edge->indirect_info->ecf_flags = ecf_flags;
1000	edge->indirect_info->vptr_changed = true;
1001
1002	/* Record polymorphic call info. */
1003	if (!cloning_p
1004	&& call_stmt
1005	&& (target = gimple_call_fn (gs: call_stmt))
1006	&& virtual_method_call_p (target))
1007	{
1008	ipa_polymorphic_call_context context (decl, target, call_stmt);
1009
1010	/* Only record types can have virtual calls. */
1011	edge->indirect_info->polymorphic = true;
1012	edge->indirect_info->param_index = -1;
1013	edge->indirect_info->otr_token
1014	= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target));
1015	edge->indirect_info->otr_type = obj_type_ref_class (ref: target);
1016	gcc_assert (TREE_CODE (edge->indirect_info->otr_type) == RECORD_TYPE);
1017	edge->indirect_info->context = context;
1018	}
1019
1020	edge->next_callee = indirect_calls;
1021	if (indirect_calls)
1022	indirect_calls->prev_callee = edge;
1023	indirect_calls = edge;
1024
1025	return edge;
1026	}
1027
1028	/* Remove the edge from the list of the callees of the caller. */
1029
1030	void
1031	cgraph_edge::remove_caller (void)
1032	{
1033	if (prev_callee)
1034	prev_callee->next_callee = next_callee;
1035	if (next_callee)
1036	next_callee->prev_callee = prev_callee;
1037	if (!prev_callee)
1038	{
1039	if (indirect_unknown_callee)
1040	caller->indirect_calls = next_callee;
1041	else
1042	caller->callees = next_callee;
1043	}
1044	if (caller->call_site_hash
1045	&& this == caller->get_edge (call_stmt))
1046	caller->call_site_hash->remove_elt_with_hash
1047	(comparable: call_stmt, hash: cgraph_edge_hasher::hash (call_stmt));
1048	}
1049
1050	/* Put the edge onto the free list. */
1051
1052	void
1053	symbol_table::free_edge (cgraph_edge *e)
1054	{
1055	edges_count--;
1056	if (e->m_summary_id != -1)
1057	edge_released_summary_ids.safe_push (obj: e->m_summary_id);
1058
1059	if (e->indirect_info)
1060	ggc_free (e->indirect_info);
1061	ggc_free (e);
1062	}
1063
1064	/* Remove the edge in the cgraph. */
1065
1066	void
1067	cgraph_edge::remove (cgraph_edge *edge)
1068	{
1069	/* Call all edge removal hooks. */
1070	symtab->call_edge_removal_hooks (e: edge);
1071
1072	if (!edge->indirect_unknown_callee)
1073	/* Remove from callers list of the callee. */
1074	edge->remove_callee ();
1075
1076	/* Remove from callees list of the callers. */
1077	edge->remove_caller ();
1078
1079	/* Put the edge onto the free list. */
1080	symtab->free_edge (e: edge);
1081	}
1082
1083	/* Turn edge into speculative call calling N2. Update
1084	the profile so the direct call is taken COUNT times
1085	with FREQUENCY.
1086
1087	At clone materialization time, the indirect call E will
1088	be expanded as:
1089
1090	if (call_dest == N2)
1091	n2 ();
1092	else
1093	call call_dest
1094
1095	At this time the function just creates the direct call,
1096	the reference representing the if conditional and attaches
1097	them all to the original indirect call statement.
1098
1099	speculative_id is used to link direct calls with their corresponding
1100	IPA_REF_ADDR references when representing speculative calls.
1101
1102	Return direct edge created. */
1103
1104	cgraph_edge *
1105	cgraph_edge::make_speculative (cgraph_node *n2, profile_count direct_count,
1106	unsigned int speculative_id)
1107	{
1108	cgraph_node *n = caller;
1109	ipa_ref *ref = NULL;
1110	cgraph_edge *e2;
1111
1112	if (dump_file)
1113	fprintf (stream: dump_file, format: "Indirect call -> speculative call %s => %s\n",
1114	n->dump_name (), n2->dump_name ());
1115	speculative = true;
1116	e2 = n->create_edge (callee: n2, call_stmt, count: direct_count);
1117	initialize_inline_failed (e2);
1118	e2->speculative = true;
1119	if (TREE_NOTHROW (n2->decl))
1120	e2->can_throw_external = false;
1121	else
1122	e2->can_throw_external = can_throw_external;
1123	e2->lto_stmt_uid = lto_stmt_uid;
1124	e2->speculative_id = speculative_id;
1125	e2->in_polymorphic_cdtor = in_polymorphic_cdtor;
1126	indirect_info->num_speculative_call_targets++;
1127	count -= e2->count;
1128	symtab->call_edge_duplication_hooks (cs1: this, cs2: e2);
1129	ref = n->create_reference (referred_node: n2, use_type: IPA_REF_ADDR, stmt: call_stmt);
1130	ref->lto_stmt_uid = lto_stmt_uid;
1131	ref->speculative_id = speculative_id;
1132	ref->speculative = speculative;
1133	n2->mark_address_taken ();
1134	return e2;
1135	}
1136
1137	/* Speculative call consists of an indirect edge and one or more
1138	direct edge+ref pairs.
1139
1140	Given an edge which is part of speculative call, return the first
1141	direct call edge in the speculative call sequence. */
1142
1143	cgraph_edge *
1144	cgraph_edge::first_speculative_call_target ()
1145	{
1146	cgraph_edge *e = this;
1147
1148	gcc_checking_assert (e->speculative);
1149	if (e->callee)
1150	{
1151	while (e->prev_callee && e->prev_callee->speculative
1152	&& e->prev_callee->call_stmt == e->call_stmt
1153	&& e->prev_callee->lto_stmt_uid == e->lto_stmt_uid)
1154	e = e->prev_callee;
1155	return e;
1156	}
1157	/* Call stmt site hash always points to the first target of the
1158	speculative call sequence. */
1159	if (e->call_stmt)
1160	return e->caller->get_edge (call_stmt: e->call_stmt);
1161	for (cgraph_edge *e2 = e->caller->callees; true; e2 = e2->next_callee)
1162	if (e2->speculative
1163	&& e->call_stmt == e2->call_stmt
1164	&& e->lto_stmt_uid == e2->lto_stmt_uid)
1165	return e2;
1166	}
1167
1168	/* We always maintain first direct edge in the call site hash, if one
1169	exists. E is going to be removed. See if it is first one and update
1170	hash accordingly. INDIRECT is the indirect edge of speculative call.
1171	We assume that INDIRECT->num_speculative_call_targets_p () is already
1172	updated for removal of E. */
1173	static void
1174	update_call_stmt_hash_for_removing_direct_edge (cgraph_edge *e,
1175	cgraph_edge *indirect)
1176	{
1177	if (e->caller->call_site_hash)
1178	{
1179	if (e->caller->get_edge (call_stmt: e->call_stmt) != e)
1180	;
1181	else if (!indirect->num_speculative_call_targets_p ())
1182	cgraph_update_edge_in_call_site_hash (e: indirect);
1183	else
1184	{
1185	gcc_checking_assert (e->next_callee && e->next_callee->speculative
1186	&& e->next_callee->call_stmt == e->call_stmt);
1187	cgraph_update_edge_in_call_site_hash (e: e->next_callee);
1188	}
1189	}
1190	}
1191
1192	/* Speculative call EDGE turned out to be direct call to CALLEE_DECL. Remove
1193	the speculative call sequence and return edge representing the call, the
1194	original EDGE can be removed and deallocated. Return the edge that now
1195	represents the call.
1196
1197	For "speculative" indirect call that contains multiple "speculative"
1198	targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
1199	decrease the count and only remove current direct edge.
1200
1201	If no speculative direct call left to the speculative indirect call, remove
1202	the speculative of both the indirect call and corresponding direct edge.
1203
1204	It is up to caller to iteratively resolve each "speculative" direct call and
1205	redirect the call as appropriate. */
1206
1207	cgraph_edge *
1208	cgraph_edge::resolve_speculation (cgraph_edge *edge, tree callee_decl)
1209	{
1210	cgraph_edge *e2;
1211	ipa_ref *ref;
1212
1213	gcc_assert (edge->speculative && (!callee_decl || edge->callee));
1214	if (!edge->callee)
1215	e2 = edge->first_speculative_call_target ();
1216	else
1217	e2 = edge;
1218	ref = e2->speculative_call_target_ref ();
1219	edge = edge->speculative_call_indirect_edge ();
1220	if (!callee_decl
1221	|| !ref->referred->semantically_equivalent_p
1222	(target: symtab_node::get (decl: callee_decl)))
1223	{
1224	if (dump_file)
1225	{
1226	if (callee_decl)
1227	{
1228	fprintf (stream: dump_file, format: "Speculative indirect call %s => %s has "
1229	"turned out to have contradicting known target ",
1230	edge->caller->dump_name (),
1231	e2->callee->dump_name ());
1232	print_generic_expr (dump_file, callee_decl);
1233	fprintf (stream: dump_file, format: "\n");
1234	}
1235	else
1236	{
1237	fprintf (stream: dump_file, format: "Removing speculative call %s => %s\n",
1238	edge->caller->dump_name (),
1239	e2->callee->dump_name ());
1240	}
1241	}
1242	}
1243	else
1244	{
1245	cgraph_edge *tmp = edge;
1246	if (dump_file)
1247	fprintf (stream: dump_file, format: "Speculative call turned into direct call.\n");
1248	edge = e2;
1249	e2 = tmp;
1250	/* FIXME: If EDGE is inlined, we should scale up the frequencies
1251	and counts in the functions inlined through it. */
1252	}
1253	edge->count += e2->count;
1254	if (edge->num_speculative_call_targets_p ())
1255	{
1256	/* The indirect edge has multiple speculative targets, don't remove
1257	speculative until all related direct edges are resolved. */
1258	edge->indirect_info->num_speculative_call_targets--;
1259	if (!edge->indirect_info->num_speculative_call_targets)
1260	edge->speculative = false;
1261	}
1262	else
1263	edge->speculative = false;
1264	e2->speculative = false;
1265	update_call_stmt_hash_for_removing_direct_edge (e: e2, indirect: edge);
1266	ref->remove_reference ();
1267	if (e2->indirect_unknown_callee || e2->inline_failed)
1268	remove (edge: e2);
1269	else
1270	e2->callee->remove_symbol_and_inline_clones ();
1271	return edge;
1272	}
1273
1274	/* Return edge corresponding to speculative call to a given target.
1275	NULL if speculative call does not have one. */
1276
1277	cgraph_edge *
1278	cgraph_edge::speculative_call_for_target (cgraph_node *target)
1279	{
1280	for (cgraph_edge *direct = first_speculative_call_target ();
1281	direct;
1282	direct = direct->next_speculative_call_target ())
1283	if (direct->speculative_call_target_ref ()
1284	->referred->semantically_equivalent_p (target))
1285	return direct;
1286	return NULL;
1287	}
1288
1289	/* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
1290	leading to CALLEE. Speculations can be resolved in the process and EDGE can
1291	be removed and deallocated. Return the edge that now represents the
1292	call. */
1293
1294	cgraph_edge *
1295	cgraph_edge::make_direct (cgraph_edge *edge, cgraph_node *callee)
1296	{
1297	gcc_assert (edge->indirect_unknown_callee || edge->speculative);
1298
1299	/* If we are redirecting speculative call, make it non-speculative. */
1300	if (edge->speculative)
1301	{
1302	cgraph_edge *found = NULL;
1303	cgraph_edge *direct, *next;
1304
1305	edge = edge->speculative_call_indirect_edge ();
1306
1307	/* Look all speculative targets and remove all but one corresponding
1308	to callee (if it exists). */
1309	for (direct = edge->first_speculative_call_target ();
1310	direct;
1311	direct = next)
1312	{
1313	next = direct->next_speculative_call_target ();
1314
1315	/* Compare ref not direct->callee. Direct edge is possibly
1316	inlined or redirected. */
1317	if (!direct->speculative_call_target_ref ()
1318	->referred->semantically_equivalent_p (target: callee))
1319	edge = direct->resolve_speculation (edge: direct, NULL);
1320	else
1321	{
1322	gcc_checking_assert (!found);
1323	found = direct;
1324	}
1325	}
1326
1327	/* On successful speculation just remove the indirect edge and
1328	return the pre existing direct edge.
1329	It is important to not remove it and redirect because the direct
1330	edge may be inlined or redirected. */
1331	if (found)
1332	{
1333	cgraph_edge *e2 = resolve_speculation (edge: found, callee_decl: callee->decl);
1334	gcc_checking_assert (!found->speculative && e2 == found);
1335	return found;
1336	}
1337	gcc_checking_assert (!edge->speculative);
1338	}
1339
1340	edge->indirect_unknown_callee = 0;
1341	ggc_free (edge->indirect_info);
1342	edge->indirect_info = NULL;
1343
1344	/* Get the edge out of the indirect edge list. */
1345	if (edge->prev_callee)
1346	edge->prev_callee->next_callee = edge->next_callee;
1347	if (edge->next_callee)
1348	edge->next_callee->prev_callee = edge->prev_callee;
1349	if (!edge->prev_callee)
1350	edge->caller->indirect_calls = edge->next_callee;
1351
1352	/* Put it into the normal callee list */
1353	edge->prev_callee = NULL;
1354	edge->next_callee = edge->caller->callees;
1355	if (edge->caller->callees)
1356	edge->caller->callees->prev_callee = edge;
1357	edge->caller->callees = edge;
1358
1359	/* Insert to callers list of the new callee. */
1360	edge->set_callee (callee);
1361
1362	/* We need to re-determine the inlining status of the edge. */
1363	initialize_inline_failed (edge);
1364	return edge;
1365	}
1366
1367	/* Redirect callee of the edge to N. The function does not update underlying
1368	call expression. */
1369
1370	void
1371	cgraph_edge::redirect_callee (cgraph_node *n)
1372	{
1373	bool loc = callee->comdat_local_p ();
1374	/* Remove from callers list of the current callee. */
1375	remove_callee ();
1376
1377	/* Insert to callers list of the new callee. */
1378	set_callee (n);
1379
1380	if (!inline_failed)
1381	return;
1382	if (!loc && n->comdat_local_p ())
1383	{
1384	cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
1385	to->calls_comdat_local = true;
1386	}
1387	else if (loc && !n->comdat_local_p ())
1388	{
1389	cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
1390	gcc_checking_assert (to->calls_comdat_local);
1391	to->calls_comdat_local = to->check_calls_comdat_local_p ();
1392	}
1393	}
1394
1395	/* If necessary, change the function declaration in the call statement
1396	associated with E so that it corresponds to the edge callee. Speculations
1397	can be resolved in the process and EDGE can be removed and deallocated.
1398
1399	The edge could be one of speculative direct call generated from speculative
1400	indirect call. In this circumstance, decrease the speculative targets
1401	count (i.e. num_speculative_call_targets) and redirect call stmt to the
1402	corresponding i-th target. If no speculative direct call left to the
1403	speculative indirect call, remove "speculative" of the indirect call and
1404	also redirect stmt to it's final direct target.
1405
1406	It is up to caller to iteratively transform each "speculative"
1407	direct call as appropriate. */
1408
1409	gimple *
1410	cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge *e)
1411	{
1412	tree decl = gimple_call_fndecl (gs: e->call_stmt);
1413	gcall *new_stmt;
1414
1415	if (e->speculative)
1416	{
1417	/* If there already is an direct call (i.e. as a result of inliner's
1418	substitution), forget about speculating. */
1419	if (decl)
1420	e = make_direct (edge: e->speculative_call_indirect_edge (),
1421	callee: cgraph_node::get (decl));
1422	else
1423	{
1424	/* Be sure we redirect all speculative targets before poking
1425	about indirect edge. */
1426	gcc_checking_assert (e->callee);
1427	cgraph_edge *indirect = e->speculative_call_indirect_edge ();
1428	gcall *new_stmt;
1429	ipa_ref *ref;
1430
1431	/* Expand speculation into GIMPLE code. */
1432	if (dump_file)
1433	{
1434	fprintf (stream: dump_file,
1435	format: "Expanding speculative call of %s -> %s count: ",
1436	e->caller->dump_name (),
1437	e->callee->dump_name ());
1438	e->count.dump (f: dump_file);
1439	fprintf (stream: dump_file, format: "\n");
1440	}
1441	push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
1442
1443	profile_count all = indirect->count;
1444	for (cgraph_edge *e2 = e->first_speculative_call_target ();
1445	e2;
1446	e2 = e2->next_speculative_call_target ())
1447	all = all + e2->count;
1448	profile_probability prob = e->count.probability_in (overall: all);
1449	if (!prob.initialized_p ())
1450	prob = profile_probability::even ();
1451	ref = e->speculative_call_target_ref ();
1452	new_stmt = gimple_ic (e->call_stmt,
1453	dyn_cast<cgraph_node *> (p: ref->referred),
1454	prob);
1455	e->speculative = false;
1456	if (indirect->num_speculative_call_targets_p ())
1457	{
1458	/* The indirect edge has multiple speculative targets, don't
1459	remove speculative until all related direct edges are
1460	redirected. */
1461	indirect->indirect_info->num_speculative_call_targets--;
1462	if (!indirect->indirect_info->num_speculative_call_targets)
1463	indirect->speculative = false;
1464	}
1465	else
1466	indirect->speculative = false;
1467	/* Indirect edges are not both in the call site hash.
1468	get it updated. */
1469	update_call_stmt_hash_for_removing_direct_edge (e, indirect);
1470	cgraph_edge::set_call_stmt (e, new_stmt, update_speculative: false);
1471	e->count = gimple_bb (g: e->call_stmt)->count;
1472
1473	/* Once we are done with expanding the sequence, update also indirect
1474	call probability. Until then the basic block accounts for the
1475	sum of indirect edge and all non-expanded speculations. */
1476	if (!indirect->speculative)
1477	indirect->count = gimple_bb (g: indirect->call_stmt)->count;
1478	ref->speculative = false;
1479	ref->stmt = NULL;
1480	pop_cfun ();
1481	/* Continue redirecting E to proper target. */
1482	}
1483	}
1484
1485
1486	if (e->indirect_unknown_callee
1487	|| decl == e->callee->decl)
1488	return e->call_stmt;
1489
1490	if (decl && ipa_saved_clone_sources)
1491	{
1492	tree *p = ipa_saved_clone_sources->get (node: e->callee);
1493	if (p && decl == *p)
1494	{
1495	gimple_call_set_fndecl (gs: e->call_stmt, decl: e->callee->decl);
1496	return e->call_stmt;
1497	}
1498	}
1499	if (flag_checking && decl)
1500	{
1501	if (cgraph_node *node = cgraph_node::get (decl))
1502	{
1503	clone_info *info = clone_info::get (node);
1504	gcc_assert (!info || !info->param_adjustments);
1505	}
1506	}
1507
1508	clone_info *callee_info = clone_info::get (node: e->callee);
1509	if (symtab->dump_file)
1510	{
1511	fprintf (stream: symtab->dump_file, format: "updating call of %s -> %s: ",
1512	e->caller->dump_name (), e->callee->dump_name ());
1513	print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1514	if (callee_info && callee_info->param_adjustments)
1515	callee_info->param_adjustments->dump (f: symtab->dump_file);
1516	}
1517
1518	if (ipa_param_adjustments *padjs
1519	= callee_info ? callee_info->param_adjustments : NULL)
1520	{
1521	/* We need to defer cleaning EH info on the new statement to
1522	fixup-cfg. We may not have dominator information at this point
1523	and thus would end up with unreachable blocks and have no way
1524	to communicate that we need to run CFG cleanup then. */
1525	int lp_nr = lookup_stmt_eh_lp (e->call_stmt);
1526	if (lp_nr != 0)
1527	remove_stmt_from_eh_lp (e->call_stmt);
1528
1529	tree old_fntype = gimple_call_fntype (gs: e->call_stmt);
1530	new_stmt = padjs->modify_call (cs: e, update_references: false);
1531	cgraph_node *origin = e->callee;
1532	while (origin->clone_of)
1533	origin = origin->clone_of;
1534
1535	if ((origin->former_clone_of
1536	&& old_fntype == TREE_TYPE (origin->former_clone_of))
1537	|| old_fntype == TREE_TYPE (origin->decl))
1538	gimple_call_set_fntype (call_stmt: new_stmt, TREE_TYPE (e->callee->decl));
1539	else
1540	{
1541	tree new_fntype = padjs->build_new_function_type (old_type: old_fntype, type_is_original_p: true);
1542	gimple_call_set_fntype (call_stmt: new_stmt, fntype: new_fntype);
1543	}
1544
1545	if (lp_nr != 0)
1546	add_stmt_to_eh_lp (new_stmt, lp_nr);
1547	}
1548	else
1549	{
1550	if (flag_checking
1551	&& !fndecl_built_in_p (node: e->callee->decl, name1: BUILT_IN_UNREACHABLE,
1552	names: BUILT_IN_UNREACHABLE_TRAP))
1553	ipa_verify_edge_has_no_modifications (cs: e);
1554	new_stmt = e->call_stmt;
1555	gimple_call_set_fndecl (gs: new_stmt, decl: e->callee->decl);
1556	update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), s: new_stmt);
1557	}
1558
1559	/* If changing the call to __cxa_pure_virtual or similar noreturn function,
1560	adjust gimple_call_fntype too. */
1561	if (gimple_call_noreturn_p (s: new_stmt)
1562	&& VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e->callee->decl)))
1563	&& TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl))
1564	&& (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl)))
1565	== void_type_node))
1566	gimple_call_set_fntype (call_stmt: new_stmt, TREE_TYPE (e->callee->decl));
1567
1568	/* If the call becomes noreturn, remove the LHS if possible. */
1569	tree lhs = gimple_call_lhs (gs: new_stmt);
1570	if (lhs
1571	&& gimple_call_noreturn_p (s: new_stmt)
1572	&& (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt)))
1573	|| should_remove_lhs_p (lhs)))
1574	{
1575	gimple_call_set_lhs (gs: new_stmt, NULL_TREE);
1576	/* We need to fix up the SSA name to avoid checking errors. */
1577	if (TREE_CODE (lhs) == SSA_NAME)
1578	{
1579	tree var = create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e->caller->decl),
1580	TREE_TYPE (lhs), NULL);
1581	SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs, var);
1582	SSA_NAME_DEF_STMT (lhs) = gimple_build_nop ();
1583	set_ssa_default_def (DECL_STRUCT_FUNCTION (e->caller->decl),
1584	var, lhs);
1585	}
1586	update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), s: new_stmt);
1587	}
1588
1589	/* If new callee has no static chain, remove it. */
1590	if (gimple_call_chain (gs: new_stmt) && !DECL_STATIC_CHAIN (e->callee->decl))
1591	{
1592	gimple_call_set_chain (call_stmt: new_stmt, NULL);
1593	update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), s: new_stmt);
1594	}
1595
1596	maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e->caller->decl),
1597	new_stmt);
1598
1599	e->caller->set_call_stmt_including_clones (old_stmt: e->call_stmt, new_stmt, update_speculative: false);
1600
1601	if (symtab->dump_file)
1602	{
1603	fprintf (stream: symtab->dump_file, format: " updated to:");
1604	print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1605	}
1606	return new_stmt;
1607	}
1608
1609	/* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1610	OLD_STMT changed into NEW_STMT. OLD_CALL is gimple_call_fndecl
1611	of OLD_STMT if it was previously call statement.
1612	If NEW_STMT is NULL, the call has been dropped without any
1613	replacement. */
1614
1615	static void
1616	cgraph_update_edges_for_call_stmt_node (cgraph_node *node,
1617	gimple *old_stmt, tree old_call,
1618	gimple *new_stmt)
1619	{
1620	tree new_call = (new_stmt && is_gimple_call (gs: new_stmt))
1621	? gimple_call_fndecl (gs: new_stmt) : 0;
1622
1623	/* We are seeing indirect calls, then there is nothing to update. */
1624	if (!new_call && !old_call)
1625	return;
1626	/* See if we turned indirect call into direct call or folded call to one builtin
1627	into different builtin. */
1628	if (old_call != new_call)
1629	{
1630	cgraph_edge *e = node->get_edge (call_stmt: old_stmt);
1631	cgraph_edge *ne = NULL;
1632	profile_count count;
1633
1634	if (e)
1635	{
1636	/* Keep calls marked as dead dead. */
1637	if (new_stmt && is_gimple_call (gs: new_stmt) && e->callee
1638	&& fndecl_built_in_p (node: e->callee->decl, name1: BUILT_IN_UNREACHABLE,
1639	names: BUILT_IN_UNREACHABLE_TRAP))
1640	{
1641	cgraph_edge::set_call_stmt (e: node->get_edge (call_stmt: old_stmt),
1642	new_stmt: as_a <gcall *> (p: new_stmt));
1643	return;
1644	}
1645	/* See if the edge is already there and has the correct callee. It
1646	might be so because of indirect inlining has already updated
1647	it. We also might've cloned and redirected the edge. */
1648	if (new_call && e->callee)
1649	{
1650	cgraph_node *callee = e->callee;
1651	while (callee)
1652	{
1653	if (callee->decl == new_call
1654	|| callee->former_clone_of == new_call)
1655	{
1656	cgraph_edge::set_call_stmt (e, new_stmt: as_a <gcall *> (p: new_stmt));
1657	return;
1658	}
1659	callee = callee->clone_of;
1660	}
1661	}
1662
1663	/* Otherwise remove edge and create new one; we can't simply redirect
1664	since function has changed, so inline plan and other information
1665	attached to edge is invalid. */
1666	count = e->count;
1667	if (e->indirect_unknown_callee || e->inline_failed)
1668	cgraph_edge::remove (edge: e);
1669	else
1670	e->callee->remove_symbol_and_inline_clones ();
1671	}
1672	else if (new_call)
1673	{
1674	/* We are seeing new direct call; compute profile info based on BB. */
1675	basic_block bb = gimple_bb (g: new_stmt);
1676	count = bb->count;
1677	}
1678
1679	if (new_call)
1680	{
1681	ne = node->create_edge (callee: cgraph_node::get_create (decl: new_call),
1682	call_stmt: as_a <gcall *> (p: new_stmt), count);
1683	gcc_assert (ne->inline_failed);
1684	}
1685	}
1686	/* We only updated the call stmt; update pointer in cgraph edge.. */
1687	else if (old_stmt != new_stmt)
1688	cgraph_edge::set_call_stmt (e: node->get_edge (call_stmt: old_stmt),
1689	new_stmt: as_a <gcall *> (p: new_stmt));
1690	}
1691
1692	/* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1693	OLD_STMT changed into NEW_STMT. OLD_DECL is gimple_call_fndecl
1694	of OLD_STMT before it was updated (updating can happen inplace). */
1695
1696	void
1697	cgraph_update_edges_for_call_stmt (gimple *old_stmt, tree old_decl,
1698	gimple *new_stmt)
1699	{
1700	cgraph_node *orig = cgraph_node::get (cfun->decl);
1701	cgraph_node *node;
1702
1703	gcc_checking_assert (orig);
1704	cgraph_update_edges_for_call_stmt_node (node: orig, old_stmt, old_call: old_decl, new_stmt);
1705	if (orig->clones)
1706	for (node = orig->clones; node != orig;)
1707	{
1708	cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_call: old_decl,
1709	new_stmt);
1710	if (node->clones)
1711	node = node->clones;
1712	else if (node->next_sibling_clone)
1713	node = node->next_sibling_clone;
1714	else
1715	{
1716	while (node != orig && !node->next_sibling_clone)
1717	node = node->clone_of;
1718	if (node != orig)
1719	node = node->next_sibling_clone;
1720	}
1721	}
1722	}
1723
1724
1725	/* Remove all callees from the node. */
1726
1727	void
1728	cgraph_node::remove_callees (void)
1729	{
1730	cgraph_edge *e, *f;
1731
1732	calls_comdat_local = false;
1733
1734	/* It is sufficient to remove the edges from the lists of callers of
1735	the callees. The callee list of the node can be zapped with one
1736	assignment. */
1737	for (e = callees; e; e = f)
1738	{
1739	f = e->next_callee;
1740	symtab->call_edge_removal_hooks (e);
1741	if (!e->indirect_unknown_callee)
1742	e->remove_callee ();
1743	symtab->free_edge (e);
1744	}
1745	for (e = indirect_calls; e; e = f)
1746	{
1747	f = e->next_callee;
1748	symtab->call_edge_removal_hooks (e);
1749	if (!e->indirect_unknown_callee)
1750	e->remove_callee ();
1751	symtab->free_edge (e);
1752	}
1753	indirect_calls = NULL;
1754	callees = NULL;
1755	if (call_site_hash)
1756	{
1757	call_site_hash->empty ();
1758	call_site_hash = NULL;
1759	}
1760	}
1761
1762	/* Remove all callers from the node. */
1763
1764	void
1765	cgraph_node::remove_callers (void)
1766	{
1767	cgraph_edge *e, *f;
1768
1769	/* It is sufficient to remove the edges from the lists of callees of
1770	the callers. The caller list of the node can be zapped with one
1771	assignment. */
1772	for (e = callers; e; e = f)
1773	{
1774	f = e->next_caller;
1775	symtab->call_edge_removal_hooks (e);
1776	e->remove_caller ();
1777	symtab->free_edge (e);
1778	}
1779	callers = NULL;
1780	}
1781
1782	/* Helper function for cgraph_release_function_body and free_lang_data.
1783	It releases body from function DECL without having to inspect its
1784	possibly non-existent symtab node. */
1785
1786	void
1787	release_function_body (tree decl)
1788	{
1789	function *fn = DECL_STRUCT_FUNCTION (decl);
1790	if (fn)
1791	{
1792	if (fn->cfg
1793	&& loops_for_fn (fn))
1794	{
1795	fn->curr_properties &= ~PROP_loops;
1796	loop_optimizer_finalize (fn);
1797	}
1798	if (fn->gimple_df)
1799	{
1800	delete_tree_ssa (fn);
1801	fn->eh = NULL;
1802	}
1803	if (fn->cfg)
1804	{
1805	gcc_assert (!dom_info_available_p (fn, CDI_DOMINATORS));
1806	gcc_assert (!dom_info_available_p (fn, CDI_POST_DOMINATORS));
1807	delete_tree_cfg_annotations (fn);
1808	free_cfg (fn);
1809	fn->cfg = NULL;
1810	}
1811	if (fn->value_histograms)
1812	free_histograms (fn);
1813	gimple_set_body (decl, NULL);
1814	/* Struct function hangs a lot of data that would leak if we didn't
1815	removed all pointers to it. */
1816	ggc_free (fn);
1817	DECL_STRUCT_FUNCTION (decl) = NULL;
1818	}
1819	DECL_SAVED_TREE (decl) = NULL;
1820	}
1821
1822	/* Release memory used to represent body of function.
1823	Use this only for functions that are released before being translated to
1824	target code (i.e. RTL). Functions that are compiled to RTL and beyond
1825	are free'd in final.cc via free_after_compilation().
1826	KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */
1827
1828	void
1829	cgraph_node::release_body (bool keep_arguments)
1830	{
1831	ipa_transforms_to_apply.release ();
1832	if (!used_as_abstract_origin && symtab->state != PARSING)
1833	{
1834	DECL_RESULT (decl) = NULL;
1835
1836	if (!keep_arguments)
1837	DECL_ARGUMENTS (decl) = NULL;
1838	}
1839	/* If the node is abstract and needed, then do not clear
1840	DECL_INITIAL of its associated function declaration because it's
1841	needed to emit debug info later. */
1842	if (!used_as_abstract_origin && DECL_INITIAL (decl))
1843	DECL_INITIAL (decl) = error_mark_node;
1844	release_function_body (decl);
1845	if (lto_file_data)
1846	{
1847	lto_free_function_in_decl_state_for_node (this);
1848	lto_file_data = NULL;
1849	}
1850	if (flag_checking && clones)
1851	{
1852	/* It is invalid to release body before materializing clones except
1853	for thunks that don't really need a body. Verify also that we do
1854	not leak pointers to the call statements. */
1855	for (cgraph_node *node = clones; node;
1856	node = node->next_sibling_clone)
1857	gcc_assert (node->thunk && !node->callees->call_stmt);
1858	}
1859	remove_callees ();
1860	remove_all_references ();
1861	}
1862
1863	/* Remove function from symbol table. */
1864
1865	void
1866	cgraph_node::remove (void)
1867	{
1868	bool clone_info_set = false;
1869	clone_info *info, saved_info;
1870	if (symtab->ipa_clones_dump_file && symtab->cloned_nodes.contains (k: this))
1871	fprintf (stream: symtab->ipa_clones_dump_file,
1872	format: "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order,
1873	DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl),
1874	DECL_SOURCE_COLUMN (decl));
1875
1876	if ((info = clone_info::get (node: this)) != NULL)
1877	{
1878	saved_info = *info;
1879	clone_info_set = true;
1880	}
1881	symtab->call_cgraph_removal_hooks (node: this);
1882	remove_callers ();
1883	remove_callees ();
1884	ipa_transforms_to_apply.release ();
1885	delete_function_version (decl_v: function_version ());
1886
1887	/* Incremental inlining access removed nodes stored in the postorder list.
1888	*/
1889	force_output = false;
1890	forced_by_abi = false;
1891
1892	unregister (clone_info_set ? &saved_info : NULL);
1893	if (prev_sibling_clone)
1894	prev_sibling_clone->next_sibling_clone = next_sibling_clone;
1895	else if (clone_of)
1896	{
1897	clone_of->clones = next_sibling_clone;
1898	if (!clones)
1899	{
1900	bool need_body = false;
1901	for (cgraph_node *n = clone_of; n; n = n->clone_of)
1902	if (n->analyzed || n->clones)
1903	{
1904	need_body = true;
1905	break;
1906	}
1907	if (!need_body)
1908	clone_of->release_body ();
1909	}
1910	}
1911	if (next_sibling_clone)
1912	next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
1913	if (clones)
1914	{
1915	cgraph_node *n, *next;
1916
1917	if (clone_of)
1918	{
1919	for (n = clones; n->next_sibling_clone; n = n->next_sibling_clone)
1920	n->clone_of = clone_of;
1921	n->clone_of = clone_of;
1922	n->next_sibling_clone = clone_of->clones;
1923	if (clone_of->clones)
1924	clone_of->clones->prev_sibling_clone = n;
1925	clone_of->clones = clones;
1926	}
1927	else
1928	{
1929	/* We are removing node with clones. This makes clones inconsistent,
1930	but assume they will be removed subsequently and just keep clone
1931	tree intact. This can happen in unreachable function removal since
1932	we remove unreachable functions in random order, not by bottom-up
1933	walk of clone trees. */
1934	for (n = clones; n; n = next)
1935	{
1936	next = n->next_sibling_clone;
1937	n->next_sibling_clone = NULL;
1938	n->prev_sibling_clone = NULL;
1939	n->clone_of = NULL;
1940	}
1941	}
1942	}
1943
1944	/* While all the clones are removed after being proceeded, the function
1945	itself is kept in the cgraph even after it is compiled. Check whether
1946	we are done with this body and reclaim it proactively if this is the case.
1947	*/
1948	if (symtab->state != LTO_STREAMING)
1949	{
1950	cgraph_node *n = cgraph_node::get (decl);
1951	if (!n
1952	|| (!n->clones && !n->clone_of && !n->inlined_to
1953	&& ((symtab->global_info_ready || in_lto_p)
1954	&& (TREE_ASM_WRITTEN (n->decl)
1955	|| DECL_EXTERNAL (n->decl)
1956	|| !n->analyzed
1957	|| (!flag_wpa && n->in_other_partition)))))
1958	release_body ();
1959	}
1960	else
1961	{
1962	lto_free_function_in_decl_state_for_node (this);
1963	lto_file_data = NULL;
1964	}
1965
1966	decl = NULL;
1967	if (call_site_hash)
1968	{
1969	call_site_hash->empty ();
1970	call_site_hash = NULL;
1971	}
1972
1973	symtab->release_symbol (node: this);
1974	}
1975
1976	/* Likewise indicate that a node is having address taken. */
1977
1978	void
1979	cgraph_node::mark_address_taken (void)
1980	{
1981	/* Indirect inlining can figure out that all uses of the address are
1982	inlined. */
1983	if (inlined_to)
1984	{
1985	gcc_assert (cfun->after_inlining);
1986	gcc_assert (callers->indirect_inlining_edge);
1987	return;
1988	}
1989	/* FIXME: address_taken flag is used both as a shortcut for testing whether
1990	IPA_REF_ADDR reference exists (and thus it should be set on node
1991	representing alias we take address of) and as a test whether address
1992	of the object was taken (and thus it should be set on node alias is
1993	referring to). We should remove the first use and the remove the
1994	following set. */
1995	address_taken = 1;
1996	cgraph_node *node = ultimate_alias_target ();
1997	node->address_taken = 1;
1998	}
1999
2000	/* Return local info node for the compiled function. */
2001
2002	cgraph_node *
2003	cgraph_node::local_info_node (tree decl)
2004	{
2005	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
2006	cgraph_node *node = get (decl);
2007	if (!node)
2008	return NULL;
2009	return node->ultimate_alias_target ();
2010	}
2011
2012	/* Return RTL info for the compiled function. */
2013
2014	cgraph_rtl_info *
2015	cgraph_node::rtl_info (const_tree decl)
2016	{
2017	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
2018	cgraph_node *node = get (decl);
2019	if (!node)
2020	return NULL;
2021	enum availability avail;
2022	node = node->ultimate_alias_target (availability: &avail);
2023	if (decl != current_function_decl
2024	&& (avail < AVAIL_AVAILABLE
2025	|| (node->decl != current_function_decl
2026	&& !TREE_ASM_WRITTEN (node->decl))))
2027	return NULL;
2028	/* Allocate if it doesn't exist. */
2029	if (node->rtl == NULL)
2030	{
2031	node->rtl = ggc_cleared_alloc<cgraph_rtl_info> ();
2032	SET_HARD_REG_SET (node->rtl->function_used_regs);
2033	}
2034	return node->rtl;
2035	}
2036
2037	/* Return a string describing the failure REASON. */
2038
2039	const char*
2040	cgraph_inline_failed_string (cgraph_inline_failed_t reason)
2041	{
2042	#undef DEFCIFCODE
2043	#define DEFCIFCODE(code, type, string) string,
2044
2045	static const char *cif_string_table[CIF_N_REASONS] = {
2046	#include "cif-code.def"
2047	};
2048
2049	/* Signedness of an enum type is implementation defined, so cast it
2050	to unsigned before testing. */
2051	gcc_assert ((unsigned) reason < CIF_N_REASONS);
2052	return cif_string_table[reason];
2053	}
2054
2055	/* Return a type describing the failure REASON. */
2056
2057	cgraph_inline_failed_type_t
2058	cgraph_inline_failed_type (cgraph_inline_failed_t reason)
2059	{
2060	#undef DEFCIFCODE
2061	#define DEFCIFCODE(code, type, string) type,
2062
2063	static cgraph_inline_failed_type_t cif_type_table[CIF_N_REASONS] = {
2064	#include "cif-code.def"
2065	};
2066
2067	/* Signedness of an enum type is implementation defined, so cast it
2068	to unsigned before testing. */
2069	gcc_assert ((unsigned) reason < CIF_N_REASONS);
2070	return cif_type_table[reason];
2071	}
2072
2073	/* Names used to print out the availability enum. */
2074	const char * const cgraph_availability_names[] =
2075	{"unset", "not_available", "overwritable", "available", "local"};
2076
2077	/* Output flags of edge to a file F. */
2078
2079	void
2080	cgraph_edge::dump_edge_flags (FILE *f)
2081	{
2082	if (speculative)
2083	fprintf (stream: f, format: "(speculative) ");
2084	if (!inline_failed)
2085	fprintf (stream: f, format: "(inlined) ");
2086	if (call_stmt_cannot_inline_p)
2087	fprintf (stream: f, format: "(call_stmt_cannot_inline_p) ");
2088	if (indirect_inlining_edge)
2089	fprintf (stream: f, format: "(indirect_inlining) ");
2090	if (count.initialized_p ())
2091	{
2092	fprintf (stream: f, format: "(");
2093	count.dump (f);
2094	fprintf (stream: f, format: ",");
2095	fprintf (stream: f, format: "%.2f per call) ", sreal_frequency ().to_double ());
2096	}
2097	if (can_throw_external)
2098	fprintf (stream: f, format: "(can throw external) ");
2099	}
2100
2101	/* Dump edge to stderr. */
2102
2103	void
2104	cgraph_edge::debug (void)
2105	{
2106	fprintf (stderr, format: "%s -> %s ", caller->dump_asm_name (),
2107	callee == NULL ? "(null)" : callee->dump_asm_name ());
2108	dump_edge_flags (stderr);
2109	fprintf (stderr, format: "\n\n");
2110	caller->debug ();
2111	if (callee != NULL)
2112	callee->debug ();
2113	}
2114
2115	/* Dump call graph node to file F. */
2116
2117	void
2118	cgraph_node::dump (FILE *f)
2119	{
2120	cgraph_edge *edge;
2121
2122	dump_base (f);
2123
2124	if (inlined_to)
2125	fprintf (stream: f, format: " Function %s is inline copy in %s\n",
2126	dump_name (),
2127	inlined_to->dump_name ());
2128	if (clone_of)
2129	fprintf (stream: f, format: " Clone of %s\n", clone_of->dump_asm_name ());
2130	if (symtab->function_flags_ready)
2131	fprintf (stream: f, format: " Availability: %s\n",
2132	cgraph_availability_names [get_availability ()]);
2133
2134	if (profile_id)
2135	fprintf (stream: f, format: " Profile id: %i\n",
2136	profile_id);
2137	if (unit_id)
2138	fprintf (stream: f, format: " Unit id: %i\n",
2139	unit_id);
2140	cgraph_function_version_info *vi = function_version ();
2141	if (vi != NULL)
2142	{
2143	fprintf (stream: f, format: " Version info: ");
2144	if (vi->prev != NULL)
2145	{
2146	fprintf (stream: f, format: "prev: ");
2147	fprintf (stream: f, format: "%s ", vi->prev->this_node->dump_asm_name ());
2148	}
2149	if (vi->next != NULL)
2150	{
2151	fprintf (stream: f, format: "next: ");
2152	fprintf (stream: f, format: "%s ", vi->next->this_node->dump_asm_name ());
2153	}
2154	if (vi->dispatcher_resolver != NULL_TREE)
2155	fprintf (stream: f, format: "dispatcher: %s",
2156	lang_hooks.decl_printable_name (vi->dispatcher_resolver, 2));
2157
2158	fprintf (stream: f, format: "\n");
2159	}
2160	fprintf (stream: f, format: " Function flags:");
2161	if (count.initialized_p ())
2162	{
2163	fprintf (stream: f, format: " count:");
2164	count.dump (f);
2165	}
2166	if (tp_first_run > 0)
2167	fprintf (stream: f, format: " first_run:%" PRId64, (int64_t) tp_first_run);
2168	if (cgraph_node *origin = nested_function_origin (node: this))
2169	fprintf (stream: f, format: " nested in:%s", origin->dump_asm_name ());
2170	if (gimple_has_body_p (decl))
2171	fprintf (stream: f, format: " body");
2172	if (process)
2173	fprintf (stream: f, format: " process");
2174	if (local)
2175	fprintf (stream: f, format: " local");
2176	if (redefined_extern_inline)
2177	fprintf (stream: f, format: " redefined_extern_inline");
2178	if (only_called_at_startup)
2179	fprintf (stream: f, format: " only_called_at_startup");
2180	if (only_called_at_exit)
2181	fprintf (stream: f, format: " only_called_at_exit");
2182	if (tm_clone)
2183	fprintf (stream: f, format: " tm_clone");
2184	if (calls_comdat_local)
2185	fprintf (stream: f, format: " calls_comdat_local");
2186	if (icf_merged)
2187	fprintf (stream: f, format: " icf_merged");
2188	if (merged_comdat)
2189	fprintf (stream: f, format: " merged_comdat");
2190	if (merged_extern_inline)
2191	fprintf (stream: f, format: " merged_extern_inline");
2192	if (split_part)
2193	fprintf (stream: f, format: " split_part");
2194	if (indirect_call_target)
2195	fprintf (stream: f, format: " indirect_call_target");
2196	if (nonfreeing_fn)
2197	fprintf (stream: f, format: " nonfreeing_fn");
2198	if (DECL_STATIC_CONSTRUCTOR (decl))
2199	fprintf (stream: f,format: " static_constructor (priority:%i)", get_init_priority ());
2200	if (DECL_STATIC_DESTRUCTOR (decl))
2201	fprintf (stream: f,format: " static_destructor (priority:%i)", get_fini_priority ());
2202	if (frequency == NODE_FREQUENCY_HOT)
2203	fprintf (stream: f, format: " hot");
2204	if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2205	fprintf (stream: f, format: " unlikely_executed");
2206	if (frequency == NODE_FREQUENCY_EXECUTED_ONCE)
2207	fprintf (stream: f, format: " executed_once");
2208	if (opt_for_fn (decl, optimize_size))
2209	fprintf (stream: f, format: " optimize_size");
2210	if (parallelized_function)
2211	fprintf (stream: f, format: " parallelized_function");
2212	if (DECL_IS_MALLOC (decl))
2213	fprintf (stream: f, format: " decl_is_malloc");
2214	if (DECL_IS_OPERATOR_NEW_P (decl))
2215	fprintf (stream: f, format: " %soperator_new",
2216	DECL_IS_REPLACEABLE_OPERATOR (decl) ? "replaceable_" : "");
2217	if (DECL_IS_OPERATOR_DELETE_P (decl))
2218	fprintf (stream: f, format: " %soperator_delete",
2219	DECL_IS_REPLACEABLE_OPERATOR (decl) ? "replaceable_" : "");
2220
2221	if (DECL_STATIC_CHAIN (decl))
2222	fprintf (stream: f, format: " static_chain");
2223
2224	fprintf (stream: f, format: "\n");
2225
2226	if (thunk)
2227	{
2228	fprintf (stream: f, format: " Thunk");
2229	thunk_info::get (node: this)->dump (f);
2230	}
2231	else if (former_thunk_p ())
2232	{
2233	fprintf (stream: f, format: " Former thunk ");
2234	thunk_info::get (node: this)->dump (f);
2235	}
2236	else gcc_checking_assert (!thunk_info::get (this));
2237
2238	fprintf (stream: f, format: " Called by: ");
2239
2240	profile_count sum = profile_count::zero ();
2241	for (edge = callers; edge; edge = edge->next_caller)
2242	{
2243	fprintf (stream: f, format: "%s ", edge->caller->dump_asm_name ());
2244	edge->dump_edge_flags (f);
2245	if (edge->count.initialized_p ())
2246	sum += edge->count.ipa ();
2247	}
2248
2249	fprintf (stream: f, format: "\n Calls: ");
2250	for (edge = callees; edge; edge = edge->next_callee)
2251	{
2252	fprintf (stream: f, format: "%s ", edge->callee->dump_asm_name ());
2253	edge->dump_edge_flags (f);
2254	}
2255	fprintf (stream: f, format: "\n");
2256
2257	if (!body_removed && count.ipa ().initialized_p ())
2258	{
2259	bool ok = true;
2260	bool min = false;
2261	ipa_ref *ref;
2262
2263	FOR_EACH_ALIAS (this, ref)
2264	if (dyn_cast <cgraph_node *> (p: ref->referring)->count.initialized_p ())
2265	sum += dyn_cast <cgraph_node *> (p: ref->referring)->count.ipa ();
2266
2267	if (inlined_to
2268	|| (symtab->state < EXPANSION
2269	&& ultimate_alias_target () == this && only_called_directly_p ()))
2270	ok = !count.ipa ().differs_from_p (other: sum);
2271	else if (count.ipa () > profile_count::from_gcov_type (v: 100)
2272	&& count.ipa () < sum.apply_scale (num: 99, den: 100))
2273	ok = false, min = true;
2274	if (!ok)
2275	{
2276	fprintf (stream: f, format: " Invalid sum of caller counts ");
2277	sum.dump (f);
2278	if (min)
2279	fprintf (stream: f, format: ", should be at most ");
2280	else
2281	fprintf (stream: f, format: ", should be ");
2282	count.ipa ().dump (f);
2283	fprintf (stream: f, format: "\n");
2284	}
2285	}
2286
2287	for (edge = indirect_calls; edge; edge = edge->next_callee)
2288	{
2289	if (edge->indirect_info->polymorphic)
2290	{
2291	fprintf (stream: f, format: " Polymorphic indirect call of type ");
2292	print_generic_expr (f, edge->indirect_info->otr_type, TDF_SLIM);
2293	fprintf (stream: f, format: " token:%i", (int) edge->indirect_info->otr_token);
2294	}
2295	else
2296	fprintf (stream: f, format: " Indirect call");
2297	edge->dump_edge_flags (f);
2298	if (edge->indirect_info->param_index != -1)
2299	{
2300	fprintf (stream: f, format: "of param:%i ", edge->indirect_info->param_index);
2301	if (edge->indirect_info->agg_contents)
2302	fprintf (stream: f, format: "loaded from %s %s at offset %i ",
2303	edge->indirect_info->member_ptr ? "member ptr" : "aggregate",
2304	edge->indirect_info->by_ref ? "passed by reference":"",
2305	(int)edge->indirect_info->offset);
2306	if (edge->indirect_info->vptr_changed)
2307	fprintf (stream: f, format: "(vptr maybe changed) ");
2308	}
2309	fprintf (stream: f, format: "num speculative call targets: %i\n",
2310	edge->indirect_info->num_speculative_call_targets);
2311	if (edge->indirect_info->polymorphic)
2312	edge->indirect_info->context.dump (f);
2313	}
2314	}
2315
2316	/* Dump call graph node to file F in graphviz format. */
2317
2318	void
2319	cgraph_node::dump_graphviz (FILE *f)
2320	{
2321	cgraph_edge *edge;
2322
2323	for (edge = callees; edge; edge = edge->next_callee)
2324	{
2325	cgraph_node *callee = edge->callee;
2326
2327	fprintf (stream: f, format: "\t\"%s\" -> \"%s\"\n", dump_name (), callee->dump_name ());
2328	}
2329	}
2330
2331
2332	/* Dump call graph node NODE to stderr. */
2333
2334	DEBUG_FUNCTION void
2335	cgraph_node::debug (void)
2336	{
2337	dump (stderr);
2338	}
2339
2340	/* Dump the callgraph to file F. */
2341
2342	void
2343	cgraph_node::dump_cgraph (FILE *f)
2344	{
2345	cgraph_node *node;
2346
2347	fprintf (stream: f, format: "callgraph:\n\n");
2348	FOR_EACH_FUNCTION (node)
2349	node->dump (f);
2350	}
2351
2352	/* Return true when the DECL can possibly be inlined. */
2353
2354	bool
2355	cgraph_function_possibly_inlined_p (tree decl)
2356	{
2357	if (!symtab->global_info_ready)
2358	return !DECL_UNINLINABLE (decl);
2359	return DECL_POSSIBLY_INLINED (decl);
2360	}
2361
2362	/* Return function availability. See cgraph.h for description of individual
2363	return values. */
2364	enum availability
2365	cgraph_node::get_availability (symtab_node *ref)
2366	{
2367	if (ref)
2368	{
2369	cgraph_node *cref = dyn_cast <cgraph_node *> (p: ref);
2370	if (cref)
2371	ref = cref->inlined_to;
2372	}
2373	enum availability avail;
2374	if (!analyzed && !in_other_partition)
2375	avail = AVAIL_NOT_AVAILABLE;
2376	else if (local)
2377	avail = AVAIL_LOCAL;
2378	else if (inlined_to)
2379	avail = AVAIL_AVAILABLE;
2380	else if (transparent_alias)
2381	ultimate_alias_target (availability: &avail, ref);
2382	else if (ifunc_resolver
2383	|| lookup_attribute (attr_name: "noipa", DECL_ATTRIBUTES (decl)))
2384	avail = AVAIL_INTERPOSABLE;
2385	else if (!externally_visible)
2386	avail = AVAIL_AVAILABLE;
2387	/* If this is a reference from symbol itself and there are no aliases, we
2388	may be sure that the symbol was not interposed by something else because
2389	the symbol itself would be unreachable otherwise.
2390
2391	Also comdat groups are always resolved in groups. */
2392	else if ((this == ref && !has_aliases_p ())
2393	|| (ref && get_comdat_group ()
2394	&& get_comdat_group () == ref->get_comdat_group ()))
2395	avail = AVAIL_AVAILABLE;
2396	/* Inline functions are safe to be analyzed even if their symbol can
2397	be overwritten at runtime. It is not meaningful to enforce any sane
2398	behavior on replacing inline function by different body. */
2399	else if (DECL_DECLARED_INLINE_P (decl))
2400	avail = AVAIL_AVAILABLE;
2401
2402	/* If the function can be overwritten, return OVERWRITABLE. Take
2403	care at least of two notable extensions - the COMDAT functions
2404	used to share template instantiations in C++ (this is symmetric
2405	to code cp_cannot_inline_tree_fn and probably shall be shared and
2406	the inlinability hooks completely eliminated). */
2407
2408	else if (decl_replaceable_p (decl, semantic_interposition)
2409	&& !DECL_EXTERNAL (decl))
2410	avail = AVAIL_INTERPOSABLE;
2411	else avail = AVAIL_AVAILABLE;
2412
2413	return avail;
2414	}
2415
2416	/* Worker for cgraph_node_can_be_local_p. */
2417	static bool
2418	cgraph_node_cannot_be_local_p_1 (cgraph_node *node, void *)
2419	{
2420	return !(!node->force_output
2421	&& !node->ifunc_resolver
2422	/* Limitation of gas requires us to output targets of symver aliases
2423	as global symbols. This is binutils PR 25295. */
2424	&& !node->symver
2425	&& ((DECL_COMDAT (node->decl)
2426	&& !node->forced_by_abi
2427	&& !node->used_from_object_file_p ()
2428	&& !node->same_comdat_group)
2429	|| !node->externally_visible));
2430	}
2431
2432	/* Return true if cgraph_node can be made local for API change.
2433	Extern inline functions and C++ COMDAT functions can be made local
2434	at the expense of possible code size growth if function is used in multiple
2435	compilation units. */
2436	bool
2437	cgraph_node::can_be_local_p (void)
2438	{
2439	return (!address_taken
2440	&& !call_for_symbol_thunks_and_aliases (callback: cgraph_node_cannot_be_local_p_1,
2441	NULL, include_overwritable: true));
2442	}
2443
2444	/* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2445	When INCLUDE_OVERWRITABLE is false, overwritable symbols are
2446	skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2447	skipped. */
2448	bool
2449	cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback)
2450	(cgraph_node *, void *),
2451	void *data,
2452	bool include_overwritable,
2453	bool exclude_virtual_thunks)
2454	{
2455	cgraph_edge *e;
2456	ipa_ref *ref;
2457	enum availability avail = AVAIL_AVAILABLE;
2458
2459	if (include_overwritable
2460	|| (avail = get_availability ()) > AVAIL_INTERPOSABLE)
2461	{
2462	if (callback (this, data))
2463	return true;
2464	}
2465	FOR_EACH_ALIAS (this, ref)
2466	{
2467	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
2468	if (include_overwritable
2469	|| alias->get_availability () > AVAIL_INTERPOSABLE)
2470	if (alias->call_for_symbol_thunks_and_aliases (callback, data,
2471	include_overwritable,
2472	exclude_virtual_thunks))
2473	return true;
2474	}
2475	if (avail <= AVAIL_INTERPOSABLE)
2476	return false;
2477	for (e = callers; e; e = e->next_caller)
2478	if (e->caller->thunk
2479	&& (include_overwritable
2480	|| e->caller->get_availability () > AVAIL_INTERPOSABLE)
2481	&& !(exclude_virtual_thunks
2482	&& thunk_info::get (node: e->caller)->virtual_offset_p))
2483	if (e->caller->call_for_symbol_thunks_and_aliases (callback, data,
2484	include_overwritable,
2485	exclude_virtual_thunks))
2486	return true;
2487
2488	return false;
2489	}
2490
2491	/* Worker to bring NODE local. */
2492
2493	bool
2494	cgraph_node::make_local (cgraph_node *node, void *)
2495	{
2496	gcc_checking_assert (node->can_be_local_p ());
2497	if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2498	{
2499	node->make_decl_local ();
2500	node->set_section (NULL);
2501	node->set_comdat_group (NULL);
2502	node->externally_visible = false;
2503	node->forced_by_abi = false;
2504	node->local = true;
2505	node->unique_name = ((node->resolution == LDPR_PREVAILING_DEF_IRONLY
2506	|| node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
2507	&& !flag_incremental_link);
2508	node->resolution = LDPR_PREVAILING_DEF_IRONLY;
2509	gcc_assert (node->get_availability () == AVAIL_LOCAL);
2510	}
2511	return false;
2512	}
2513
2514	/* Bring cgraph node local. */
2515
2516	void
2517	cgraph_node::make_local (void)
2518	{
2519	call_for_symbol_thunks_and_aliases (callback: cgraph_node::make_local, NULL, include_overwritable: true);
2520	}
2521
2522	/* Worker to set nothrow flag. */
2523
2524	static void
2525	set_nothrow_flag_1 (cgraph_node *node, bool nothrow, bool non_call,
2526	bool *changed)
2527	{
2528	cgraph_edge *e;
2529
2530	if (nothrow && !TREE_NOTHROW (node->decl))
2531	{
2532	/* With non-call exceptions we can't say for sure if other function body
2533	was not possibly optimized to still throw. */
2534	if (!non_call || node->binds_to_current_def_p ())
2535	{
2536	TREE_NOTHROW (node->decl) = true;
2537	*changed = true;
2538	for (e = node->callers; e; e = e->next_caller)
2539	e->can_throw_external = false;
2540	}
2541	}
2542	else if (!nothrow && TREE_NOTHROW (node->decl))
2543	{
2544	TREE_NOTHROW (node->decl) = false;
2545	*changed = true;
2546	}
2547	ipa_ref *ref;
2548	FOR_EACH_ALIAS (node, ref)
2549	{
2550	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
2551	if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
2552	set_nothrow_flag_1 (node: alias, nothrow, non_call, changed);
2553	}
2554	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
2555	if (e->caller->thunk
2556	&& (!nothrow || e->caller->get_availability () > AVAIL_INTERPOSABLE))
2557	set_nothrow_flag_1 (node: e->caller, nothrow, non_call, changed);
2558	}
2559
2560	/* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2561	if any to NOTHROW. */
2562
2563	bool
2564	cgraph_node::set_nothrow_flag (bool nothrow)
2565	{
2566	bool changed = false;
2567	bool non_call = opt_for_fn (decl, flag_non_call_exceptions);
2568
2569	if (!nothrow || get_availability () > AVAIL_INTERPOSABLE)
2570	set_nothrow_flag_1 (node: this, nothrow, non_call, changed: &changed);
2571	else
2572	{
2573	ipa_ref *ref;
2574
2575	FOR_EACH_ALIAS (this, ref)
2576	{
2577	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
2578	if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
2579	set_nothrow_flag_1 (node: alias, nothrow, non_call, changed: &changed);
2580	}
2581	}
2582	return changed;
2583	}
2584
2585	/* Worker to set malloc flag. */
2586	static void
2587	set_malloc_flag_1 (cgraph_node *node, bool malloc_p, bool *changed)
2588	{
2589	if (malloc_p && !DECL_IS_MALLOC (node->decl))
2590	{
2591	DECL_IS_MALLOC (node->decl) = true;
2592	*changed = true;
2593	}
2594
2595	ipa_ref *ref;
2596	FOR_EACH_ALIAS (node, ref)
2597	{
2598	cgraph_node *alias = dyn_cast<cgraph_node *> (p: ref->referring);
2599	if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
2600	set_malloc_flag_1 (node: alias, malloc_p, changed);
2601	}
2602
2603	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
2604	if (e->caller->thunk
2605	&& (!malloc_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
2606	set_malloc_flag_1 (node: e->caller, malloc_p, changed);
2607	}
2608
2609	/* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any. */
2610
2611	bool
2612	cgraph_node::set_malloc_flag (bool malloc_p)
2613	{
2614	bool changed = false;
2615
2616	if (!malloc_p || get_availability () > AVAIL_INTERPOSABLE)
2617	set_malloc_flag_1 (node: this, malloc_p, changed: &changed);
2618	else
2619	{
2620	ipa_ref *ref;
2621
2622	FOR_EACH_ALIAS (this, ref)
2623	{
2624	cgraph_node *alias = dyn_cast<cgraph_node *> (p: ref->referring);
2625	if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
2626	set_malloc_flag_1 (node: alias, malloc_p, changed: &changed);
2627	}
2628	}
2629	return changed;
2630	}
2631
2632	/* Worker to set noreturng flag. */
2633	static void
2634	set_noreturn_flag_1 (cgraph_node *node, bool noreturn_p, bool *changed)
2635	{
2636	if (noreturn_p && !TREE_THIS_VOLATILE (node->decl))
2637	{
2638	TREE_THIS_VOLATILE (node->decl) = true;
2639	*changed = true;
2640	}
2641
2642	ipa_ref *ref;
2643	FOR_EACH_ALIAS (node, ref)
2644	{
2645	cgraph_node *alias = dyn_cast<cgraph_node *> (p: ref->referring);
2646	if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
2647	set_noreturn_flag_1 (node: alias, noreturn_p, changed);
2648	}
2649
2650	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
2651	if (e->caller->thunk
2652	&& (!noreturn_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
2653	set_noreturn_flag_1 (node: e->caller, noreturn_p, changed);
2654	}
2655
2656	/* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any. */
2657
2658	bool
2659	cgraph_node::set_noreturn_flag (bool noreturn_p)
2660	{
2661	bool changed = false;
2662
2663	if (!noreturn_p || get_availability () > AVAIL_INTERPOSABLE)
2664	set_noreturn_flag_1 (node: this, noreturn_p, changed: &changed);
2665	else
2666	{
2667	ipa_ref *ref;
2668
2669	FOR_EACH_ALIAS (this, ref)
2670	{
2671	cgraph_node *alias = dyn_cast<cgraph_node *> (p: ref->referring);
2672	if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
2673	set_noreturn_flag_1 (node: alias, noreturn_p, changed: &changed);
2674	}
2675	}
2676	return changed;
2677	}
2678
2679	/* Worker to set_const_flag. */
2680
2681	static void
2682	set_const_flag_1 (cgraph_node *node, bool set_const, bool looping,
2683	bool *changed)
2684	{
2685	/* Static constructors and destructors without a side effect can be
2686	optimized out. */
2687	if (set_const && !looping)
2688	{
2689	if (DECL_STATIC_CONSTRUCTOR (node->decl))
2690	{
2691	DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2692	*changed = true;
2693	}
2694	if (DECL_STATIC_DESTRUCTOR (node->decl))
2695	{
2696	DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2697	*changed = true;
2698	}
2699	}
2700	if (!set_const)
2701	{
2702	if (TREE_READONLY (node->decl))
2703	{
2704	TREE_READONLY (node->decl) = 0;
2705	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
2706	*changed = true;
2707	}
2708	}
2709	else
2710	{
2711	/* Consider function:
2712
2713	bool a(int *p)
2714	{
2715	return *p==*p;
2716	}
2717
2718	During early optimization we will turn this into:
2719
2720	bool a(int *p)
2721	{
2722	return true;
2723	}
2724
2725	Now if this function will be detected as CONST however when interposed
2726	it may end up being just pure. We always must assume the worst
2727	scenario here. */
2728	if (TREE_READONLY (node->decl))
2729	{
2730	if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl))
2731	{
2732	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
2733	*changed = true;
2734	}
2735	}
2736	else if (node->binds_to_current_def_p ())
2737	{
2738	TREE_READONLY (node->decl) = true;
2739	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
2740	DECL_PURE_P (node->decl) = false;
2741	*changed = true;
2742	}
2743	else
2744	{
2745	if (dump_file && (dump_flags & TDF_DETAILS))
2746	fprintf (stream: dump_file, format: "Dropping state to PURE because function does "
2747	"not bind to current def.\n");
2748	if (!DECL_PURE_P (node->decl))
2749	{
2750	DECL_PURE_P (node->decl) = true;
2751	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = looping;
2752	*changed = true;
2753	}
2754	else if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl))
2755	{
2756	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
2757	*changed = true;
2758	}
2759	}
2760	}
2761
2762	ipa_ref *ref;
2763	FOR_EACH_ALIAS (node, ref)
2764	{
2765	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
2766	if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
2767	set_const_flag_1 (node: alias, set_const, looping, changed);
2768	}
2769	for (struct cgraph_node *n = node->simd_clones; n != NULL;
2770	n = n->simdclone->next_clone)
2771	set_const_flag_1 (node: n, set_const, looping, changed);
2772	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
2773	if (e->caller->thunk
2774	&& (!set_const || e->caller->get_availability () > AVAIL_INTERPOSABLE))
2775	{
2776	/* Virtual thunks access virtual offset in the vtable, so they can
2777	only be pure, never const. */
2778	if (set_const
2779	&& (thunk_info::get (node: e->caller)->virtual_offset_p
2780	|| !node->binds_to_current_def_p (ref: e->caller)))
2781	*changed |= e->caller->set_pure_flag (pure: true, looping);
2782	else
2783	set_const_flag_1 (node: e->caller, set_const, looping, changed);
2784	}
2785	}
2786
2787	/* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
2788	If SET_CONST if false, clear the flag.
2789
2790	When setting the flag be careful about possible interposition and
2791	do not set the flag for functions that can be interposed and set pure
2792	flag for functions that can bind to other definition.
2793
2794	Return true if any change was done. */
2795
2796	bool
2797	cgraph_node::set_const_flag (bool set_const, bool looping)
2798	{
2799	bool changed = false;
2800	if (!set_const || get_availability () > AVAIL_INTERPOSABLE)
2801	set_const_flag_1 (node: this, set_const, looping, changed: &changed);
2802	else
2803	{
2804	ipa_ref *ref;
2805
2806	FOR_EACH_ALIAS (this, ref)
2807	{
2808	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
2809	if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
2810	set_const_flag_1 (node: alias, set_const, looping, changed: &changed);
2811	}
2812	}
2813	return changed;
2814	}
2815
2816	/* Info used by set_pure_flag_1. */
2817
2818	struct set_pure_flag_info
2819	{
2820	bool pure;
2821	bool looping;
2822	bool changed;
2823	};
2824
2825	/* Worker to set_pure_flag. */
2826
2827	static bool
2828	set_pure_flag_1 (cgraph_node *node, void *data)
2829	{
2830	struct set_pure_flag_info *info = (struct set_pure_flag_info *)data;
2831	/* Static constructors and destructors without a side effect can be
2832	optimized out. */
2833	if (info->pure && !info->looping)
2834	{
2835	if (DECL_STATIC_CONSTRUCTOR (node->decl))
2836	{
2837	DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2838	info->changed = true;
2839	}
2840	if (DECL_STATIC_DESTRUCTOR (node->decl))
2841	{
2842	DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2843	info->changed = true;
2844	}
2845	}
2846	if (info->pure)
2847	{
2848	if (!DECL_PURE_P (node->decl) && !TREE_READONLY (node->decl))
2849	{
2850	DECL_PURE_P (node->decl) = true;
2851	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = info->looping;
2852	info->changed = true;
2853	}
2854	else if (DECL_LOOPING_CONST_OR_PURE_P (node->decl)
2855	&& !info->looping)
2856	{
2857	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
2858	info->changed = true;
2859	}
2860	}
2861	else
2862	{
2863	if (DECL_PURE_P (node->decl))
2864	{
2865	DECL_PURE_P (node->decl) = false;
2866	DECL_LOOPING_CONST_OR_PURE_P (node->decl) = false;
2867	info->changed = true;
2868	}
2869	}
2870	return false;
2871	}
2872
2873	/* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2874	if any to PURE.
2875
2876	When setting the flag, be careful about possible interposition.
2877	Return true if any change was done. */
2878
2879	bool
2880	cgraph_node::set_pure_flag (bool pure, bool looping)
2881	{
2882	struct set_pure_flag_info info = {.pure: pure, .looping: looping, .changed: false};
2883	call_for_symbol_thunks_and_aliases (callback: set_pure_flag_1, data: &info, include_overwritable: !pure, exclude_virtual_thunks: true);
2884	for (struct cgraph_node *n = simd_clones; n != NULL;
2885	n = n->simdclone->next_clone)
2886	set_pure_flag_1 (node: n, data: &info);
2887	return info.changed;
2888	}
2889
2890	/* Return true when cgraph_node cannot return or throw and thus
2891	it is safe to ignore its side effects for IPA analysis. */
2892
2893	bool
2894	cgraph_node::cannot_return_p (void)
2895	{
2896	int flags = flags_from_decl_or_type (decl);
2897	if (!opt_for_fn (decl, flag_exceptions))
2898	return (flags & ECF_NORETURN) != 0;
2899	else
2900	return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2901	== (ECF_NORETURN | ECF_NOTHROW));
2902	}
2903
2904	/* Return true when call of edge cannot lead to return from caller
2905	and thus it is safe to ignore its side effects for IPA analysis
2906	when computing side effects of the caller.
2907	FIXME: We could actually mark all edges that have no reaching
2908	patch to the exit block or throw to get better results. */
2909	bool
2910	cgraph_edge::cannot_lead_to_return_p (void)
2911	{
2912	if (caller->cannot_return_p ())
2913	return true;
2914	if (indirect_unknown_callee)
2915	{
2916	int flags = indirect_info->ecf_flags;
2917	if (!opt_for_fn (caller->decl, flag_exceptions))
2918	return (flags & ECF_NORETURN) != 0;
2919	else
2920	return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2921	== (ECF_NORETURN | ECF_NOTHROW));
2922	}
2923	else
2924	return callee->cannot_return_p ();
2925	}
2926
2927	/* Return true if the edge may be considered hot. */
2928
2929	bool
2930	cgraph_edge::maybe_hot_p (void)
2931	{
2932	if (!maybe_hot_count_p (NULL, count.ipa ()))
2933	return false;
2934	if (caller->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
2935	|| (callee
2936	&& callee->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED))
2937	return false;
2938	if (caller->frequency > NODE_FREQUENCY_UNLIKELY_EXECUTED
2939	&& (callee
2940	&& callee->frequency <= NODE_FREQUENCY_EXECUTED_ONCE))
2941	return false;
2942	if (opt_for_fn (caller->decl, optimize_size))
2943	return false;
2944	if (caller->frequency == NODE_FREQUENCY_HOT)
2945	return true;
2946	if (!count.initialized_p ())
2947	return true;
2948	cgraph_node *where = caller->inlined_to ? caller->inlined_to : caller;
2949	if (!where->count.initialized_p ())
2950	return false;
2951	if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE)
2952	{
2953	if (count * 2 < where->count * 3)
2954	return false;
2955	}
2956	else if (count * param_hot_bb_frequency_fraction < where->count)
2957	return false;
2958	return true;
2959	}
2960
2961	/* Worker for cgraph_can_remove_if_no_direct_calls_p. */
2962
2963	static bool
2964	nonremovable_p (cgraph_node *node, void *)
2965	{
2966	return !node->can_remove_if_no_direct_calls_and_refs_p ();
2967	}
2968
2969	/* Return true if whole comdat group can be removed if there are no direct
2970	calls to THIS. */
2971
2972	bool
2973	cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline)
2974	{
2975	struct ipa_ref *ref;
2976
2977	/* For local symbols or non-comdat group it is the same as
2978	can_remove_if_no_direct_calls_p. */
2979	if (!externally_visible || !same_comdat_group)
2980	{
2981	if (DECL_EXTERNAL (decl))
2982	return true;
2983	if (address_taken)
2984	return false;
2985	return !call_for_symbol_and_aliases (callback: nonremovable_p, NULL, include_overwritable: true);
2986	}
2987
2988	if (will_inline && address_taken)
2989	return false;
2990
2991	/* Otherwise check if we can remove the symbol itself and then verify
2992	that only uses of the comdat groups are direct call to THIS
2993	or its aliases. */
2994	if (!can_remove_if_no_direct_calls_and_refs_p ())
2995	return false;
2996
2997	/* Check that all refs come from within the comdat group. */
2998	for (int i = 0; iterate_referring (i, ref); i++)
2999	if (ref->referring->get_comdat_group () != get_comdat_group ())
3000	return false;
3001
3002	struct cgraph_node *target = ultimate_alias_target ();
3003	for (cgraph_node *next = dyn_cast<cgraph_node *> (p: same_comdat_group);
3004	next != this; next = dyn_cast<cgraph_node *> (p: next->same_comdat_group))
3005	{
3006	if (!externally_visible)
3007	continue;
3008	if (!next->alias
3009	&& !next->can_remove_if_no_direct_calls_and_refs_p ())
3010	return false;
3011
3012	/* If we see different symbol than THIS, be sure to check calls. */
3013	if (next->ultimate_alias_target () != target)
3014	for (cgraph_edge *e = next->callers; e; e = e->next_caller)
3015	if (e->caller->get_comdat_group () != get_comdat_group ()
3016	|| will_inline)
3017	return false;
3018
3019	/* If function is not being inlined, we care only about
3020	references outside of the comdat group. */
3021	if (!will_inline)
3022	for (int i = 0; next->iterate_referring (i, ref); i++)
3023	if (ref->referring->get_comdat_group () != get_comdat_group ())
3024	return false;
3025	}
3026	return true;
3027	}
3028
3029	/* Return true when function cgraph_node can be expected to be removed
3030	from program when direct calls in this compilation unit are removed.
3031
3032	As a special case COMDAT functions are
3033	cgraph_can_remove_if_no_direct_calls_p while the are not
3034	cgraph_only_called_directly_p (it is possible they are called from other
3035	unit)
3036
3037	This function behaves as cgraph_only_called_directly_p because eliminating
3038	all uses of COMDAT function does not make it necessarily disappear from
3039	the program unless we are compiling whole program or we do LTO. In this
3040	case we know we win since dynamic linking will not really discard the
3041	linkonce section. */
3042
3043	bool
3044	cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
3045	(bool will_inline)
3046	{
3047	gcc_assert (!inlined_to);
3048	if (DECL_EXTERNAL (decl))
3049	return true;
3050
3051	if (!in_lto_p && !flag_whole_program)
3052	{
3053	/* If the symbol is in comdat group, we need to verify that whole comdat
3054	group becomes unreachable. Technically we could skip references from
3055	within the group, too. */
3056	if (!only_called_directly_p ())
3057	return false;
3058	if (same_comdat_group && externally_visible)
3059	{
3060	struct cgraph_node *target = ultimate_alias_target ();
3061
3062	if (will_inline && address_taken)
3063	return true;
3064	for (cgraph_node *next = dyn_cast<cgraph_node *> (p: same_comdat_group);
3065	next != this;
3066	next = dyn_cast<cgraph_node *> (p: next->same_comdat_group))
3067	{
3068	if (!externally_visible)
3069	continue;
3070	if (!next->alias
3071	&& !next->only_called_directly_p ())
3072	return false;
3073
3074	/* If we see different symbol than THIS,
3075	be sure to check calls. */
3076	if (next->ultimate_alias_target () != target)
3077	for (cgraph_edge *e = next->callers; e; e = e->next_caller)
3078	if (e->caller->get_comdat_group () != get_comdat_group ()
3079	|| will_inline)
3080	return false;
3081	}
3082	}
3083	return true;
3084	}
3085	else
3086	return can_remove_if_no_direct_calls_p (will_inline);
3087	}
3088
3089
3090	/* Worker for cgraph_only_called_directly_p. */
3091
3092	static bool
3093	cgraph_not_only_called_directly_p_1 (cgraph_node *node, void *)
3094	{
3095	return !node->only_called_directly_or_aliased_p ();
3096	}
3097
3098	/* Return true when function cgraph_node and all its aliases are only called
3099	directly.
3100	i.e. it is not externally visible, address was not taken and
3101	it is not used in any other non-standard way. */
3102
3103	bool
3104	cgraph_node::only_called_directly_p (void)
3105	{
3106	gcc_assert (ultimate_alias_target () == this);
3107	return !call_for_symbol_and_aliases (callback: cgraph_not_only_called_directly_p_1,
3108	NULL, include_overwritable: true);
3109	}
3110
3111
3112	/* Collect all callers of NODE. Worker for collect_callers_of_node. */
3113
3114	static bool
3115	collect_callers_of_node_1 (cgraph_node *node, void *data)
3116	{
3117	vec<cgraph_edge *> *redirect_callers = (vec<cgraph_edge *> *)data;
3118	cgraph_edge *cs;
3119	enum availability avail;
3120	node->ultimate_alias_target (availability: &avail);
3121
3122	if (avail > AVAIL_INTERPOSABLE)
3123	for (cs = node->callers; cs != NULL; cs = cs->next_caller)
3124	if (!cs->indirect_inlining_edge
3125	&& !cs->caller->thunk)
3126	redirect_callers->safe_push (obj: cs);
3127	return false;
3128	}
3129
3130	/* Collect all callers of cgraph_node and its aliases that are known to lead to
3131	cgraph_node (i.e. are not overwritable). */
3132
3133	auto_vec<cgraph_edge *>
3134	cgraph_node::collect_callers (void)
3135	{
3136	auto_vec<cgraph_edge *> redirect_callers;
3137	call_for_symbol_thunks_and_aliases (callback: collect_callers_of_node_1,
3138	data: &redirect_callers, include_overwritable: false);
3139	return redirect_callers;
3140	}
3141
3142
3143	/* Return TRUE if NODE2 a clone of NODE or is equivalent to it. Return
3144	optimistically true if this cannot be determined. */
3145
3146	static bool
3147	clone_of_p (cgraph_node *node, cgraph_node *node2)
3148	{
3149	node = node->ultimate_alias_target ();
3150	node2 = node2->ultimate_alias_target ();
3151
3152	if (node2->clone_of == node
3153	|| node2->former_clone_of == node->decl)
3154	return true;
3155
3156	if (!node->thunk && !node->former_thunk_p ())
3157	{
3158	while (node2
3159	&& node->decl != node2->decl
3160	&& node->decl != node2->former_clone_of)
3161	node2 = node2->clone_of;
3162	return node2 != NULL;
3163	}
3164
3165	/* There are no virtual clones of thunks so check former_clone_of or if we
3166	might have skipped thunks because this adjustments are no longer
3167	necessary. */
3168	while (node->thunk || node->former_thunk_p ())
3169	{
3170	if (!thunk_info::get (node)->this_adjusting)
3171	return false;
3172	/* In case of instrumented expanded thunks, which can have multiple calls
3173	in them, we do not know how to continue and just have to be
3174	optimistic. The same applies if all calls have already been inlined
3175	into the thunk. */
3176	if (!node->callees || node->callees->next_callee)
3177	return true;
3178	node = node->callees->callee->ultimate_alias_target ();
3179
3180	clone_info *info = clone_info::get (node: node2);
3181	if (!info || !info->param_adjustments
3182	|| info->param_adjustments->first_param_intact_p ())
3183	return false;
3184	if (node2->former_clone_of == node->decl
3185	|| node2->former_clone_of == node->former_clone_of)
3186	return true;
3187
3188	cgraph_node *n2 = node2;
3189	while (n2 && node->decl != n2->decl)
3190	n2 = n2->clone_of;
3191	if (n2)
3192	return true;
3193	}
3194
3195	return false;
3196	}
3197
3198	/* Verify edge count and frequency. */
3199
3200	bool
3201	cgraph_edge::verify_count ()
3202	{
3203	bool error_found = false;
3204	if (!count.verify ())
3205	{
3206	error ("caller edge count invalid");
3207	error_found = true;
3208	}
3209	return error_found;
3210	}
3211
3212	/* Switch to THIS_CFUN if needed and print STMT to stderr. */
3213	static void
3214	cgraph_debug_gimple_stmt (function *this_cfun, gimple *stmt)
3215	{
3216	bool fndecl_was_null = false;
3217	/* debug_gimple_stmt needs correct cfun */
3218	if (cfun != this_cfun)
3219	set_cfun (new_cfun: this_cfun);
3220	/* ...and an actual current_function_decl */
3221	if (!current_function_decl)
3222	{
3223	current_function_decl = this_cfun->decl;
3224	fndecl_was_null = true;
3225	}
3226	debug_gimple_stmt (stmt);
3227	if (fndecl_was_null)
3228	current_function_decl = NULL;
3229	}
3230
3231	/* Verify that call graph edge corresponds to DECL from the associated
3232	statement. Return true if the verification should fail. */
3233
3234	bool
3235	cgraph_edge::verify_corresponds_to_fndecl (tree decl)
3236	{
3237	cgraph_node *node;
3238
3239	if (!decl || callee->inlined_to)
3240	return false;
3241	if (symtab->state == LTO_STREAMING)
3242	return false;
3243	node = cgraph_node::get (decl);
3244
3245	/* We do not know if a node from a different partition is an alias or what it
3246	aliases and therefore cannot do the former_clone_of check reliably. When
3247	body_removed is set, we have lost all information about what was alias or
3248	thunk of and also cannot proceed. */
3249	if (!node
3250	|| node->body_removed
3251	|| node->in_other_partition
3252	|| callee->icf_merged
3253	|| callee->in_other_partition)
3254	return false;
3255
3256	node = node->ultimate_alias_target ();
3257
3258	/* Optimizers can redirect unreachable calls or calls triggering undefined
3259	behavior to __builtin_unreachable or __builtin_unreachable trap. */
3260
3261	if (fndecl_built_in_p (node: callee->decl, name1: BUILT_IN_UNREACHABLE,
3262	names: BUILT_IN_UNREACHABLE_TRAP))
3263	return false;
3264
3265	if (callee->former_clone_of != node->decl
3266	&& (node != callee->ultimate_alias_target ())
3267	&& !clone_of_p (node, node2: callee))
3268	return true;
3269	else
3270	return false;
3271	}
3272
3273	/* Disable warnings about missing quoting in GCC diagnostics for
3274	the verification errors. Their format strings don't follow GCC
3275	diagnostic conventions and the calls are ultimately followed by
3276	one to internal_error. */
3277	#if __GNUC__ >= 10
3278	# pragma GCC diagnostic push
3279	# pragma GCC diagnostic ignored "-Wformat-diag"
3280	#endif
3281
3282	/* Verify consistency of speculative call in NODE corresponding to STMT
3283	and LTO_STMT_UID. If INDIRECT is set, assume that it is the indirect
3284	edge of call sequence. Return true if error is found.
3285
3286	This function is called to every component of indirect call (direct edges,
3287	indirect edge and refs). To save duplicated work, do full testing only
3288	in that case. */
3289	static bool
3290	verify_speculative_call (struct cgraph_node *node, gimple *stmt,
3291	unsigned int lto_stmt_uid,
3292	struct cgraph_edge *indirect)
3293	{
3294	if (indirect == NULL)
3295	{
3296	for (indirect = node->indirect_calls; indirect;
3297	indirect = indirect->next_callee)
3298	if (indirect->call_stmt == stmt
3299	&& indirect->lto_stmt_uid == lto_stmt_uid)
3300	break;
3301	if (!indirect)
3302	{
3303	error ("missing indirect call in speculative call sequence");
3304	return true;
3305	}
3306	if (!indirect->speculative)
3307	{
3308	error ("indirect call in speculative call sequence has no "
3309	"speculative flag");
3310	return true;
3311	}
3312	return false;
3313	}
3314
3315	/* Maximal number of targets. We probably will never want to have more than
3316	this. */
3317	const unsigned int num = 256;
3318	cgraph_edge *direct_calls[num];
3319	ipa_ref *refs[num];
3320
3321	for (unsigned int i = 0; i < num; i++)
3322	{
3323	direct_calls[i] = NULL;
3324	refs[i] = NULL;
3325	}
3326
3327	cgraph_edge *first_call = NULL;
3328	cgraph_edge *prev_call = NULL;
3329
3330	for (cgraph_edge *direct = node->callees; direct;
3331	direct = direct->next_callee)
3332	if (direct->call_stmt == stmt && direct->lto_stmt_uid == lto_stmt_uid)
3333	{
3334	if (!first_call)
3335	first_call = direct;
3336	if (prev_call && direct != prev_call->next_callee)
3337	{
3338	error ("speculative edges are not adjacent");
3339	return true;
3340	}
3341	prev_call = direct;
3342	if (!direct->speculative)
3343	{
3344	error ("direct call to %s in speculative call sequence has no "
3345	"speculative flag", direct->callee->dump_name ());
3346	return true;
3347	}
3348	if (direct->speculative_id >= num)
3349	{
3350	error ("direct call to %s in speculative call sequence has "
3351	"speculative_id %i out of range",
3352	direct->callee->dump_name (), direct->speculative_id);
3353	return true;
3354	}
3355	if (direct_calls[direct->speculative_id])
3356	{
3357	error ("duplicate direct call to %s in speculative call sequence "
3358	"with speculative_id %i",
3359	direct->callee->dump_name (), direct->speculative_id);
3360	return true;
3361	}
3362	direct_calls[direct->speculative_id] = direct;
3363	}
3364
3365	if (first_call->call_stmt
3366	&& first_call != node->get_edge (call_stmt: first_call->call_stmt))
3367	{
3368	error ("call stmt hash does not point to first direct edge of "
3369	"speculative call sequence");
3370	return true;
3371	}
3372
3373	ipa_ref *ref;
3374	for (int i = 0; node->iterate_reference (i, ref); i++)
3375	if (ref->speculative
3376	&& ref->stmt == stmt && ref->lto_stmt_uid == lto_stmt_uid)
3377	{
3378	if (ref->speculative_id >= num)
3379	{
3380	error ("direct call to %s in speculative call sequence has "
3381	"speculative_id %i out of range",
3382	ref->referred->dump_name (), ref->speculative_id);
3383	return true;
3384	}
3385	if (refs[ref->speculative_id])
3386	{
3387	error ("duplicate reference %s in speculative call sequence "
3388	"with speculative_id %i",
3389	ref->referred->dump_name (), ref->speculative_id);
3390	return true;
3391	}
3392	refs[ref->speculative_id] = ref;
3393	}
3394
3395	int num_targets = 0;
3396	for (unsigned int i = 0 ; i < num ; i++)
3397	{
3398	if (refs[i] && !direct_calls[i])
3399	{
3400	error ("missing direct call for speculation %i", i);
3401	return true;
3402	}
3403	if (!refs[i] && direct_calls[i])
3404	{
3405	error ("missing ref for speculation %i", i);
3406	return true;
3407	}
3408	if (refs[i] != NULL)
3409	num_targets++;
3410	}
3411
3412	if (num_targets != indirect->num_speculative_call_targets_p ())
3413	{
3414	error ("number of speculative targets %i mismatched with "
3415	"num_speculative_call_targets %i",
3416	num_targets,
3417	indirect->num_speculative_call_targets_p ());
3418	return true;
3419	}
3420	return false;
3421	}
3422
3423	/* Verify cgraph nodes of given cgraph node. */
3424	DEBUG_FUNCTION void
3425	cgraph_node::verify_node (void)
3426	{
3427	cgraph_edge *e;
3428	function *this_cfun = DECL_STRUCT_FUNCTION (decl);
3429	basic_block this_block;
3430	gimple_stmt_iterator gsi;
3431	bool error_found = false;
3432	int i;
3433	ipa_ref *ref = NULL;
3434
3435	if (seen_error ())
3436	return;
3437
3438	timevar_push (tv: TV_CGRAPH_VERIFY);
3439	error_found |= verify_base ();
3440	for (e = callees; e; e = e->next_callee)
3441	if (e->aux)
3442	{
3443	error ("aux field set for edge %s->%s",
3444	identifier_to_locale (e->caller->name ()),
3445	identifier_to_locale (e->callee->name ()));
3446	error_found = true;
3447	}
3448	if (!count.verify ())
3449	{
3450	error ("cgraph count invalid");
3451	error_found = true;
3452	}
3453	if (inlined_to && same_comdat_group)
3454	{
3455	error ("inline clone in same comdat group list");
3456	error_found = true;
3457	}
3458	if (inlined_to && !count.compatible_p (other: inlined_to->count))
3459	{
3460	error ("inline clone count is not compatible");
3461	count.debug ();
3462	inlined_to->count.debug ();
3463	error_found = true;
3464	}
3465	if (tp_first_run < 0)
3466	{
3467	error ("tp_first_run must be non-negative");
3468	error_found = true;
3469	}
3470	if (!definition && !in_other_partition && local)
3471	{
3472	error ("local symbols must be defined");
3473	error_found = true;
3474	}
3475	if (inlined_to && externally_visible)
3476	{
3477	error ("externally visible inline clone");
3478	error_found = true;
3479	}
3480	if (inlined_to && address_taken)
3481	{
3482	error ("inline clone with address taken");
3483	error_found = true;
3484	}
3485	if (inlined_to && force_output)
3486	{
3487	error ("inline clone is forced to output");
3488	error_found = true;
3489	}
3490	if (symtab->state != LTO_STREAMING)
3491	{
3492	if (calls_comdat_local && !same_comdat_group)
3493	{
3494	error ("calls_comdat_local is set outside of a comdat group");
3495	error_found = true;
3496	}
3497	if (!inlined_to && calls_comdat_local != check_calls_comdat_local_p ())
3498	{
3499	error ("invalid calls_comdat_local flag");
3500	error_found = true;
3501	}
3502	}
3503	if (DECL_IS_MALLOC (decl)
3504	&& !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
3505	{
3506	error ("malloc attribute should be used for a function that "
3507	"returns a pointer");
3508	error_found = true;
3509	}
3510	if (definition
3511	&& externally_visible
3512	/* For aliases in lto1 free_lang_data doesn't guarantee preservation
3513	of opt_for_fn (decl, flag_semantic_interposition). See PR105399. */
3514	&& (!alias || !in_lto_p)
3515	&& semantic_interposition
3516	!= opt_for_fn (decl, flag_semantic_interposition))
3517	{
3518	error ("semantic interposition mismatch");
3519	error_found = true;
3520	}
3521	for (e = indirect_calls; e; e = e->next_callee)
3522	{
3523	if (e->aux)
3524	{
3525	error ("aux field set for indirect edge from %s",
3526	identifier_to_locale (e->caller->name ()));
3527	error_found = true;
3528	}
3529	if (!e->count.compatible_p (other: count))
3530	{
3531	error ("edge count is not compatible with function count");
3532	e->count.debug ();
3533	count.debug ();
3534	error_found = true;
3535	}
3536	if (!e->indirect_unknown_callee
3537	|| !e->indirect_info)
3538	{
3539	error ("An indirect edge from %s is not marked as indirect or has "
3540	"associated indirect_info, the corresponding statement is: ",
3541	identifier_to_locale (e->caller->name ()));
3542	cgraph_debug_gimple_stmt (this_cfun, stmt: e->call_stmt);
3543	error_found = true;
3544	}
3545	if (e->call_stmt && e->lto_stmt_uid)
3546	{
3547	error ("edge has both call_stmt and lto_stmt_uid set");
3548	error_found = true;
3549	}
3550	}
3551	bool check_comdat = comdat_local_p ();
3552	for (e = callers; e; e = e->next_caller)
3553	{
3554	if (e->verify_count ())
3555	error_found = true;
3556	if (check_comdat
3557	&& !in_same_comdat_group_p (target: e->caller))
3558	{
3559	error ("comdat-local function called by %s outside its comdat",
3560	identifier_to_locale (e->caller->name ()));
3561	error_found = true;
3562	}
3563	if (!e->inline_failed)
3564	{
3565	if (inlined_to
3566	!= (e->caller->inlined_to
3567	? e->caller->inlined_to : e->caller))
3568	{
3569	error ("inlined_to pointer is wrong");
3570	error_found = true;
3571	}
3572	if (callers->next_caller)
3573	{
3574	error ("multiple inline callers");
3575	error_found = true;
3576	}
3577	}
3578	else
3579	if (inlined_to)
3580	{
3581	error ("inlined_to pointer set for noninline callers");
3582	error_found = true;
3583	}
3584	}
3585	for (e = callees; e; e = e->next_callee)
3586	{
3587	if (e->verify_count ())
3588	error_found = true;
3589	if (!e->count.compatible_p (other: count))
3590	{
3591	error ("edge count is not compatible with function count");
3592	e->count.debug ();
3593	count.debug ();
3594	error_found = true;
3595	}
3596	if (gimple_has_body_p (e->caller->decl)
3597	&& !e->caller->inlined_to
3598	&& !e->speculative
3599	/* Optimized out calls are redirected to __builtin_unreachable. */
3600	&& (e->count.nonzero_p ()
3601	|| ! e->callee->decl
3602	|| !fndecl_built_in_p (node: e->callee->decl, name1: BUILT_IN_UNREACHABLE,
3603	names: BUILT_IN_UNREACHABLE_TRAP))
3604	&& count
3605	== ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))->count
3606	&& (!e->count.ipa_p ()
3607	&& e->count.differs_from_p (other: gimple_bb (g: e->call_stmt)->count)))
3608	{
3609	error ("caller edge count does not match BB count");
3610	fprintf (stderr, format: "edge count: ");
3611	e->count.dump (stderr);
3612	fprintf (stderr, format: "\n bb count: ");
3613	gimple_bb (g: e->call_stmt)->count.dump (stderr);
3614	fprintf (stderr, format: "\n");
3615	error_found = true;
3616	}
3617	if (e->call_stmt && e->lto_stmt_uid)
3618	{
3619	error ("edge has both call_stmt and lto_stmt_uid set");
3620	error_found = true;
3621	}
3622	if (e->speculative
3623	&& verify_speculative_call (node: e->caller, stmt: e->call_stmt, lto_stmt_uid: e->lto_stmt_uid,
3624	NULL))
3625	error_found = true;
3626	}
3627	for (e = indirect_calls; e; e = e->next_callee)
3628	{
3629	if (e->verify_count ())
3630	error_found = true;
3631	if (gimple_has_body_p (e->caller->decl)
3632	&& !e->caller->inlined_to
3633	&& !e->speculative
3634	&& e->count.ipa_p ()
3635	&& count
3636	== ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))->count
3637	&& (!e->count.ipa_p ()
3638	&& e->count.differs_from_p (other: gimple_bb (g: e->call_stmt)->count)))
3639	{
3640	error ("indirect call count does not match BB count");
3641	fprintf (stderr, format: "edge count: ");
3642	e->count.dump (stderr);
3643	fprintf (stderr, format: "\n bb count: ");
3644	gimple_bb (g: e->call_stmt)->count.dump (stderr);
3645	fprintf (stderr, format: "\n");
3646	error_found = true;
3647	}
3648	if (e->speculative
3649	&& verify_speculative_call (node: e->caller, stmt: e->call_stmt, lto_stmt_uid: e->lto_stmt_uid,
3650	indirect: e))
3651	error_found = true;
3652	}
3653	for (i = 0; iterate_reference (i, ref); i++)
3654	{
3655	if (ref->stmt && ref->lto_stmt_uid)
3656	{
3657	error ("reference has both stmt and lto_stmt_uid set");
3658	error_found = true;
3659	}
3660	if (ref->speculative
3661	&& verify_speculative_call (node: this, stmt: ref->stmt,
3662	lto_stmt_uid: ref->lto_stmt_uid, NULL))
3663	error_found = true;
3664	}
3665
3666	if (!callers && inlined_to)
3667	{
3668	error ("inlined_to pointer is set but no predecessors found");
3669	error_found = true;
3670	}
3671	if (inlined_to == this)
3672	{
3673	error ("inlined_to pointer refers to itself");
3674	error_found = true;
3675	}
3676
3677	if (clone_of)
3678	{
3679	cgraph_node *first_clone = clone_of->clones;
3680	if (first_clone != this)
3681	{
3682	if (prev_sibling_clone->clone_of != clone_of)
3683	{
3684	error ("cgraph_node has wrong clone_of");
3685	error_found = true;
3686	}
3687	}
3688	}
3689	if (clones)
3690	{
3691	cgraph_node *n;
3692	for (n = clones; n; n = n->next_sibling_clone)
3693	if (n->clone_of != this)
3694	break;
3695	if (n)
3696	{
3697	error ("cgraph_node has wrong clone list");
3698	error_found = true;
3699	}
3700	}
3701	if ((prev_sibling_clone || next_sibling_clone) && !clone_of)
3702	{
3703	error ("cgraph_node is in clone list but it is not clone");
3704	error_found = true;
3705	}
3706	if (!prev_sibling_clone && clone_of && clone_of->clones != this)
3707	{
3708	error ("cgraph_node has wrong prev_clone pointer");
3709	error_found = true;
3710	}
3711	if (prev_sibling_clone && prev_sibling_clone->next_sibling_clone != this)
3712	{
3713	error ("double linked list of clones corrupted");
3714	error_found = true;
3715	}
3716
3717	if (analyzed && alias)
3718	{
3719	bool ref_found = false;
3720	int i;
3721	ipa_ref *ref = NULL;
3722
3723	if (callees)
3724	{
3725	error ("Alias has call edges");
3726	error_found = true;
3727	}
3728	for (i = 0; iterate_reference (i, ref); i++)
3729	if (ref->use != IPA_REF_ALIAS)
3730	{
3731	error ("Alias has non-alias reference");
3732	error_found = true;
3733	}
3734	else if (ref_found)
3735	{
3736	error ("Alias has more than one alias reference");
3737	error_found = true;
3738	}
3739	else
3740	ref_found = true;
3741	if (!ref_found)
3742	{
3743	error ("Analyzed alias has no reference");
3744	error_found = true;
3745	}
3746	}
3747
3748	if (analyzed && thunk)
3749	{
3750	if (!callees)
3751	{
3752	error ("No edge out of thunk node");
3753	error_found = true;
3754	}
3755	else if (callees->next_callee)
3756	{
3757	error ("More than one edge out of thunk node");
3758	error_found = true;
3759	}
3760	if (gimple_has_body_p (decl) && !inlined_to)
3761	{
3762	error ("Thunk is not supposed to have body");
3763	error_found = true;
3764	}
3765	}
3766	else if (analyzed && gimple_has_body_p (decl)
3767	&& !TREE_ASM_WRITTEN (decl)
3768	&& (!DECL_EXTERNAL (decl) || inlined_to)
3769	&& !flag_wpa)
3770	{
3771	if ((this_cfun->curr_properties & PROP_assumptions_done) != 0)
3772	;
3773	else if (this_cfun->cfg)
3774	{
3775	hash_set<gimple *> stmts;
3776
3777	/* Reach the trees by walking over the CFG, and note the
3778	enclosing basic-blocks in the call edges. */
3779	FOR_EACH_BB_FN (this_block, this_cfun)
3780	{
3781	for (gsi = gsi_start_phis (this_block);
3782	!gsi_end_p (i: gsi); gsi_next (i: &gsi))
3783	stmts.add (k: gsi_stmt (i: gsi));
3784	for (gsi = gsi_start_bb (bb: this_block);
3785	!gsi_end_p (i: gsi);
3786	gsi_next (i: &gsi))
3787	{
3788	gimple *stmt = gsi_stmt (i: gsi);
3789	stmts.add (k: stmt);
3790	if (is_gimple_call (gs: stmt))
3791	{
3792	cgraph_edge *e = get_edge (call_stmt: stmt);
3793	tree decl = gimple_call_fndecl (gs: stmt);
3794	if (e)
3795	{
3796	if (e->aux)
3797	{
3798	error ("shared call_stmt:");
3799	cgraph_debug_gimple_stmt (this_cfun, stmt);
3800	error_found = true;
3801	}
3802	if (!e->indirect_unknown_callee)
3803	{
3804	if (e->verify_corresponds_to_fndecl (decl))
3805	{
3806	error ("edge points to wrong declaration:");
3807	debug_tree (e->callee->decl);
3808	fprintf (stderr,format: " Instead of:");
3809	debug_tree (decl);
3810	error_found = true;
3811	}
3812	}
3813	else if (decl)
3814	{
3815	error ("an indirect edge with unknown callee "
3816	"corresponding to a call_stmt with "
3817	"a known declaration:");
3818	error_found = true;
3819	cgraph_debug_gimple_stmt (this_cfun, stmt: e->call_stmt);
3820	}
3821	e->aux = (void *)1;
3822	}
3823	else if (decl)
3824	{
3825	error ("missing callgraph edge for call stmt:");
3826	cgraph_debug_gimple_stmt (this_cfun, stmt);
3827	error_found = true;
3828	}
3829	}
3830	}
3831	}
3832	for (i = 0; iterate_reference (i, ref); i++)
3833	if (ref->stmt && !stmts.contains (k: ref->stmt))
3834	{
3835	error ("reference to dead statement");
3836	cgraph_debug_gimple_stmt (this_cfun, stmt: ref->stmt);
3837	error_found = true;
3838	}
3839	}
3840	else
3841	/* No CFG available?! */
3842	gcc_unreachable ();
3843
3844	for (e = callees; e; e = e->next_callee)
3845	{
3846	if (!e->aux && !e->speculative)
3847	{
3848	error ("edge %s->%s has no corresponding call_stmt",
3849	identifier_to_locale (e->caller->name ()),
3850	identifier_to_locale (e->callee->name ()));
3851	cgraph_debug_gimple_stmt (this_cfun, stmt: e->call_stmt);
3852	error_found = true;
3853	}
3854	e->aux = 0;
3855	}
3856	for (e = indirect_calls; e; e = e->next_callee)
3857	{
3858	if (!e->aux && !e->speculative)
3859	{
3860	error ("an indirect edge from %s has no corresponding call_stmt",
3861	identifier_to_locale (e->caller->name ()));
3862	cgraph_debug_gimple_stmt (this_cfun, stmt: e->call_stmt);
3863	error_found = true;
3864	}
3865	e->aux = 0;
3866	}
3867	}
3868
3869	if (nested_function_info *info = nested_function_info::get (node: this))
3870	{
3871	if (info->nested != NULL)
3872	{
3873	for (cgraph_node *n = info->nested; n != NULL;
3874	n = next_nested_function (node: n))
3875	{
3876	nested_function_info *ninfo = nested_function_info::get (node: n);
3877	if (ninfo->origin == NULL)
3878	{
3879	error ("missing origin for a node in a nested list");
3880	error_found = true;
3881	}
3882	else if (ninfo->origin != this)
3883	{
3884	error ("origin points to a different parent");
3885	error_found = true;
3886	break;
3887	}
3888	}
3889	}
3890	if (info->next_nested != NULL && info->origin == NULL)
3891	{
3892	error ("missing origin for a node in a nested list");
3893	error_found = true;
3894	}
3895	}
3896
3897	if (error_found)
3898	{
3899	dump (stderr);
3900	internal_error ("verify_cgraph_node failed");
3901	}
3902	timevar_pop (tv: TV_CGRAPH_VERIFY);
3903	}
3904
3905	/* Verify whole cgraph structure. */
3906	DEBUG_FUNCTION void
3907	cgraph_node::verify_cgraph_nodes (void)
3908	{
3909	cgraph_node *node;
3910
3911	if (seen_error ())
3912	return;
3913
3914	FOR_EACH_FUNCTION (node)
3915	node->verify ();
3916	}
3917
3918	#if __GNUC__ >= 10
3919	# pragma GCC diagnostic pop
3920	#endif
3921
3922	/* Walk the alias chain to return the function cgraph_node is alias of.
3923	Walk through thunks, too.
3924	When AVAILABILITY is non-NULL, get minimal availability in the chain.
3925	When REF is non-NULL, assume that reference happens in symbol REF
3926	when determining the availability. */
3927
3928	cgraph_node *
3929	cgraph_node::function_symbol (enum availability *availability,
3930	struct symtab_node *ref)
3931	{
3932	cgraph_node *node = ultimate_alias_target (availability, ref);
3933
3934	while (node->thunk)
3935	{
3936	enum availability a;
3937
3938	ref = node;
3939	node = node->callees->callee;
3940	node = node->ultimate_alias_target (availability: availability ? &a : NULL, ref);
3941	if (availability && a < *availability)
3942	*availability = a;
3943	}
3944	return node;
3945	}
3946
3947	/* Walk the alias chain to return the function cgraph_node is alias of.
3948	Walk through non virtual thunks, too. Thus we return either a function
3949	or a virtual thunk node.
3950	When AVAILABILITY is non-NULL, get minimal availability in the chain.
3951	When REF is non-NULL, assume that reference happens in symbol REF
3952	when determining the availability. */
3953
3954	cgraph_node *
3955	cgraph_node::function_or_virtual_thunk_symbol
3956	(enum availability *availability,
3957	struct symtab_node *ref)
3958	{
3959	cgraph_node *node = ultimate_alias_target (availability, ref);
3960
3961	while (node->thunk && !thunk_info::get (node)->virtual_offset_p)
3962	{
3963	enum availability a;
3964
3965	ref = node;
3966	node = node->callees->callee;
3967	node = node->ultimate_alias_target (availability: availability ? &a : NULL, ref);
3968	if (availability && a < *availability)
3969	*availability = a;
3970	}
3971	return node;
3972	}
3973
3974	/* When doing LTO, read cgraph_node's body from disk if it is not already
3975	present. Also perform any necessary clone materializations. */
3976
3977	bool
3978	cgraph_node::get_untransformed_body ()
3979	{
3980	lto_file_decl_data *file_data;
3981	const char *data, *name;
3982	size_t len;
3983	tree decl = this->decl;
3984
3985	/* See if there is clone to be materialized.
3986	(inline clones does not need materialization, but we can be seeing
3987	an inline clone of real clone). */
3988	cgraph_node *p = this;
3989	for (cgraph_node *c = clone_of; c; c = c->clone_of)
3990	{
3991	if (c->decl != decl)
3992	p->materialize_clone ();
3993	p = c;
3994	}
3995
3996	/* Check if body is already there. Either we have gimple body or
3997	the function is thunk and in that case we set DECL_ARGUMENTS. */
3998	if (DECL_ARGUMENTS (decl) || gimple_has_body_p (decl))
3999	return false;
4000
4001	gcc_assert (in_lto_p && !DECL_RESULT (decl));
4002
4003	timevar_push (tv: TV_IPA_LTO_GIMPLE_IN);
4004
4005	file_data = lto_file_data;
4006	name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4007
4008	/* We may have renamed the declaration, e.g., a static function. */
4009	name = lto_get_decl_name_mapping (file_data, name);
4010	struct lto_in_decl_state *decl_state
4011	= lto_get_function_in_decl_state (file_data, decl);
4012
4013	cgraph_node *origin = this;
4014	while (origin->clone_of)
4015	origin = origin->clone_of;
4016
4017	int stream_order = origin->order - file_data->order_base;
4018	data = lto_get_section_data (file_data, LTO_section_function_body,
4019	name, stream_order, &len,
4020	decompress: decl_state->compressed);
4021	if (!data)
4022	fatal_error (input_location, "%s: section %s.%d is missing",
4023	file_data->file_name, name, stream_order);
4024
4025	gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
4026
4027	if (!quiet_flag)
4028	fprintf (stderr, format: " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4029	lto_input_function_body (file_data, this, data);
4030	lto_stats.num_function_bodies++;
4031	lto_free_section_data (file_data, LTO_section_function_body, name,
4032	data, len, decompress: decl_state->compressed);
4033	lto_free_function_in_decl_state_for_node (this);
4034	/* Keep lto file data so ipa-inline-analysis knows about cross module
4035	inlining. */
4036
4037	timevar_pop (tv: TV_IPA_LTO_GIMPLE_IN);
4038
4039	return true;
4040	}
4041
4042	/* Prepare function body. When doing LTO, read cgraph_node's body from disk
4043	if it is not already present. When some IPA transformations are scheduled,
4044	apply them. */
4045
4046	bool
4047	cgraph_node::get_body (void)
4048	{
4049	bool updated;
4050
4051	updated = get_untransformed_body ();
4052
4053	/* Getting transformed body makes no sense for inline clones;
4054	we should never use this on real clones because they are materialized
4055	early.
4056	TODO: Materializing clones here will likely lead to smaller LTRANS
4057	footprint. */
4058	gcc_assert (!inlined_to && !clone_of);
4059	if (ipa_transforms_to_apply.exists ())
4060	{
4061	opt_pass *saved_current_pass = current_pass;
4062	FILE *saved_dump_file = dump_file;
4063	const char *saved_dump_file_name = dump_file_name;
4064	dump_flags_t saved_dump_flags = dump_flags;
4065	dump_file_name = NULL;
4066	set_dump_file (NULL);
4067
4068	push_cfun (DECL_STRUCT_FUNCTION (decl));
4069
4070	update_ssa (TODO_update_ssa_only_virtuals);
4071	execute_all_ipa_transforms (true);
4072	cgraph_edge::rebuild_edges ();
4073	free_dominance_info (CDI_DOMINATORS);
4074	free_dominance_info (CDI_POST_DOMINATORS);
4075	pop_cfun ();
4076	updated = true;
4077
4078	current_pass = saved_current_pass;
4079	set_dump_file (saved_dump_file);
4080	dump_file_name = saved_dump_file_name;
4081	dump_flags = saved_dump_flags;
4082	}
4083	return updated;
4084	}
4085
4086	/* Return the DECL_STRUCT_FUNCTION of the function. */
4087
4088	struct function *
4089	cgraph_node::get_fun () const
4090	{
4091	const cgraph_node *node = this;
4092	struct function *fun = DECL_STRUCT_FUNCTION (node->decl);
4093
4094	while (!fun && node->clone_of)
4095	{
4096	node = node->clone_of;
4097	fun = DECL_STRUCT_FUNCTION (node->decl);
4098	}
4099
4100	return fun;
4101	}
4102
4103	/* Reset all state within cgraph.cc so that we can rerun the compiler
4104	within the same process. For use by toplev::finalize. */
4105
4106	void
4107	cgraph_cc_finalize (void)
4108	{
4109	nested_function_info::release ();
4110	thunk_info::release ();
4111	clone_info::release ();
4112	symtab = NULL;
4113
4114	x_cgraph_nodes_queue = NULL;
4115
4116	cgraph_fnver_htab = NULL;
4117	version_info_node = NULL;
4118	}
4119
4120	/* A worker for call_for_symbol_and_aliases. */
4121
4122	bool
4123	cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
4124	void *),
4125	void *data,
4126	bool include_overwritable)
4127	{
4128	ipa_ref *ref;
4129	FOR_EACH_ALIAS (this, ref)
4130	{
4131	cgraph_node *alias = dyn_cast <cgraph_node *> (p: ref->referring);
4132	if (include_overwritable
4133	|| alias->get_availability () > AVAIL_INTERPOSABLE)
4134	if (alias->call_for_symbol_and_aliases (callback, data,
4135	include_overwritable))
4136	return true;
4137	}
4138	return false;
4139	}
4140
4141	/* Return true if NODE has thunk. */
4142
4143	bool
4144	cgraph_node::has_thunk_p (cgraph_node *node, void *)
4145	{
4146	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
4147	if (e->caller->thunk)
4148	return true;
4149	return false;
4150	}
4151
4152	/* Expected frequency of executions within the function. */
4153
4154	sreal
4155	cgraph_edge::sreal_frequency ()
4156	{
4157	return count.to_sreal_scale (in: caller->inlined_to
4158	? caller->inlined_to->count
4159	: caller->count);
4160	}
4161
4162
4163	/* During LTO stream in this can be used to check whether call can possibly
4164	be internal to the current translation unit. */
4165
4166	bool
4167	cgraph_edge::possibly_call_in_translation_unit_p (void)
4168	{
4169	gcc_checking_assert (in_lto_p && caller->prevailing_p ());
4170
4171	/* While incremental linking we may end up getting function body later. */
4172	if (flag_incremental_link == INCREMENTAL_LINK_LTO)
4173	return true;
4174
4175	/* We may be smarter here and avoid streaming in indirect calls we can't
4176	track, but that would require arranging streaming the indirect call
4177	summary first. */
4178	if (!callee)
4179	return true;
4180
4181	/* If callee is local to the original translation unit, it will be
4182	defined. */
4183	if (!TREE_PUBLIC (callee->decl) && !DECL_EXTERNAL (callee->decl))
4184	return true;
4185
4186	/* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
4187	yet) and see if it is a definition. In fact we may also resolve aliases,
4188	but that is probably not too important. */
4189	symtab_node *node = callee;
4190	for (int n = 10; node->previous_sharing_asm_name && n ; n--)
4191	node = node->previous_sharing_asm_name;
4192	if (node->previous_sharing_asm_name)
4193	node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee->decl));
4194	gcc_assert (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl));
4195	return node->get_availability () >= AVAIL_INTERPOSABLE;
4196	}
4197
4198	/* Return num_speculative_targets of this edge. */
4199
4200	int
4201	cgraph_edge::num_speculative_call_targets_p (void)
4202	{
4203	return indirect_info ? indirect_info->num_speculative_call_targets : 0;
4204	}
4205
4206	/* Check if function calls comdat local. This is used to recompute
4207	calls_comdat_local flag after function transformations. */
4208	bool
4209	cgraph_node::check_calls_comdat_local_p ()
4210	{
4211	for (cgraph_edge *e = callees; e; e = e->next_callee)
4212	if (e->inline_failed
4213	? e->callee->comdat_local_p ()
4214	: e->callee->check_calls_comdat_local_p ())
4215	return true;
4216	return false;
4217	}
4218
4219	/* Return true if this node represents a former, i.e. an expanded, thunk. */
4220
4221	bool
4222	cgraph_node::former_thunk_p (void)
4223	{
4224	if (thunk)
4225	return false;
4226	thunk_info *i = thunk_info::get (node: this);
4227	if (!i)
4228	return false;
4229	gcc_checking_assert (i->fixed_offset || i->virtual_offset_p
4230	|| i->indirect_offset);
4231	return true;
4232	}
4233
4234	/* A stashed copy of "symtab" for use by selftest::symbol_table_test.
4235	This needs to be a global so that it can be a GC root, and thus
4236	prevent the stashed copy from being garbage-collected if the GC runs
4237	during a symbol_table_test. */
4238
4239	symbol_table *saved_symtab;
4240
4241	#if CHECKING_P
4242
4243	namespace selftest {
4244
4245	/* class selftest::symbol_table_test. */
4246
4247	/* Constructor. Store the old value of symtab, and create a new one. */
4248
4249	symbol_table_test::symbol_table_test ()
4250	{
4251	gcc_assert (saved_symtab == NULL);
4252	saved_symtab = symtab;
4253	symtab = new (ggc_alloc<symbol_table> ()) symbol_table ();
4254	}
4255
4256	/* Destructor. Restore the old value of symtab. */
4257
4258	symbol_table_test::~symbol_table_test ()
4259	{
4260	gcc_assert (saved_symtab != NULL);
4261	symtab = saved_symtab;
4262	saved_symtab = NULL;
4263	}
4264
4265	/* Verify that symbol_table_test works. */
4266
4267	static void
4268	test_symbol_table_test ()
4269	{
4270	/* Simulate running two selftests involving symbol tables. */
4271	for (int i = 0; i < 2; i++)
4272	{
4273	symbol_table_test stt;
4274	tree test_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
4275	get_identifier ("test_decl"),
4276	build_function_type_list (void_type_node,
4277	NULL_TREE));
4278	cgraph_node *node = cgraph_node::get_create (decl: test_decl);
4279	gcc_assert (node);
4280
4281	/* Verify that the node has order 0 on both iterations,
4282	and thus that nodes have predictable dump names in selftests. */
4283	ASSERT_EQ (node->order, 0);
4284	ASSERT_STREQ (node->dump_name (), "test_decl/0");
4285	}
4286	}
4287
4288	/* Run all of the selftests within this file. */
4289
4290	void
4291	cgraph_cc_tests ()
4292	{
4293	test_symbol_table_test ();
4294	}
4295
4296	} // namespace selftest
4297
4298	#endif /* CHECKING_P */
4299
4300	#include "gt-cgraph.h"
4301