1	/* Symbol table.
2	Copyright (C) 2012-2024 Free Software Foundation, Inc.
3	Contributed by Jan Hubicka
4
5	This file is part of GCC.
6
7	GCC is free software; you can redistribute it and/or modify it under
8	the terms of the GNU General Public License as published by the Free
9	Software Foundation; either version 3, or (at your option) any later
10	version.
11
12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15	for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with GCC; see the file COPYING3. If not see
19	<http://www.gnu.org/licenses/>. */
20
21	#include "config.h"
22	#include "system.h"
23	#include "coretypes.h"
24	#include "backend.h"
25	#include "target.h"
26	#include "rtl.h"
27	#include "tree.h"
28	#include "gimple.h"
29	#include "timevar.h"
30	#include "cgraph.h"
31	#include "lto-streamer.h"
32	#include "print-tree.h"
33	#include "varasm.h"
34	#include "langhooks.h"
35	#include "output.h"
36	#include "ipa-utils.h"
37	#include "calls.h"
38	#include "stringpool.h"
39	#include "attribs.h"
40	#include "builtins.h"
41	#include "fold-const.h"
42
43	static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
44
45	const char * const ld_plugin_symbol_resolution_names[]=
46	{
47	"",
48	"undef",
49	"prevailing_def",
50	"prevailing_def_ironly",
51	"preempted_reg",
52	"preempted_ir",
53	"resolved_ir",
54	"resolved_exec",
55	"resolved_dyn",
56	"prevailing_def_ironly_exp"
57	};
58
59	/* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
60	until we find an identifier that is not itself a transparent alias. */
61
62	static inline tree
63	ultimate_transparent_alias_target (tree alias)
64	{
65	tree target = alias;
66
67	while (IDENTIFIER_TRANSPARENT_ALIAS (target))
68	{
69	gcc_checking_assert (TREE_CHAIN (target));
70	target = TREE_CHAIN (target);
71	}
72	gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
73	&& ! TREE_CHAIN (target));
74
75	return target;
76	}
77
78
79	/* Hash asmnames ignoring the user specified marks. */
80
81	hashval_t
82	symbol_table::decl_assembler_name_hash (const_tree asmname)
83	{
84	if (IDENTIFIER_POINTER (asmname)[0] == '*')
85	{
86	const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
87	size_t ulp_len = strlen (s: user_label_prefix);
88
89	if (ulp_len == 0)
90	;
91	else if (strncmp (s1: decl_str, s2: user_label_prefix, n: ulp_len) == 0)
92	decl_str += ulp_len;
93
94	return htab_hash_string (decl_str);
95	}
96
97	return htab_hash_string (IDENTIFIER_POINTER (asmname));
98	}
99
100	/* Return true if assembler names NAME1 and NAME2 leads to the same symbol
101	name. */
102
103	bool
104	symbol_table::assembler_names_equal_p (const char *name1, const char *name2)
105	{
106	if (name1 != name2)
107	{
108	if (name1[0] == '*')
109	{
110	size_t ulp_len = strlen (s: user_label_prefix);
111
112	name1 ++;
113
114	if (ulp_len == 0)
115	;
116	else if (strncmp (s1: name1, s2: user_label_prefix, n: ulp_len) == 0)
117	name1 += ulp_len;
118	else
119	return false;
120	}
121	if (name2[0] == '*')
122	{
123	size_t ulp_len = strlen (s: user_label_prefix);
124
125	name2 ++;
126
127	if (ulp_len == 0)
128	;
129	else if (strncmp (s1: name2, s2: user_label_prefix, n: ulp_len) == 0)
130	name2 += ulp_len;
131	else
132	return false;
133	}
134	return !strcmp (s1: name1, s2: name2);
135	}
136	return true;
137	}
138
139	/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
140
141	bool
142	symbol_table::decl_assembler_name_equal (tree decl, const_tree asmname)
143	{
144	tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
145	const char *decl_str;
146	const char *asmname_str;
147
148	if (decl_asmname == asmname)
149	return true;
150
151	decl_str = IDENTIFIER_POINTER (decl_asmname);
152	asmname_str = IDENTIFIER_POINTER (asmname);
153	return assembler_names_equal_p (name1: decl_str, name2: asmname_str);
154	}
155
156
157	/* Returns nonzero if P1 and P2 are equal. */
158
159	/* Insert NODE to assembler name hash. */
160
161	void
162	symbol_table::insert_to_assembler_name_hash (symtab_node *node,
163	bool with_clones)
164	{
165	if (is_a <varpool_node *> (p: node) && DECL_HARD_REGISTER (node->decl))
166	return;
167	gcc_checking_assert (!node->previous_sharing_asm_name
168	&& !node->next_sharing_asm_name);
169	if (assembler_name_hash)
170	{
171	symtab_node **aslot;
172	cgraph_node *cnode;
173	tree decl = node->decl;
174
175	tree name = DECL_ASSEMBLER_NAME (node->decl);
176
177	/* C++ FE can produce decls without associated assembler name and insert
178	them to symtab to hold section or TLS information. */
179	if (!name)
180	return;
181
182	hashval_t hash = decl_assembler_name_hash (asmname: name);
183	aslot = assembler_name_hash->find_slot_with_hash (comparable: name, hash, insert: INSERT);
184	gcc_assert (*aslot != node);
185	node->next_sharing_asm_name = (symtab_node *)*aslot;
186	if (*aslot != NULL)
187	(*aslot)->previous_sharing_asm_name = node;
188	*aslot = node;
189
190	/* Update also possible inline clones sharing a decl. */
191	cnode = dyn_cast <cgraph_node *> (p: node);
192	if (cnode && cnode->clones && with_clones)
193	for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
194	if (cnode->decl == decl)
195	insert_to_assembler_name_hash (node: cnode, with_clones: true);
196	}
197
198	}
199
200	/* Remove NODE from assembler name hash. */
201
202	void
203	symbol_table::unlink_from_assembler_name_hash (symtab_node *node,
204	bool with_clones)
205	{
206	if (assembler_name_hash)
207	{
208	cgraph_node *cnode;
209	tree decl = node->decl;
210
211	if (node->next_sharing_asm_name)
212	node->next_sharing_asm_name->previous_sharing_asm_name
213	= node->previous_sharing_asm_name;
214	if (node->previous_sharing_asm_name)
215	{
216	node->previous_sharing_asm_name->next_sharing_asm_name
217	= node->next_sharing_asm_name;
218	}
219	else
220	{
221	tree name = DECL_ASSEMBLER_NAME (node->decl);
222	symtab_node **slot;
223
224	if (!name)
225	return;
226
227	hashval_t hash = decl_assembler_name_hash (asmname: name);
228	slot = assembler_name_hash->find_slot_with_hash (comparable: name, hash,
229	insert: NO_INSERT);
230	gcc_assert (*slot == node);
231	if (!node->next_sharing_asm_name)
232	assembler_name_hash->clear_slot (slot);
233	else
234	*slot = node->next_sharing_asm_name;
235	}
236	node->next_sharing_asm_name = NULL;
237	node->previous_sharing_asm_name = NULL;
238
239	/* Update also possible inline clones sharing a decl. */
240	cnode = dyn_cast <cgraph_node *> (p: node);
241	if (cnode && cnode->clones && with_clones)
242	for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
243	if (cnode->decl == decl)
244	unlink_from_assembler_name_hash (node: cnode, with_clones: true);
245	}
246	}
247
248	/* Arrange node to be first in its entry of assembler_name_hash. */
249
250	void
251	symbol_table::symtab_prevail_in_asm_name_hash (symtab_node *node)
252	{
253	unlink_from_assembler_name_hash (node, with_clones: false);
254	insert_to_assembler_name_hash (node, with_clones: false);
255	}
256
257	/* Initialize asm name hash unless. */
258
259	void
260	symbol_table::symtab_initialize_asm_name_hash (void)
261	{
262	symtab_node *node;
263	if (!assembler_name_hash)
264	{
265	assembler_name_hash = hash_table<asmname_hasher>::create_ggc (n: 10);
266	FOR_EACH_SYMBOL (node)
267	insert_to_assembler_name_hash (node, with_clones: false);
268	}
269	}
270
271	/* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
272
273	void
274	symbol_table::change_decl_assembler_name (tree decl, tree name)
275	{
276	symtab_node *node = NULL;
277
278	/* We can have user ASM names on things, like global register variables, that
279	are not in the symbol table. */
280	if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
281	|| TREE_CODE (decl) == FUNCTION_DECL)
282	node = symtab_node::get (decl);
283	if (!DECL_ASSEMBLER_NAME_SET_P (decl))
284	{
285	SET_DECL_ASSEMBLER_NAME (decl, name);
286	if (node)
287	insert_to_assembler_name_hash (node, with_clones: true);
288	}
289	else
290	{
291	if (name == DECL_ASSEMBLER_NAME (decl))
292	return;
293
294	tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl))
295	? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
296	: NULL);
297	if (node)
298	unlink_from_assembler_name_hash (node, with_clones: true);
299
300	const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
301	if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
302	&& DECL_RTL_SET_P (decl))
303	warning (0, "%qD renamed after being referenced in assembly", decl);
304
305	SET_DECL_ASSEMBLER_NAME (decl, name);
306	if (alias)
307	{
308	IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
309	TREE_CHAIN (name) = alias;
310	}
311	/* If we change assembler name, also all transparent aliases must
312	be updated. There are three kinds - those having same assembler name,
313	those being renamed in varasm.cc and weakref being renamed by the
314	assembler. */
315	if (node)
316	{
317	insert_to_assembler_name_hash (node, with_clones: true);
318	ipa_ref *ref;
319	for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++)
320	{
321	struct symtab_node *alias = ref->referring;
322	if (alias->transparent_alias && !alias->weakref
323	&& symbol_table::assembler_names_equal_p
324	(name1: old_name, IDENTIFIER_POINTER (
325	DECL_ASSEMBLER_NAME (alias->decl))))
326	change_decl_assembler_name (decl: alias->decl, name);
327	else if (alias->transparent_alias
328	&& IDENTIFIER_TRANSPARENT_ALIAS (alias->decl))
329	{
330	gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl))
331	&& IDENTIFIER_TRANSPARENT_ALIAS
332	(DECL_ASSEMBLER_NAME (alias->decl)));
333
334	TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) =
335	ultimate_transparent_alias_target
336	(DECL_ASSEMBLER_NAME (node->decl));
337	}
338	#ifdef ASM_OUTPUT_WEAKREF
339	else gcc_assert (!alias->transparent_alias || alias->weakref);
340	#else
341	else gcc_assert (!alias->transparent_alias);
342	#endif
343	}
344	gcc_assert (!node->transparent_alias || !node->definition
345	|| node->weakref
346	|| TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
347	|| symbol_table::assembler_names_equal_p
348	(IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
349	IDENTIFIER_POINTER
350	(DECL_ASSEMBLER_NAME
351	(node->get_alias_target ()->decl))));
352	}
353	}
354	}
355
356	/* Hash sections by their names. */
357
358	hashval_t
359	section_name_hasher::hash (section_hash_entry *n)
360	{
361	return htab_hash_string (n->name);
362	}
363
364	/* Return true if section P1 name equals to P2. */
365
366	bool
367	section_name_hasher::equal (section_hash_entry *n1, const char *name)
368	{
369	return n1->name == name || !strcmp (s1: n1->name, s2: name);
370	}
371
372	/* Bump the reference count on ENTRY so that it is retained. */
373
374	static section_hash_entry *
375	retain_section_hash_entry (section_hash_entry *entry)
376	{
377	entry->ref_count++;
378	return entry;
379	}
380
381	/* Drop the reference count on ENTRY and remove it if the reference
382	count drops to zero. */
383
384	static void
385	release_section_hash_entry (section_hash_entry *entry)
386	{
387	if (entry)
388	{
389	entry->ref_count--;
390	if (!entry->ref_count)
391	{
392	hashval_t hash = htab_hash_string (entry->name);
393	section_hash_entry **slot
394	= symtab->section_hash->find_slot_with_hash (comparable: entry->name,
395	hash, insert: INSERT);
396	ggc_free (entry);
397	symtab->section_hash->clear_slot (slot);
398	}
399	}
400	}
401
402	/* Add node into symbol table. This function is not used directly, but via
403	cgraph/varpool node creation routines. */
404
405	void
406	symtab_node::register_symbol (void)
407	{
408	symtab->register_symbol (node: this);
409
410	if (!decl->decl_with_vis.symtab_node)
411	decl->decl_with_vis.symtab_node = this;
412
413	ref_list.clear ();
414
415	/* Be sure to do this last; C++ FE might create new nodes via
416	DECL_ASSEMBLER_NAME langhook! */
417	symtab->insert_to_assembler_name_hash (node: this, with_clones: false);
418	}
419
420	/* Remove NODE from same comdat group. */
421
422	void
423	symtab_node::remove_from_same_comdat_group (void)
424	{
425	if (same_comdat_group)
426	{
427	symtab_node *prev;
428	for (prev = same_comdat_group;
429	prev->same_comdat_group != this;
430	prev = prev->same_comdat_group)
431	;
432	if (same_comdat_group == prev)
433	prev->same_comdat_group = NULL;
434	else
435	prev->same_comdat_group = same_comdat_group;
436	same_comdat_group = NULL;
437	set_comdat_group (NULL);
438	}
439	}
440
441	/* Remove node from symbol table. This function is not used directly, but via
442	cgraph/varpool node removal routines.
443	INFO is a clone info to attach to new root of clone tree (if any). */
444
445	void
446	symtab_node::unregister (clone_info *info)
447	{
448	remove_all_references ();
449	remove_all_referring ();
450
451	/* Remove reference to section. */
452	set_section_for_node (NULL);
453
454	remove_from_same_comdat_group ();
455
456	symtab->unregister (node: this);
457
458	/* During LTO symtab merging we temporarily corrupt decl to symtab node
459	hash. */
460	gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p);
461	if (decl->decl_with_vis.symtab_node == this)
462	{
463	symtab_node *replacement_node = NULL;
464	if (cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this))
465	replacement_node = cnode->find_replacement (info);
466	decl->decl_with_vis.symtab_node = replacement_node;
467	}
468	if (!is_a <varpool_node *> (p: this) || !DECL_HARD_REGISTER (decl))
469	symtab->unlink_from_assembler_name_hash (node: this, with_clones: false);
470	if (in_init_priority_hash)
471	symtab->init_priority_hash->remove (k: this);
472	}
473
474
475	/* Remove symbol from symbol table. */
476
477	void
478	symtab_node::remove (void)
479	{
480	if (cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this))
481	cnode->remove ();
482	else if (varpool_node *vnode = dyn_cast <varpool_node *> (p: this))
483	vnode->remove ();
484	}
485
486	/* Add NEW_ to the same comdat group that OLD is in. */
487
488	void
489	symtab_node::add_to_same_comdat_group (symtab_node *old_node)
490	{
491	gcc_assert (old_node->get_comdat_group ());
492	gcc_assert (!same_comdat_group);
493	gcc_assert (this != old_node);
494
495	set_comdat_group (old_node->get_comdat_group ());
496	same_comdat_group = old_node;
497	if (!old_node->same_comdat_group)
498	old_node->same_comdat_group = this;
499	else
500	{
501	symtab_node *n;
502	for (n = old_node->same_comdat_group;
503	n->same_comdat_group != old_node;
504	n = n->same_comdat_group)
505	;
506	n->same_comdat_group = this;
507	}
508
509	cgraph_node *n;
510	if (comdat_local_p ()
511	&& (n = dyn_cast <cgraph_node *> (p: this)) != NULL)
512	{
513	for (cgraph_edge *e = n->callers; e; e = e->next_caller)
514	if (e->caller->inlined_to)
515	e->caller->inlined_to->calls_comdat_local = true;
516	else
517	e->caller->calls_comdat_local = true;
518	}
519	}
520
521	/* Dissolve the same_comdat_group list in which NODE resides. */
522
523	void
524	symtab_node::dissolve_same_comdat_group_list (void)
525	{
526	symtab_node *n = this;
527	symtab_node *next;
528
529	if (!same_comdat_group)
530	return;
531	do
532	{
533	next = n->same_comdat_group;
534	n->same_comdat_group = NULL;
535	if (dyn_cast <cgraph_node *> (p: n))
536	dyn_cast <cgraph_node *> (p: n)->calls_comdat_local = false;
537	/* Clear comdat_group for comdat locals, since
538	make_decl_local doesn't. */
539	if (!TREE_PUBLIC (n->decl))
540	n->set_comdat_group (NULL);
541	n = next;
542	}
543	while (n != this);
544	}
545
546	/* Return printable assembler name of NODE.
547	This function is used only for debugging. When assembler name
548	is unknown go with identifier name. */
549
550	const char *
551	symtab_node::asm_name () const
552	{
553	if (!DECL_ASSEMBLER_NAME_SET_P (decl))
554	return name ();
555	return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
556	}
557
558	/* Return printable identifier name. */
559
560	const char *
561	symtab_node::name () const
562	{
563	if (!DECL_NAME (decl))
564	{
565	if (DECL_ASSEMBLER_NAME_SET_P (decl))
566	return asm_name ();
567	else
568	return "<unnamed>";
569	}
570	return lang_hooks.decl_printable_name (decl, 2);
571	}
572
573	const char *
574	symtab_node::get_dump_name (bool asm_name_p) const
575	{
576	#define EXTRA 16
577	const char *fname = asm_name_p ? asm_name () : name ();
578	unsigned l = strlen (s: fname);
579
580	char *s = (char *)ggc_internal_cleared_alloc (s: l + EXTRA);
581	snprintf (s: s, maxlen: l + EXTRA, format: "%s/%d", fname, order);
582
583	return s;
584	}
585
586	const char *
587	symtab_node::dump_name () const
588	{
589	return get_dump_name (asm_name_p: false);
590	}
591
592	const char *
593	symtab_node::dump_asm_name () const
594	{
595	return get_dump_name (asm_name_p: true);
596	}
597
598	/* Return ipa reference from this symtab_node to
599	REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
600	of the use. */
601
602	ipa_ref *
603	symtab_node::create_reference (symtab_node *referred_node,
604	enum ipa_ref_use use_type)
605	{
606	return create_reference (referred_node, use_type, NULL);
607	}
608
609
610	/* Return ipa reference from this symtab_node to
611	REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
612	of the use and STMT the statement (if it exists). */
613
614	ipa_ref *
615	symtab_node::create_reference (symtab_node *referred_node,
616	enum ipa_ref_use use_type, gimple *stmt)
617	{
618	ipa_ref *ref = NULL, *ref2 = NULL;
619	ipa_ref_list *list, *list2;
620	ipa_ref_t *old_references;
621
622	gcc_checking_assert (!stmt || is_a <cgraph_node *> (this));
623	gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
624
625	list = &ref_list;
626	old_references = list->references.address ();
627	list->references.safe_grow (len: list->references.length () + 1, exact: false);
628	ref = &list->references.last ();
629
630	list2 = &referred_node->ref_list;
631
632	/* IPA_REF_ALIAS is always inserted at the beginning of the list. */
633	if(use_type == IPA_REF_ALIAS)
634	{
635	list2->referring.safe_insert (ix: 0, obj: ref);
636	ref->referred_index = 0;
637
638	for (unsigned int i = 1; i < list2->referring.length (); i++)
639	list2->referring[i]->referred_index = i;
640	}
641	else
642	{
643	list2->referring.safe_push (obj: ref);
644	ref->referred_index = list2->referring.length () - 1;
645	}
646
647	ref->referring = this;
648	ref->referred = referred_node;
649	ref->stmt = stmt;
650	ref->lto_stmt_uid = 0;
651	ref->speculative_id = 0;
652	ref->use = use_type;
653	ref->speculative = 0;
654
655	/* If vector was moved in memory, update pointers. */
656	if (old_references != list->references.address ())
657	{
658	int i;
659	for (i = 0; iterate_reference(i, ref&: ref2); i++)
660	ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2;
661	}
662	return ref;
663	}
664
665	ipa_ref *
666	symtab_node::maybe_create_reference (tree val, gimple *stmt)
667	{
668	STRIP_NOPS (val);
669	ipa_ref_use use_type;
670
671	switch (TREE_CODE (val))
672	{
673	case VAR_DECL:
674	use_type = IPA_REF_LOAD;
675	break;
676	case ADDR_EXPR:
677	use_type = IPA_REF_ADDR;
678	break;
679	default:
680	gcc_assert (!handled_component_p (val));
681	return NULL;
682	}
683
684	val = get_base_var (val);
685	if (val && VAR_OR_FUNCTION_DECL_P (val))
686	{
687	symtab_node *referred = symtab_node::get (decl: val);
688	gcc_checking_assert (referred);
689	return create_reference (referred_node: referred, use_type, stmt);
690	}
691	return NULL;
692	}
693
694	/* Clone all references from symtab NODE to this symtab_node. */
695
696	void
697	symtab_node::clone_references (symtab_node *node)
698	{
699	ipa_ref *ref = NULL, *ref2 = NULL;
700	int i;
701	for (i = 0; node->iterate_reference (i, ref); i++)
702	{
703	bool speculative = ref->speculative;
704	unsigned int stmt_uid = ref->lto_stmt_uid;
705	unsigned int spec_id = ref->speculative_id;
706
707	ref2 = create_reference (referred_node: ref->referred, use_type: ref->use, stmt: ref->stmt);
708	ref2->speculative = speculative;
709	ref2->lto_stmt_uid = stmt_uid;
710	ref2->speculative_id = spec_id;
711	}
712	}
713
714	/* Clone all referring from symtab NODE to this symtab_node. */
715
716	void
717	symtab_node::clone_referring (symtab_node *node)
718	{
719	ipa_ref *ref = NULL, *ref2 = NULL;
720	int i;
721	for (i = 0; node->iterate_referring(i, ref); i++)
722	{
723	bool speculative = ref->speculative;
724	unsigned int stmt_uid = ref->lto_stmt_uid;
725	unsigned int spec_id = ref->speculative_id;
726
727	ref2 = ref->referring->create_reference (referred_node: this, use_type: ref->use, stmt: ref->stmt);
728	ref2->speculative = speculative;
729	ref2->lto_stmt_uid = stmt_uid;
730	ref2->speculative_id = spec_id;
731	}
732	}
733
734	/* Clone reference REF to this symtab_node and set its stmt to STMT. */
735
736	ipa_ref *
737	symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
738	{
739	bool speculative = ref->speculative;
740	unsigned int stmt_uid = ref->lto_stmt_uid;
741	unsigned int spec_id = ref->speculative_id;
742	ipa_ref *ref2;
743
744	ref2 = create_reference (referred_node: ref->referred, use_type: ref->use, stmt);
745	ref2->speculative = speculative;
746	ref2->lto_stmt_uid = stmt_uid;
747	ref2->speculative_id = spec_id;
748	return ref2;
749	}
750
751	/* Find the structure describing a reference to REFERRED_NODE of USE_TYPE and
752	associated with statement STMT or LTO_STMT_UID. */
753
754	ipa_ref *
755	symtab_node::find_reference (symtab_node *referred_node,
756	gimple *stmt, unsigned int lto_stmt_uid,
757	enum ipa_ref_use use_type)
758	{
759	ipa_ref *r = NULL;
760	int i;
761
762	for (i = 0; iterate_reference (i, ref&: r); i++)
763	if (r->referred == referred_node
764	&& !r->speculative
765	&& r->use == use_type
766	&& ((stmt && r->stmt == stmt)
767	|| (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid)
768	|| (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid)))
769	return r;
770	return NULL;
771	}
772
773	/* Remove all references that are associated with statement STMT. */
774
775	void
776	symtab_node::remove_stmt_references (gimple *stmt)
777	{
778	ipa_ref *r = NULL;
779	int i = 0;
780
781	while (iterate_reference (i, ref&: r))
782	if (r->stmt == stmt)
783	r->remove_reference ();
784	else
785	i++;
786	}
787
788	/* Remove all stmt references in non-speculative references in THIS
789	and all clones.
790	Those are not maintained during inlining & cloning.
791	The exception are speculative references that are updated along
792	with callgraph edges associated with them. */
793
794	void
795	symtab_node::clear_stmts_in_references (void)
796	{
797	ipa_ref *r = NULL;
798	int i;
799
800	for (i = 0; iterate_reference (i, ref&: r); i++)
801	if (!r->speculative)
802	{
803	r->stmt = NULL;
804	r->lto_stmt_uid = 0;
805	r->speculative_id = 0;
806	}
807	cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
808	if (cnode)
809	{
810	if (cnode->clones)
811	for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
812	cnode->clear_stmts_in_references ();
813	}
814	}
815
816	/* Remove all references in ref list. */
817
818	void
819	symtab_node::remove_all_references (void)
820	{
821	while (ref_list.references.length ())
822	ref_list.references.last ().remove_reference ();
823	ref_list.references.release ();
824	}
825
826	/* Remove all referring items in ref list. */
827
828	void
829	symtab_node::remove_all_referring (void)
830	{
831	while (ref_list.referring.length ())
832	ref_list.referring.last ()->remove_reference ();
833	ref_list.referring.release ();
834	}
835
836	/* Dump references in ref list to FILE. */
837
838	void
839	symtab_node::dump_references (FILE *file)
840	{
841	ipa_ref *ref = NULL;
842	int i;
843	for (i = 0; iterate_reference (i, ref); i++)
844	{
845	fprintf (stream: file, format: "%s (%s) ", ref->referred->dump_asm_name (),
846	ipa_ref_use_name[ref->use]);
847	if (ref->speculative)
848	fprintf (stream: file, format: "(speculative) ");
849	}
850	fprintf (stream: file, format: "\n");
851	}
852
853	/* Dump referring in list to FILE. */
854
855	void
856	symtab_node::dump_referring (FILE *file)
857	{
858	ipa_ref *ref = NULL;
859	int i;
860	for (i = 0; iterate_referring(i, ref); i++)
861	{
862	fprintf (stream: file, format: "%s (%s) ", ref->referring->dump_asm_name (),
863	ipa_ref_use_name[ref->use]);
864	if (ref->speculative)
865	fprintf (stream: file, format: "(speculative) ");
866	}
867	fprintf (stream: file, format: "\n");
868	}
869
870	static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
871
872	/* Dump the visibility of the symbol. */
873
874	const char *
875	symtab_node::get_visibility_string () const
876	{
877	static const char * const visibility_types[]
878	= { "default", "protected", "hidden", "internal" };
879	return visibility_types[DECL_VISIBILITY (decl)];
880	}
881
882	/* Dump the type_name of the symbol. */
883	const char *
884	symtab_node::get_symtab_type_string () const
885	{
886	return symtab_type_names[type];
887	}
888
889	/* Dump base fields of symtab nodes to F. Not to be used directly. */
890
891	void
892	symtab_node::dump_base (FILE *f)
893	{
894	static const char * const visibility_types[] = {
895	"default", "protected", "hidden", "internal"
896	};
897
898	fprintf (stream: f, format: "%s (%s)", dump_asm_name (), name ());
899	if (dump_flags & TDF_ADDRESS)
900	dump_addr (f, " @", (void *)this);
901	fprintf (stream: f, format: "\n Type: %s", symtab_type_names[type]);
902
903	if (definition)
904	fprintf (stream: f, format: " definition");
905	if (analyzed)
906	fprintf (stream: f, format: " analyzed");
907	if (alias)
908	fprintf (stream: f, format: " alias");
909	if (transparent_alias)
910	fprintf (stream: f, format: " transparent_alias");
911	if (weakref)
912	fprintf (stream: f, format: " weakref");
913	if (symver)
914	fprintf (stream: f, format: " symver");
915	if (cpp_implicit_alias)
916	fprintf (stream: f, format: " cpp_implicit_alias");
917	if (alias_target)
918	fprintf (stream: f, format: " target:%s",
919	DECL_P (alias_target)
920	? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
921	(alias_target))
922	: IDENTIFIER_POINTER (alias_target));
923	if (body_removed)
924	fprintf (stream: f, format: "\n Body removed by symtab_remove_unreachable_nodes");
925	fprintf (stream: f, format: "\n Visibility:");
926	if (in_other_partition)
927	fprintf (stream: f, format: " in_other_partition");
928	if (used_from_other_partition)
929	fprintf (stream: f, format: " used_from_other_partition");
930	if (force_output)
931	fprintf (stream: f, format: " force_output");
932	if (forced_by_abi)
933	fprintf (stream: f, format: " forced_by_abi");
934	if (externally_visible)
935	fprintf (stream: f, format: " externally_visible");
936	if (semantic_interposition)
937	fprintf (stream: f, format: " semantic_interposition");
938	if (no_reorder)
939	fprintf (stream: f, format: " no_reorder");
940	if (resolution != LDPR_UNKNOWN)
941	fprintf (stream: f, format: " %s",
942	ld_plugin_symbol_resolution_names[(int)resolution]);
943	if (TREE_ASM_WRITTEN (decl))
944	fprintf (stream: f, format: " asm_written");
945	if (DECL_EXTERNAL (decl))
946	fprintf (stream: f, format: " external");
947	if (TREE_PUBLIC (decl))
948	fprintf (stream: f, format: " public");
949	if (DECL_COMMON (decl))
950	fprintf (stream: f, format: " common");
951	if (DECL_WEAK (decl))
952	fprintf (stream: f, format: " weak");
953	if (DECL_DLLIMPORT_P (decl))
954	fprintf (stream: f, format: " dll_import");
955	if (DECL_COMDAT (decl))
956	fprintf (stream: f, format: " comdat");
957	if (get_comdat_group ())
958	fprintf (stream: f, format: " comdat_group:%s",
959	IDENTIFIER_POINTER (get_comdat_group_id ()));
960	if (DECL_ONE_ONLY (decl))
961	fprintf (stream: f, format: " one_only");
962	if (get_section ())
963	fprintf (stream: f, format: " section:%s",
964	get_section ());
965	if (implicit_section)
966	fprintf (stream: f,format: " (implicit_section)");
967	if (DECL_VISIBILITY_SPECIFIED (decl))
968	fprintf (stream: f, format: " visibility_specified");
969	if (DECL_VISIBILITY (decl))
970	fprintf (stream: f, format: " visibility:%s",
971	visibility_types [DECL_VISIBILITY (decl)]);
972	if (DECL_VIRTUAL_P (decl))
973	fprintf (stream: f, format: " virtual");
974	if (DECL_ARTIFICIAL (decl))
975	fprintf (stream: f, format: " artificial");
976	if (TREE_CODE (decl) == FUNCTION_DECL)
977	{
978	if (DECL_STATIC_CONSTRUCTOR (decl))
979	fprintf (stream: f, format: " constructor");
980	if (DECL_STATIC_DESTRUCTOR (decl))
981	fprintf (stream: f, format: " destructor");
982	}
983	if (ifunc_resolver)
984	fprintf (stream: f, format: " ifunc_resolver");
985	fprintf (stream: f, format: "\n");
986
987	if (same_comdat_group)
988	fprintf (stream: f, format: " Same comdat group as: %s\n",
989	same_comdat_group->dump_asm_name ());
990	if (next_sharing_asm_name)
991	fprintf (stream: f, format: " next sharing asm name: %i\n",
992	next_sharing_asm_name->order);
993	if (previous_sharing_asm_name)
994	fprintf (stream: f, format: " previous sharing asm name: %i\n",
995	previous_sharing_asm_name->order);
996
997	if (address_taken)
998	fprintf (stream: f, format: " Address is taken.\n");
999	if (aux)
1000	{
1001	fprintf (stream: f, format: " Aux:");
1002	dump_addr (f, " @", (void *)aux);
1003	fprintf (stream: f, format: "\n");
1004	}
1005
1006	fprintf (stream: f, format: " References: ");
1007	dump_references (file: f);
1008	fprintf (stream: f, format: " Referring: ");
1009	dump_referring (file: f);
1010	if (lto_file_data)
1011	fprintf (stream: f, format: " Read from file: %s\n",
1012	lto_file_data->file_name);
1013	}
1014
1015	/* Dump symtab node to F. */
1016
1017	void
1018	symtab_node::dump (FILE *f)
1019	{
1020	if (cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this))
1021	cnode->dump (f);
1022	else if (varpool_node *vnode = dyn_cast <varpool_node *> (p: this))
1023	vnode->dump (f);
1024	}
1025
1026	void
1027	symtab_node::dump_graphviz (FILE *f)
1028	{
1029	if (cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this))
1030	cnode->dump_graphviz (f);
1031	}
1032
1033	void
1034	symbol_table::dump (FILE *f)
1035	{
1036	symtab_node *node;
1037	fprintf (stream: f, format: "Symbol table:\n\n");
1038	FOR_EACH_SYMBOL (node)
1039	node->dump (f);
1040	}
1041
1042	void
1043	symbol_table::dump_graphviz (FILE *f)
1044	{
1045	symtab_node *node;
1046	fprintf (stream: f, format: "digraph symtab {\n");
1047	FOR_EACH_SYMBOL (node)
1048	node->dump_graphviz (f);
1049	fprintf (stream: f, format: "}\n");
1050	}
1051
1052	DEBUG_FUNCTION void
1053	symbol_table::debug (void)
1054	{
1055	dump (stderr);
1056	}
1057
1058	/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1059	Return NULL if there's no such node. */
1060
1061	symtab_node *
1062	symtab_node::get_for_asmname (const_tree asmname)
1063	{
1064	symtab_node *node;
1065
1066	symtab->symtab_initialize_asm_name_hash ();
1067	hashval_t hash = symtab->decl_assembler_name_hash (asmname);
1068	symtab_node **slot
1069	= symtab->assembler_name_hash->find_slot_with_hash (comparable: asmname, hash,
1070	insert: NO_INSERT);
1071
1072	if (slot)
1073	{
1074	node = *slot;
1075	return node;
1076	}
1077	return NULL;
1078	}
1079
1080	/* Dump symtab node NODE to stderr. */
1081
1082	DEBUG_FUNCTION void
1083	symtab_node::debug (void)
1084	{
1085	dump (stderr);
1086	}
1087
1088	/* Verify common part of symtab nodes. */
1089
1090	#if __GNUC__ >= 10
1091	/* Disable warnings about missing quoting in GCC diagnostics for
1092	the verification errors. Their format strings don't follow GCC
1093	diagnostic conventions and the calls are ultimately followed by
1094	one to internal_error. */
1095	# pragma GCC diagnostic push
1096	# pragma GCC diagnostic ignored "-Wformat-diag"
1097	#endif
1098
1099	DEBUG_FUNCTION bool
1100	symtab_node::verify_base (void)
1101	{
1102	bool error_found = false;
1103	symtab_node *hashed_node;
1104
1105	if (is_a <cgraph_node *> (p: this))
1106	{
1107	if (TREE_CODE (decl) != FUNCTION_DECL)
1108	{
1109	error ("function symbol is not function");
1110	error_found = true;
1111	}
1112	else if ((lookup_attribute (attr_name: "ifunc", DECL_ATTRIBUTES (decl))
1113	!= NULL)
1114	!= dyn_cast <cgraph_node *> (p: this)->ifunc_resolver)
1115	{
1116	error ("inconsistent %<ifunc%> attribute");
1117	error_found = true;
1118	}
1119	}
1120	else if (is_a <varpool_node *> (p: this))
1121	{
1122	if (!VAR_P (decl))
1123	{
1124	error ("variable symbol is not variable");
1125	error_found = true;
1126	}
1127	}
1128	else
1129	{
1130	error ("node has unknown type");
1131	error_found = true;
1132	}
1133	if (order < 0 || order >= symtab->order)
1134	{
1135	error ("node has invalid order %i", order);
1136	error_found = true;
1137	}
1138
1139	if (symtab->state != LTO_STREAMING)
1140	{
1141	hashed_node = symtab_node::get (decl);
1142	if (!hashed_node)
1143	{
1144	error ("node not found node->decl->decl_with_vis.symtab_node");
1145	error_found = true;
1146	}
1147	if (hashed_node != this
1148	&& (!is_a <cgraph_node *> (p: this)
1149	|| !dyn_cast <cgraph_node *> (p: this)->clone_of
1150	|| dyn_cast <cgraph_node *> (p: this)->clone_of->decl != decl))
1151	{
1152	error ("node differs from node->decl->decl_with_vis.symtab_node");
1153	error_found = true;
1154	}
1155	}
1156	if (symtab->assembler_name_hash)
1157	{
1158	hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
1159	if (hashed_node)
1160	{
1161	if (hashed_node->previous_sharing_asm_name)
1162	{
1163	error ("assembler name hash list corrupted");
1164	error_found = true;
1165	}
1166	else if (previous_sharing_asm_name == NULL)
1167	{
1168	if (hashed_node != this)
1169	{
1170	error ("assembler name hash list corrupted");
1171	error_found = true;
1172	}
1173	}
1174	else if (!(is_a <varpool_node *> (p: this) && DECL_HARD_REGISTER (decl)))
1175	{
1176	if (!asmname_hasher::equal (n: previous_sharing_asm_name,
1177	DECL_ASSEMBLER_NAME (decl)))
1178	{
1179	error ("node not found in symtab assembler name hash");
1180	error_found = true;
1181	}
1182	}
1183	}
1184	}
1185	if (previous_sharing_asm_name
1186	&& previous_sharing_asm_name->next_sharing_asm_name != this)
1187	{
1188	error ("double linked list of assembler names corrupted");
1189	error_found = true;
1190	}
1191	if (body_removed && definition)
1192	{
1193	error ("node has body_removed but is definition");
1194	error_found = true;
1195	}
1196	if (analyzed && !definition)
1197	{
1198	error ("node is analyzed but it is not a definition");
1199	error_found = true;
1200	}
1201	if (cpp_implicit_alias && !alias)
1202	{
1203	error ("node is alias but not implicit alias");
1204	error_found = true;
1205	}
1206	if (alias && !definition && !weakref)
1207	{
1208	error ("node is alias but not definition");
1209	error_found = true;
1210	}
1211	if (weakref && !transparent_alias)
1212	{
1213	error ("node is weakref but not an transparent_alias");
1214	error_found = true;
1215	}
1216	if (transparent_alias && !alias)
1217	{
1218	error ("node is transparent_alias but not an alias");
1219	error_found = true;
1220	}
1221	if (symver && !alias)
1222	{
1223	error ("node is symver but not alias");
1224	error_found = true;
1225	}
1226	/* Limitation of gas requires us to output targets of symver aliases as
1227	global symbols. This is binutils PR 25295. */
1228	if (symver
1229	&& (!TREE_PUBLIC (get_alias_target ()->decl)
1230	|| DECL_VISIBILITY (get_alias_target ()->decl) != VISIBILITY_DEFAULT))
1231	{
1232	error ("symver target is not exported with default visibility");
1233	error_found = true;
1234	}
1235	if (symver
1236	&& (!TREE_PUBLIC (decl)
1237	|| DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT))
1238	{
1239	error ("symver is not exported with default visibility");
1240	error_found = true;
1241	}
1242	if (same_comdat_group)
1243	{
1244	symtab_node *n = same_comdat_group;
1245
1246	if (!n->get_comdat_group ())
1247	{
1248	error ("node is in same_comdat_group list but has no comdat_group");
1249	error_found = true;
1250	}
1251	if (n->get_comdat_group () != get_comdat_group ())
1252	{
1253	error ("same_comdat_group list across different groups");
1254	error_found = true;
1255	}
1256	if (n->type != type)
1257	{
1258	error ("mixing different types of symbol in same comdat groups is not supported");
1259	error_found = true;
1260	}
1261	if (n == this)
1262	{
1263	error ("node is alone in a comdat group");
1264	error_found = true;
1265	}
1266	do
1267	{
1268	if (!n->same_comdat_group)
1269	{
1270	error ("same_comdat_group is not a circular list");
1271	error_found = true;
1272	break;
1273	}
1274	n = n->same_comdat_group;
1275	}
1276	while (n != this);
1277	if (comdat_local_p ())
1278	{
1279	ipa_ref *ref = NULL;
1280
1281	for (int i = 0; iterate_referring (i, ref); ++i)
1282	{
1283	if (!in_same_comdat_group_p (target: ref->referring))
1284	{
1285	error ("comdat-local symbol referred to by %s outside its "
1286	"comdat",
1287	identifier_to_locale (ref->referring->name()));
1288	error_found = true;
1289	}
1290	}
1291	}
1292	}
1293	if (implicit_section && !get_section ())
1294	{
1295	error ("implicit_section flag is set but section isn%'t");
1296	error_found = true;
1297	}
1298	if (get_section () && get_comdat_group ()
1299	&& !implicit_section
1300	&& !lookup_attribute (attr_name: "section", DECL_ATTRIBUTES (decl)))
1301	{
1302	error ("Both section and comdat group is set");
1303	error_found = true;
1304	}
1305	/* TODO: Add string table for sections, so we do not keep holding duplicated
1306	strings. */
1307	if (alias && definition
1308	&& get_section () != get_alias_target ()->get_section ()
1309	&& (!get_section()
1310	|| !get_alias_target ()->get_section ()
1311	|| strcmp (s1: get_section(),
1312	s2: get_alias_target ()->get_section ())))
1313	{
1314	error ("Alias and target%'s section differs");
1315	get_alias_target ()->dump (stderr);
1316	error_found = true;
1317	}
1318	if (alias && definition
1319	&& get_comdat_group () != get_alias_target ()->get_comdat_group ())
1320	{
1321	error ("Alias and target%'s comdat groups differs");
1322	get_alias_target ()->dump (stderr);
1323	error_found = true;
1324	}
1325	if (transparent_alias && definition && !weakref)
1326	{
1327	symtab_node *to = get_alias_target ();
1328	const char *name1
1329	= IDENTIFIER_POINTER (
1330	ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
1331	const char *name2
1332	= IDENTIFIER_POINTER (
1333	ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
1334	if (!symbol_table::assembler_names_equal_p (name1, name2))
1335	{
1336	error ("Transparent alias and target%'s assembler names differs");
1337	get_alias_target ()->dump (stderr);
1338	error_found = true;
1339	}
1340	}
1341	if (transparent_alias && definition
1342	&& get_alias_target()->transparent_alias && get_alias_target()->analyzed)
1343	{
1344	error ("Chained transparent aliases");
1345	get_alias_target ()->dump (stderr);
1346	error_found = true;
1347	}
1348
1349	return error_found;
1350	}
1351
1352	/* Verify consistency of NODE. */
1353
1354	DEBUG_FUNCTION void
1355	symtab_node::verify (void)
1356	{
1357	if (seen_error ())
1358	return;
1359
1360	timevar_push (tv: TV_CGRAPH_VERIFY);
1361	if (cgraph_node *node = dyn_cast <cgraph_node *> (p: this))
1362	node->verify_node ();
1363	else
1364	if (verify_base ())
1365	{
1366	debug ();
1367	internal_error ("symtab_node::verify failed");
1368	}
1369	timevar_pop (tv: TV_CGRAPH_VERIFY);
1370	}
1371
1372	/* Return true and set *DATA to true if NODE is an ifunc resolver. */
1373
1374	static bool
1375	check_ifunc_resolver (cgraph_node *node, void *data)
1376	{
1377	if (node->ifunc_resolver)
1378	{
1379	bool *is_ifunc_resolver = (bool *) data;
1380	*is_ifunc_resolver = true;
1381	return true;
1382	}
1383	return false;
1384	}
1385
1386	static bitmap ifunc_ref_map;
1387
1388	/* Return true if any caller of NODE is an ifunc resolver. */
1389
1390	static bool
1391	is_caller_ifunc_resolver (cgraph_node *node)
1392	{
1393	bool is_ifunc_resolver = false;
1394
1395	for (cgraph_edge *e = node->callers; e; e = e->next_caller)
1396	{
1397	/* Return true if caller is known to be an IFUNC resolver. */
1398	if (e->caller->called_by_ifunc_resolver)
1399	return true;
1400
1401	/* Check for recursive call. */
1402	if (e->caller == node)
1403	continue;
1404
1405	/* Skip if it has been visited. */
1406	unsigned int uid = e->caller->get_uid ();
1407	if (!bitmap_set_bit (ifunc_ref_map, uid))
1408	continue;
1409
1410	if (is_caller_ifunc_resolver (node: e->caller))
1411	{
1412	/* Return true if caller is an IFUNC resolver. */
1413	e->caller->called_by_ifunc_resolver = true;
1414	return true;
1415	}
1416
1417	/* Check if caller's alias is an IFUNC resolver. */
1418	e->caller->call_for_symbol_and_aliases (callback: check_ifunc_resolver,
1419	data: &is_ifunc_resolver,
1420	include_overwritable: true);
1421	if (is_ifunc_resolver)
1422	{
1423	/* Return true if caller's alias is an IFUNC resolver. */
1424	e->caller->called_by_ifunc_resolver = true;
1425	return true;
1426	}
1427	}
1428
1429	return false;
1430	}
1431
1432	/* Check symbol table for callees of IFUNC resolvers. */
1433
1434	void
1435	symtab_node::check_ifunc_callee_symtab_nodes (void)
1436	{
1437	symtab_node *node;
1438
1439	bitmap_obstack_initialize (NULL);
1440	ifunc_ref_map = BITMAP_ALLOC (NULL);
1441
1442	FOR_EACH_SYMBOL (node)
1443	{
1444	cgraph_node *cnode = dyn_cast <cgraph_node *> (p: node);
1445	if (!cnode)
1446	continue;
1447
1448	unsigned int uid = cnode->get_uid ();
1449	if (bitmap_bit_p (ifunc_ref_map, uid))
1450	continue;
1451	bitmap_set_bit (ifunc_ref_map, uid);
1452
1453	bool is_ifunc_resolver = false;
1454	cnode->call_for_symbol_and_aliases (callback: check_ifunc_resolver,
1455	data: &is_ifunc_resolver, include_overwritable: true);
1456	if (is_ifunc_resolver || is_caller_ifunc_resolver (node: cnode))
1457	cnode->called_by_ifunc_resolver = true;
1458	}
1459
1460	BITMAP_FREE (ifunc_ref_map);
1461	bitmap_obstack_release (NULL);
1462	}
1463
1464	/* Verify symbol table for internal consistency. */
1465
1466	DEBUG_FUNCTION void
1467	symtab_node::verify_symtab_nodes (void)
1468	{
1469	symtab_node *node;
1470	hash_map<tree, symtab_node *> comdat_head_map (251);
1471	asm_node *anode;
1472
1473	for (anode = symtab->first_asm_symbol (); anode; anode = anode->next)
1474	if (anode->order < 0 || anode->order >= symtab->order)
1475	{
1476	error ("invalid order in asm node %i", anode->order);
1477	internal_error ("symtab_node::verify failed");
1478	}
1479
1480	FOR_EACH_SYMBOL (node)
1481	{
1482	node->verify ();
1483	if (node->get_comdat_group ())
1484	{
1485	symtab_node **entry, *s;
1486	bool existed;
1487
1488	entry = &comdat_head_map.get_or_insert (k: node->get_comdat_group (),
1489	existed: &existed);
1490	if (!existed)
1491	*entry = node;
1492	else if (!DECL_EXTERNAL (node->decl))
1493	{
1494	for (s = (*entry)->same_comdat_group;
1495	s != NULL && s != node && s != *entry;
1496	s = s->same_comdat_group)
1497	;
1498	if (!s || s == *entry)
1499	{
1500	error ("Two symbols with same comdat_group are not linked by "
1501	"the same_comdat_group list.");
1502	(*entry)->debug ();
1503	node->debug ();
1504	internal_error ("symtab_node::verify failed");
1505	}
1506	}
1507	}
1508	}
1509	}
1510
1511	#if __GNUC__ >= 10
1512	# pragma GCC diagnostic pop
1513	#endif
1514
1515	/* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1516	but other code such as notice_global_symbol generates rtl. */
1517
1518	void
1519	symtab_node::make_decl_local (void)
1520	{
1521	rtx rtl, symbol;
1522
1523	if (weakref)
1524	{
1525	weakref = false;
1526	IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
1527	TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
1528	symtab->change_decl_assembler_name
1529	(decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
1530	DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
1531	DECL_ATTRIBUTES (decl));
1532	}
1533	/* Avoid clearing comdat_groups on comdat-local decls. */
1534	else if (TREE_PUBLIC (decl) == 0)
1535	return;
1536
1537	/* Localizing a symbol also make all its transparent aliases local. */
1538	ipa_ref *ref;
1539	for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1540	{
1541	struct symtab_node *alias = ref->referring;
1542	if (alias->transparent_alias)
1543	alias->make_decl_local ();
1544	}
1545
1546	if (VAR_P (decl))
1547	{
1548	DECL_COMMON (decl) = 0;
1549	/* ADDRESSABLE flag is not defined for public symbols. */
1550	TREE_ADDRESSABLE (decl) = 1;
1551	TREE_STATIC (decl) = 1;
1552	}
1553	else
1554	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1555
1556	DECL_COMDAT (decl) = 0;
1557	DECL_WEAK (decl) = 0;
1558	DECL_EXTERNAL (decl) = 0;
1559	DECL_VISIBILITY_SPECIFIED (decl) = 0;
1560	DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
1561	TREE_PUBLIC (decl) = 0;
1562	DECL_DLLIMPORT_P (decl) = 0;
1563	if (!DECL_RTL_SET_P (decl))
1564	return;
1565
1566	/* Update rtl flags. */
1567	make_decl_rtl (decl);
1568
1569	rtl = DECL_RTL (decl);
1570	if (!MEM_P (rtl))
1571	return;
1572
1573	symbol = XEXP (rtl, 0);
1574	if (GET_CODE (symbol) != SYMBOL_REF)
1575	return;
1576
1577	SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1578	}
1579
1580	/* Copy visibility from N.
1581	This is useful when THIS becomes a transparent alias of N. */
1582
1583	void
1584	symtab_node::copy_visibility_from (symtab_node *n)
1585	{
1586	gcc_checking_assert (n->weakref == weakref);
1587
1588	ipa_ref *ref;
1589	for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1590	{
1591	struct symtab_node *alias = ref->referring;
1592	if (alias->transparent_alias)
1593	alias->copy_visibility_from (n);
1594	}
1595
1596	if (VAR_P (decl))
1597	{
1598	DECL_COMMON (decl) = DECL_COMMON (n->decl);
1599	/* ADDRESSABLE flag is not defined for public symbols. */
1600	if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
1601	TREE_ADDRESSABLE (decl) = 1;
1602	TREE_STATIC (decl) = TREE_STATIC (n->decl);
1603	}
1604	else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1605
1606	DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
1607	DECL_WEAK (decl) = DECL_WEAK (n->decl);
1608	DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
1609	DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
1610	DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
1611	TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
1612	DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
1613	resolution = n->resolution;
1614	set_comdat_group (n->get_comdat_group ());
1615	set_section (*n);
1616	externally_visible = n->externally_visible;
1617	if (!DECL_RTL_SET_P (decl))
1618	return;
1619
1620	/* Update rtl flags. */
1621	make_decl_rtl (decl);
1622
1623	rtx rtl = DECL_RTL (decl);
1624	if (!MEM_P (rtl))
1625	return;
1626
1627	rtx symbol = XEXP (rtl, 0);
1628	if (GET_CODE (symbol) != SYMBOL_REF)
1629	return;
1630
1631	SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1632	}
1633
1634	/* Walk the alias chain to return the symbol NODE is alias of.
1635	If NODE is not an alias, return NODE.
1636	Assumes NODE is known to be alias. */
1637
1638	symtab_node *
1639	symtab_node::ultimate_alias_target_1 (enum availability *availability,
1640	symtab_node *ref)
1641	{
1642	bool transparent_p = false;
1643
1644	/* To determine visibility of the target, we follow ELF semantic of aliases.
1645	Here alias is an alternative assembler name of a given definition. Its
1646	availability prevails the availability of its target (i.e. static alias of
1647	weak definition is available.
1648
1649	Transparent alias is just alternative name of a given symbol used within
1650	one compilation unit and is translated prior hitting the object file. It
1651	inherits the visibility of its target.
1652	Weakref is a different animal (and noweak definition is weak).
1653
1654	If we ever get into supporting targets with different semantics, a target
1655	hook will be needed here. */
1656
1657	if (availability)
1658	{
1659	transparent_p = transparent_alias;
1660	if (!transparent_p)
1661	*availability = get_availability (ref);
1662	else
1663	*availability = AVAIL_NOT_AVAILABLE;
1664	}
1665
1666	symtab_node *node = this;
1667	while (node)
1668	{
1669	if (node->alias && node->analyzed)
1670	node = node->get_alias_target ();
1671	else
1672	{
1673	if (!availability || (!transparent_p && node->analyzed))
1674	;
1675	else if (node->analyzed && !node->transparent_alias)
1676	*availability = node->get_availability (ref);
1677	else
1678	*availability = AVAIL_NOT_AVAILABLE;
1679	return node;
1680	}
1681	if (node && availability && transparent_p
1682	&& node->transparent_alias)
1683	{
1684	*availability = node->get_availability (ref);
1685	transparent_p = false;
1686	}
1687	}
1688	if (availability)
1689	*availability = AVAIL_NOT_AVAILABLE;
1690	return NULL;
1691	}
1692
1693	/* C++ FE sometimes change linkage flags after producing same body aliases.
1694
1695	FIXME: C++ produce implicit aliases for virtual functions and vtables that
1696	are obviously equivalent. The way it is doing so is however somewhat
1697	kludgy and interferes with the visibility code. As a result we need to
1698	copy the visibility from the target to get things right. */
1699
1700	void
1701	symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
1702	{
1703	if (is_a <cgraph_node *> (p: this))
1704	{
1705	DECL_DECLARED_INLINE_P (decl)
1706	= DECL_DECLARED_INLINE_P (target->decl);
1707	DECL_DISREGARD_INLINE_LIMITS (decl)
1708	= DECL_DISREGARD_INLINE_LIMITS (target->decl);
1709	}
1710	/* FIXME: It is not really clear why those flags should not be copied for
1711	functions, too. */
1712	else
1713	{
1714	DECL_WEAK (decl) = DECL_WEAK (target->decl);
1715	DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1716	DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
1717	}
1718	if (TREE_PUBLIC (decl))
1719	{
1720	tree group;
1721
1722	DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1723	DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
1724	group = target->get_comdat_group ();
1725	set_comdat_group (group);
1726	if (group && !same_comdat_group)
1727	add_to_same_comdat_group (old_node: target);
1728	}
1729	externally_visible = target->externally_visible;
1730	}
1731
1732	/* Set section, do not recurse into aliases.
1733	When one wants to change section of a symbol and its aliases,
1734	use set_section. */
1735
1736	void
1737	symtab_node::set_section_for_node (const char *section)
1738	{
1739	const char *current = get_section ();
1740
1741	if (current == section
1742	|| (current && section
1743	&& !strcmp (s1: current, s2: section)))
1744	return;
1745
1746	release_section_hash_entry (entry: x_section);
1747	if (!section)
1748	{
1749	x_section = NULL;
1750	implicit_section = false;
1751	return;
1752	}
1753	if (!symtab->section_hash)
1754	symtab->section_hash = hash_table<section_name_hasher>::create_ggc (n: 10);
1755	section_hash_entry **slot = symtab->section_hash->find_slot_with_hash
1756	(comparable: section, hash: htab_hash_string (section), insert: INSERT);
1757	if (*slot)
1758	x_section = retain_section_hash_entry (entry: *slot);
1759	else
1760	{
1761	int len = strlen (s: section);
1762	*slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
1763	x_section->ref_count = 1;
1764	x_section->name = ggc_vec_alloc<char> (c: len + 1);
1765	memcpy (dest: x_section->name, src: section, n: len + 1);
1766	}
1767	}
1768
1769	/* Set the section of node THIS to be the same as the section
1770	of node OTHER. Keep reference counts of the sections
1771	up-to-date as needed. */
1772
1773	void
1774	symtab_node::set_section_for_node (const symtab_node &other)
1775	{
1776	if (x_section == other.x_section)
1777	return;
1778	if (get_section () && other.get_section ())
1779	gcc_checking_assert (strcmp (get_section (), other.get_section ()) != 0);
1780	release_section_hash_entry (entry: x_section);
1781	if (other.x_section)
1782	x_section = retain_section_hash_entry (entry: other.x_section);
1783	else
1784	{
1785	x_section = NULL;
1786	implicit_section = false;
1787	}
1788	}
1789
1790	/* Workers for set_section. */
1791
1792	bool
1793	symtab_node::set_section_from_string (symtab_node *n, void *s)
1794	{
1795	n->set_section_for_node ((char *)s);
1796	return false;
1797	}
1798
1799	/* Set the section of node N to be the same as the section
1800	of node O. */
1801
1802	bool
1803	symtab_node::set_section_from_node (symtab_node *n, void *o)
1804	{
1805	const symtab_node &other = *static_cast<const symtab_node *> (o);
1806	n->set_section_for_node (other);
1807	return false;
1808	}
1809
1810	/* Set section of symbol and its aliases. */
1811
1812	void
1813	symtab_node::set_section (const char *section)
1814	{
1815	gcc_assert (!this->alias || !this->analyzed);
1816	call_for_symbol_and_aliases
1817	(callback: symtab_node::set_section_from_string, data: const_cast<char *>(section), include_overwritable: true);
1818	}
1819
1820	void
1821	symtab_node::set_section (const symtab_node &other)
1822	{
1823	call_for_symbol_and_aliases
1824	(callback: symtab_node::set_section_from_node, data: const_cast<symtab_node *>(&other), include_overwritable: true);
1825	}
1826
1827	/* Return the initialization priority. */
1828
1829	priority_type
1830	symtab_node::get_init_priority ()
1831	{
1832	if (!this->in_init_priority_hash)
1833	return DEFAULT_INIT_PRIORITY;
1834
1835	symbol_priority_map *h = symtab->init_priority_hash->get (k: this);
1836	return h ? h->init : DEFAULT_INIT_PRIORITY;
1837	}
1838
1839	/* Return the finalization priority. */
1840
1841	priority_type
1842	cgraph_node::get_fini_priority ()
1843	{
1844	if (!this->in_init_priority_hash)
1845	return DEFAULT_INIT_PRIORITY;
1846	symbol_priority_map *h = symtab->init_priority_hash->get (k: this);
1847	return h ? h->fini : DEFAULT_INIT_PRIORITY;
1848	}
1849
1850	/* Return the initialization and finalization priority information for
1851	DECL. If there is no previous priority information, a freshly
1852	allocated structure is returned. */
1853
1854	symbol_priority_map *
1855	symtab_node::priority_info (void)
1856	{
1857	if (!symtab->init_priority_hash)
1858	symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (size: 13);
1859
1860	bool existed;
1861	symbol_priority_map *h
1862	= &symtab->init_priority_hash->get_or_insert (k: this, existed: &existed);
1863	if (!existed)
1864	{
1865	h->init = DEFAULT_INIT_PRIORITY;
1866	h->fini = DEFAULT_INIT_PRIORITY;
1867	in_init_priority_hash = true;
1868	}
1869
1870	return h;
1871	}
1872
1873	/* Set initialization priority to PRIORITY. */
1874
1875	void
1876	symtab_node::set_init_priority (priority_type priority)
1877	{
1878	symbol_priority_map *h;
1879
1880	if (is_a <cgraph_node *> (p: this))
1881	gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
1882
1883	if (priority == DEFAULT_INIT_PRIORITY)
1884	{
1885	gcc_assert (get_init_priority() == priority);
1886	return;
1887	}
1888	h = priority_info ();
1889	h->init = priority;
1890	}
1891
1892	/* Set finalization priority to PRIORITY. */
1893
1894	void
1895	cgraph_node::set_fini_priority (priority_type priority)
1896	{
1897	symbol_priority_map *h;
1898
1899	gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
1900
1901	if (priority == DEFAULT_INIT_PRIORITY)
1902	{
1903	gcc_assert (get_fini_priority() == priority);
1904	return;
1905	}
1906	h = priority_info ();
1907	h->fini = priority;
1908	}
1909
1910	/* Worker for symtab_resolve_alias. */
1911
1912	bool
1913	symtab_node::set_implicit_section (symtab_node *n,
1914	void *data ATTRIBUTE_UNUSED)
1915	{
1916	n->implicit_section = true;
1917	return false;
1918	}
1919
1920	/* Add reference recording that symtab node is alias of TARGET.
1921	The function can fail in the case of aliasing cycles; in this case
1922	it returns false. */
1923
1924	bool
1925	symtab_node::resolve_alias (symtab_node *target, bool transparent)
1926	{
1927	symtab_node *n;
1928
1929	gcc_assert (!analyzed && !ref_list.references.length ());
1930
1931	/* Never let cycles to creep into the symbol table alias references;
1932	those will make alias walkers to be infinite. */
1933	for (n = target; n && n->alias;
1934	n = n->analyzed ? n->get_alias_target () : NULL)
1935	if (n == this)
1936	{
1937	if (is_a <cgraph_node *> (p: this))
1938	error ("function %q+D part of alias cycle", decl);
1939	else if (is_a <varpool_node *> (p: this))
1940	error ("variable %q+D part of alias cycle", decl);
1941	else
1942	gcc_unreachable ();
1943	alias = false;
1944	return false;
1945	}
1946
1947	/* "analyze" the node - i.e. mark the reference. */
1948	definition = true;
1949	alias = true;
1950	analyzed = true;
1951	transparent |= transparent_alias;
1952	transparent_alias = transparent;
1953	if (transparent)
1954	while (target->transparent_alias && target->analyzed)
1955	target = target->get_alias_target ();
1956	create_reference (referred_node: target, use_type: IPA_REF_ALIAS, NULL);
1957
1958	/* Add alias into the comdat group of its target unless it is already there. */
1959	if (same_comdat_group)
1960	remove_from_same_comdat_group ();
1961	set_comdat_group (NULL);
1962	if (target->get_comdat_group ())
1963	add_to_same_comdat_group (old_node: target);
1964
1965	if ((get_section () != target->get_section ()
1966	|| target->get_comdat_group ()) && get_section () && !implicit_section)
1967	{
1968	error ("section of alias %q+D must match section of its target", decl);
1969	}
1970	set_section (*target);
1971	if (target->implicit_section)
1972	call_for_symbol_and_aliases (callback: set_implicit_section, NULL, include_overwritable: true);
1973
1974	/* Alias targets become redundant after alias is resolved into an reference.
1975	We do not want to keep it around or we would have to mind updating them
1976	when renaming symbols. */
1977	alias_target = NULL;
1978
1979	if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
1980	fixup_same_cpp_alias_visibility (target);
1981
1982	/* If alias has address taken, so does the target. */
1983	if (address_taken)
1984	target->ultimate_alias_target ()->address_taken = true;
1985
1986	/* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1987	If alias is transparent, also all transparent aliases of THIS are now
1988	aliases of TARGET.
1989	Also merge same comdat group lists. */
1990	ipa_ref *ref;
1991	for (unsigned i = 0; iterate_direct_aliases (i, ref);)
1992	{
1993	struct symtab_node *alias_alias = ref->referring;
1994	if (alias_alias->get_comdat_group ())
1995	{
1996	alias_alias->remove_from_same_comdat_group ();
1997	alias_alias->set_comdat_group (NULL);
1998	if (target->get_comdat_group ())
1999	alias_alias->add_to_same_comdat_group (old_node: target);
2000	}
2001	if ((!alias_alias->transparent_alias
2002	&& !alias_alias->symver)
2003	|| transparent)
2004	{
2005	alias_alias->remove_all_references ();
2006	alias_alias->create_reference (referred_node: target, use_type: IPA_REF_ALIAS, NULL);
2007	}
2008	else i++;
2009	}
2010	return true;
2011	}
2012
2013	/* Worker searching noninterposable alias. */
2014
2015	bool
2016	symtab_node::noninterposable_alias (symtab_node *node, void *data)
2017	{
2018	if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
2019	{
2020	symtab_node *fn = node->ultimate_alias_target ();
2021
2022	/* Ensure that the alias is well formed this may not be the case
2023	of user defined aliases and currently it is not always the case
2024	of C++ same body aliases (that is a bug). */
2025	if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
2026	|| DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
2027	|| (TREE_CODE (node->decl) == FUNCTION_DECL
2028	&& flags_from_decl_or_type (node->decl)
2029	!= flags_from_decl_or_type (fn->decl))
2030	|| DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
2031	return false;
2032	*(symtab_node **)data = node;
2033	return true;
2034	}
2035	return false;
2036	}
2037
2038	/* If node cannot be overwriten by static or dynamic linker to point to
2039	different definition, return NODE. Otherwise look for alias with such
2040	property and if none exists, introduce new one. */
2041
2042	symtab_node *
2043	symtab_node::noninterposable_alias (void)
2044	{
2045	tree new_decl;
2046	symtab_node *new_node = NULL;
2047
2048	/* First try to look up existing alias or base object
2049	(if that is already non-overwritable). */
2050	symtab_node *node = ultimate_alias_target ();
2051	gcc_assert (!node->alias && !node->weakref);
2052	node->call_for_symbol_and_aliases (callback: symtab_node::noninterposable_alias,
2053	data: (void *)&new_node, include_overwritable: true);
2054	if (new_node)
2055	return new_node;
2056
2057	/* If aliases aren't supported by the assembler, fail. */
2058	if (!TARGET_SUPPORTS_ALIASES)
2059	return NULL;
2060	else if (lookup_attribute (attr_name: "target_clones", DECL_ATTRIBUTES (node->decl)))
2061	return NULL;
2062
2063	/* Otherwise create a new one. */
2064	new_decl = copy_node (node->decl);
2065	DECL_DLLIMPORT_P (new_decl) = 0;
2066	tree name = clone_function_name (decl: node->decl, suffix: "localalias");
2067	if (!flag_wpa)
2068	{
2069	unsigned long num = 0;
2070	/* In the rare case we already have a localalias, but the above
2071	node->call_for_symbol_and_aliases call didn't find any suitable,
2072	iterate until we find one not used yet. */
2073	while (symtab_node::get_for_asmname (asmname: name))
2074	name = clone_function_name (decl: node->decl, suffix: "localalias", number: num++);
2075	}
2076	DECL_NAME (new_decl) = name;
2077	if (TREE_CODE (new_decl) == FUNCTION_DECL)
2078	DECL_STRUCT_FUNCTION (new_decl) = NULL;
2079	DECL_INITIAL (new_decl) = NULL;
2080	SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
2081	SET_DECL_RTL (new_decl, NULL);
2082
2083	/* Update the properties. */
2084	DECL_EXTERNAL (new_decl) = 0;
2085	TREE_PUBLIC (new_decl) = 0;
2086	DECL_COMDAT (new_decl) = 0;
2087	DECL_WEAK (new_decl) = 0;
2088
2089	/* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
2090	DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
2091	if (TREE_CODE (new_decl) == FUNCTION_DECL)
2092	{
2093	DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
2094	DECL_STATIC_DESTRUCTOR (new_decl) = 0;
2095	new_node = cgraph_node::create_alias (alias: new_decl, target: node->decl);
2096
2097	cgraph_node *new_cnode = dyn_cast <cgraph_node *> (p: new_node),
2098	*cnode = dyn_cast <cgraph_node *> (p: node);
2099
2100	new_cnode->unit_id = cnode->unit_id;
2101	new_cnode->merged_comdat = cnode->merged_comdat;
2102	new_cnode->merged_extern_inline = cnode->merged_extern_inline;
2103	}
2104	else
2105	{
2106	TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
2107	DECL_INITIAL (new_decl) = error_mark_node;
2108	new_node = varpool_node::create_alias (new_decl, node->decl);
2109	}
2110	new_node->resolve_alias (target: node);
2111	gcc_assert (decl_binds_to_current_def_p (new_decl)
2112	&& targetm.binds_local_p (new_decl));
2113	return new_node;
2114	}
2115
2116	/* Return true if symtab node and TARGET represents
2117	semantically equivalent symbols. */
2118
2119	bool
2120	symtab_node::semantically_equivalent_p (symtab_node *target)
2121	{
2122	enum availability avail;
2123	symtab_node *ba;
2124	symtab_node *bb;
2125
2126	/* Equivalent functions are equivalent. */
2127	if (decl == target->decl)
2128	return true;
2129
2130	/* If symbol is not overwritable by different implementation,
2131	walk to the base object it defines. */
2132	ba = ultimate_alias_target (availability: &avail);
2133	if (avail >= AVAIL_AVAILABLE)
2134	{
2135	if (target == ba)
2136	return true;
2137	}
2138	else
2139	ba = this;
2140	bb = target->ultimate_alias_target (availability: &avail);
2141	if (avail >= AVAIL_AVAILABLE)
2142	{
2143	if (this == bb)
2144	return true;
2145	}
2146	else
2147	bb = target;
2148	return bb == ba;
2149	}
2150
2151	/* Classify symbol symtab node for partitioning. */
2152
2153	enum symbol_partitioning_class
2154	symtab_node::get_partitioning_class (void)
2155	{
2156	/* Inline clones are always duplicated.
2157	This include external declarations. */
2158	cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2159
2160	if (DECL_ABSTRACT_P (decl))
2161	return SYMBOL_EXTERNAL;
2162
2163	if (cnode && (cnode->inlined_to || cnode->declare_variant_alt))
2164	return SYMBOL_DUPLICATE;
2165
2166	/* Transparent aliases are always duplicated. */
2167	if (transparent_alias)
2168	return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
2169
2170	/* External declarations are external. */
2171	if (DECL_EXTERNAL (decl))
2172	return SYMBOL_EXTERNAL;
2173
2174	/* Even static aliases of external functions as external. Those can happen
2175	when COMDAT got resolved to non-IL implementation. */
2176	if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
2177	return SYMBOL_EXTERNAL;
2178
2179	if (varpool_node *vnode = dyn_cast <varpool_node *> (p: this))
2180	{
2181	if (alias && definition && !ultimate_alias_target ()->definition)
2182	return SYMBOL_EXTERNAL;
2183	/* Constant pool references use local symbol names that cannot
2184	be promoted global. We should never put into a constant pool
2185	objects that cannot be duplicated across partitions. */
2186	if (DECL_IN_CONSTANT_POOL (decl))
2187	return SYMBOL_DUPLICATE;
2188	if (DECL_HARD_REGISTER (decl))
2189	return SYMBOL_DUPLICATE;
2190	gcc_checking_assert (vnode->definition);
2191	}
2192	/* Functions that are cloned may stay in callgraph even if they are unused.
2193	Handle them as external; compute_ltrans_boundary take care to make
2194	proper things to happen (i.e. to make them appear in the boundary but
2195	with body streamed, so clone can me materialized). */
2196	else if (!dyn_cast <cgraph_node *> (p: this)->function_symbol ()->definition)
2197	return SYMBOL_EXTERNAL;
2198
2199	/* Linker discardable symbols are duplicated to every use unless they are
2200	keyed. */
2201	if (DECL_ONE_ONLY (decl)
2202	&& !force_output
2203	&& !forced_by_abi
2204	&& !used_from_object_file_p ())
2205	return SYMBOL_DUPLICATE;
2206
2207	return SYMBOL_PARTITION;
2208	}
2209
2210	/* Return true when symbol is known to be non-zero. */
2211
2212	bool
2213	symtab_node::nonzero_address ()
2214	{
2215	/* Weakrefs may be NULL when their target is not defined. */
2216	if (alias && weakref)
2217	{
2218	if (analyzed)
2219	{
2220	symtab_node *target = ultimate_alias_target ();
2221
2222	if (target->alias && target->weakref)
2223	return false;
2224	/* We cannot recurse to target::nonzero. It is possible that the
2225	target is used only via the alias.
2226	We may walk references and look for strong use, but we do not know
2227	if this strong use will survive to final binary, so be
2228	conservative here.
2229	??? Maybe we could do the lookup during late optimization that
2230	could be useful to eliminate the NULL pointer checks in LTO
2231	programs. */
2232	if (target->definition && !DECL_EXTERNAL (target->decl))
2233	return true;
2234	if (target->resolution != LDPR_UNKNOWN
2235	&& target->resolution != LDPR_UNDEF
2236	&& !target->can_be_discarded_p ()
2237	&& flag_delete_null_pointer_checks)
2238	return true;
2239	return false;
2240	}
2241	else
2242	return false;
2243	}
2244
2245	/* With !flag_delete_null_pointer_checks we assume that symbols may
2246	bind to NULL. This is on by default on embedded targets only.
2247
2248	Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2249	linking fails. Important case of WEAK we want to do well are comdats,
2250	which also must be defined somewhere.
2251
2252	When parsing, beware the cases when WEAK attribute is added later. */
2253	if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
2254	&& flag_delete_null_pointer_checks)
2255	{
2256	refuse_visibility_changes = true;
2257	return true;
2258	}
2259
2260	/* If target is defined and not extern, we know it will be
2261	output and thus it will bind to non-NULL.
2262	Play safe for flag_delete_null_pointer_checks where weak definition may
2263	be re-defined by NULL. */
2264	if (definition && !DECL_EXTERNAL (decl)
2265	&& (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
2266	{
2267	if (!DECL_WEAK (decl))
2268	refuse_visibility_changes = true;
2269	return true;
2270	}
2271
2272	/* As the last resort, check the resolution info. */
2273	if (resolution != LDPR_UNKNOWN
2274	&& resolution != LDPR_UNDEF
2275	&& !can_be_discarded_p ()
2276	&& flag_delete_null_pointer_checks)
2277	return true;
2278	return false;
2279	}
2280
2281	/* Return 0 if symbol is known to have different address than S2,
2282	Return 1 if symbol is known to have same address as S2,
2283	return -1 otherwise.
2284
2285	If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2286	and S2 is going to be accessed. This eliminates the situations when
2287	either THIS or S2 is NULL and is useful for comparing bases when deciding
2288	about memory aliasing. */
2289	int
2290	symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
2291	{
2292	enum availability avail1, avail2;
2293
2294	/* A Shortcut: equivalent symbols are always equivalent. */
2295	if (this == s2)
2296	return 1;
2297
2298	/* Unwind transparent aliases first; those are always equal to their
2299	target. */
2300	if (this->transparent_alias && this->analyzed)
2301	return this->get_alias_target ()->equal_address_to (s2);
2302	while (s2->transparent_alias && s2->analyzed)
2303	s2 = s2->get_alias_target();
2304
2305	if (this == s2)
2306	return 1;
2307
2308	/* For non-interposable aliases, lookup and compare their actual definitions.
2309	Also check if the symbol needs to bind to given definition. */
2310	symtab_node *rs1 = ultimate_alias_target (availability: &avail1);
2311	symtab_node *rs2 = s2->ultimate_alias_target (availability: &avail2);
2312	bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
2313	bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
2314	bool really_binds_local1 = binds_local1;
2315	bool really_binds_local2 = binds_local2;
2316
2317	/* Addresses of vtables and virtual functions cannot be used by user
2318	code and are used only within speculation. In this case we may make
2319	symbol equivalent to its alias even if interposition may break this
2320	rule. Doing so will allow us to turn speculative inlining into
2321	non-speculative more aggressively. */
2322	if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
2323	binds_local1 = true;
2324	if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
2325	binds_local2 = true;
2326
2327	/* If both definitions are available we know that even if they are bound
2328	to other unit they must be defined same way and therefore we can use
2329	equivalence test. */
2330	if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
2331	binds_local1 = binds_local2 = true;
2332
2333	if (binds_local1 && binds_local2 && rs1 == rs2)
2334	{
2335	/* We made use of the fact that alias is not weak. */
2336	if (rs1 != this)
2337	refuse_visibility_changes = true;
2338	if (rs2 != s2)
2339	s2->refuse_visibility_changes = true;
2340	return 1;
2341	}
2342
2343	/* If both symbols may resolve to NULL, we cannot really prove them
2344	different. */
2345	if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
2346	return -1;
2347
2348	/* Except for NULL, functions and variables never overlap. */
2349	if (TREE_CODE (decl) != TREE_CODE (s2->decl))
2350	return 0;
2351
2352	/* If one of the symbols is unresolved alias, punt. */
2353	if (rs1->alias || rs2->alias)
2354	return -1;
2355
2356	/* If we have a non-interposable definition of at least one of the symbols
2357	and the other symbol is different, we know other unit cannot interpose
2358	it to the first symbol; all aliases of the definition needs to be
2359	present in the current unit. */
2360	if (((really_binds_local1 || really_binds_local2)
2361	/* If we have both definitions and they are different, we know they
2362	will be different even in units they binds to. */
2363	|| (binds_local1 && binds_local2))
2364	&& rs1 != rs2)
2365	{
2366	/* We make use of the fact that one symbol is not alias of the other
2367	and that the definition is non-interposable. */
2368	refuse_visibility_changes = true;
2369	s2->refuse_visibility_changes = true;
2370	rs1->refuse_visibility_changes = true;
2371	rs2->refuse_visibility_changes = true;
2372	return 0;
2373	}
2374
2375	if (rs1 == rs2)
2376	return -1;
2377
2378	/* If the FE tells us at least one of the decls will never be aliased nor
2379	overlapping with other vars in some other way, return 0. */
2380	if (VAR_P (decl)
2381	&& (lookup_attribute (attr_name: "non overlapping", DECL_ATTRIBUTES (decl))
2382	|| lookup_attribute (attr_name: "non overlapping", DECL_ATTRIBUTES (s2->decl))))
2383	return 0;
2384
2385	/* TODO: Alias oracle basically assume that addresses of global variables
2386	are different unless they are declared as alias of one to another while
2387	the code folding comparisons doesn't.
2388	We probably should be consistent and use this fact here, too, but for
2389	the moment return false only when we are called from the alias oracle.
2390	Return 0 in C constant initializers and C++ manifestly constant
2391	expressions, the likelyhood that different vars will be aliases is
2392	small and returning -1 lets us reject too many initializers. */
2393	if (memory_accessed || folding_initializer)
2394	return 0;
2395
2396	return -1;
2397	}
2398
2399	/* Worker for call_for_symbol_and_aliases. */
2400
2401	bool
2402	symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
2403	void *),
2404	void *data,
2405	bool include_overwritable)
2406	{
2407	ipa_ref *ref;
2408	FOR_EACH_ALIAS (this, ref)
2409	{
2410	symtab_node *alias = ref->referring;
2411	if (include_overwritable
2412	|| alias->get_availability () > AVAIL_INTERPOSABLE)
2413	if (alias->call_for_symbol_and_aliases (callback, data,
2414	include_overwritable))
2415	return true;
2416	}
2417	return false;
2418	}
2419
2420	/* Return true if address of N is possibly compared. */
2421
2422	static bool
2423	address_matters_1 (symtab_node *n, void *)
2424	{
2425	struct ipa_ref *ref;
2426
2427	if (!n->address_can_be_compared_p ())
2428	return false;
2429	if (n->externally_visible || n->force_output)
2430	return true;
2431
2432	for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
2433	if (ref->address_matters_p ())
2434	return true;
2435	return false;
2436	}
2437
2438	/* Return true if symbol's address may possibly be compared to other
2439	symbol's address. */
2440
2441	bool
2442	symtab_node::address_matters_p ()
2443	{
2444	gcc_assert (!alias);
2445	return call_for_symbol_and_aliases (callback: address_matters_1, NULL, include_overwritable: true);
2446	}
2447
2448	/* Return true if symbol's alignment may be increased. */
2449
2450	bool
2451	symtab_node::can_increase_alignment_p (void)
2452	{
2453	symtab_node *target = ultimate_alias_target ();
2454
2455	/* For now support only variables. */
2456	if (!VAR_P (decl))
2457	return false;
2458
2459	/* With -fno-toplevel-reorder we may have already output the constant. */
2460	if (TREE_ASM_WRITTEN (target->decl))
2461	return false;
2462
2463	/* If target is already placed in an anchor, we cannot touch its
2464	alignment. */
2465	if (DECL_RTL_SET_P (target->decl)
2466	&& MEM_P (DECL_RTL (target->decl))
2467	&& SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
2468	return false;
2469
2470	/* Constant pool entries may be shared. */
2471	if (DECL_IN_CONSTANT_POOL (target->decl))
2472	return false;
2473
2474	/* We cannot change alignment of symbols that may bind to symbols
2475	in other translation unit that may contain a definition with lower
2476	alignment. */
2477	if (!decl_binds_to_current_def_p (decl))
2478	return false;
2479
2480	/* When compiling partition, be sure the symbol is not output by other
2481	partition. */
2482	if (flag_ltrans
2483	&& (target->in_other_partition
2484	|| target->get_partitioning_class () == SYMBOL_DUPLICATE))
2485	return false;
2486
2487	/* Do not override the alignment as specified by the ABI when the used
2488	attribute is set. */
2489	if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
2490	return false;
2491
2492	/* Do not override explicit alignment set by the user when an explicit
2493	section name is also used. This is a common idiom used by many
2494	software projects. */
2495	if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
2496	return false;
2497
2498	return true;
2499	}
2500
2501	/* Worker for symtab_node::increase_alignment. */
2502
2503	static bool
2504	increase_alignment_1 (symtab_node *n, void *v)
2505	{
2506	unsigned int align = (size_t)v;
2507	if (DECL_ALIGN (n->decl) < align
2508	&& n->can_increase_alignment_p ())
2509	{
2510	SET_DECL_ALIGN (n->decl, align);
2511	DECL_USER_ALIGN (n->decl) = 1;
2512	}
2513	return false;
2514	}
2515
2516	/* Increase alignment of THIS to ALIGN. */
2517
2518	void
2519	symtab_node::increase_alignment (unsigned int align)
2520	{
2521	gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
2522	ultimate_alias_target()->call_for_symbol_and_aliases (callback: increase_alignment_1,
2523	data: (void *)(size_t) align,
2524	include_overwritable: true);
2525	gcc_assert (DECL_ALIGN (decl) >= align);
2526	}
2527
2528	/* Helper for symtab_node::definition_alignment. */
2529
2530	static bool
2531	get_alignment_1 (symtab_node *n, void *v)
2532	{
2533	*((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
2534	return false;
2535	}
2536
2537	/* Return desired alignment of the definition. This is NOT alignment useful
2538	to access THIS, because THIS may be interposable and DECL_ALIGN should
2539	be used instead. It however must be guaranteed when output definition
2540	of THIS. */
2541
2542	unsigned int
2543	symtab_node::definition_alignment ()
2544	{
2545	unsigned int align = 0;
2546	gcc_assert (!alias);
2547	call_for_symbol_and_aliases (callback: get_alignment_1, data: &align, include_overwritable: true);
2548	return align;
2549	}
2550
2551	/* Return symbol used to separate symbol name from suffix. */
2552
2553	char
2554	symbol_table::symbol_suffix_separator ()
2555	{
2556	#ifndef NO_DOT_IN_LABEL
2557	return '.';
2558	#elif !defined NO_DOLLAR_IN_LABEL
2559	return '$';
2560	#else
2561	return '_';
2562	#endif
2563	}
2564
2565	/* Return true when references to this symbol from REF must bind to current
2566	definition in final executable. */
2567
2568	bool
2569	symtab_node::binds_to_current_def_p (symtab_node *ref)
2570	{
2571	if (!definition && !in_other_partition)
2572	return false;
2573	if (transparent_alias)
2574	return definition
2575	&& get_alias_target()->binds_to_current_def_p (ref);
2576	cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2577	if (cnode && cnode->ifunc_resolver)
2578	return false;
2579	if (decl_binds_to_current_def_p (decl))
2580	return true;
2581
2582	/* Inline clones always binds locally. */
2583	if (cnode && cnode->inlined_to)
2584	return true;
2585
2586	if (DECL_EXTERNAL (decl))
2587	return false;
2588
2589	gcc_assert (externally_visible);
2590
2591	if (ref)
2592	{
2593	cgraph_node *cref = dyn_cast <cgraph_node *> (p: ref);
2594	if (cref)
2595	ref = cref->inlined_to;
2596	}
2597
2598	/* If this is a reference from symbol itself and there are no aliases, we
2599	may be sure that the symbol was not interposed by something else because
2600	the symbol itself would be unreachable otherwise. This is important
2601	to optimize recursive functions well.
2602
2603	This assumption may be broken by inlining: if symbol is interposable
2604	but the body is available (i.e. declared inline), inliner may make
2605	the body reachable even with interposition. */
2606	if (this == ref && !has_aliases_p ()
2607	&& (!cnode
2608	|| symtab->state >= IPA_SSA_AFTER_INLINING
2609	|| get_availability () >= AVAIL_INTERPOSABLE))
2610	return true;
2611
2612
2613	/* References within one comdat group are always bound in a group. */
2614	if (ref
2615	&& symtab->state >= IPA_SSA_AFTER_INLINING
2616	&& get_comdat_group ()
2617	&& get_comdat_group () == ref->get_comdat_group ())
2618	return true;
2619
2620	return false;
2621	}
2622
2623	/* Return true if symbol should be output to the symbol table. */
2624
2625	bool
2626	symtab_node::output_to_lto_symbol_table_p (void)
2627	{
2628	/* Only externally visible symbols matter. */
2629	if (!TREE_PUBLIC (decl))
2630	return false;
2631	if (!real_symbol_p ())
2632	return false;
2633	/* FIXME: variables probably should not be considered as real symbols at
2634	first place. */
2635	if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
2636	return false;
2637	if (TREE_CODE (decl) == FUNCTION_DECL && !definition
2638	&& fndecl_built_in_p (node: decl))
2639	{
2640	/* Builtins like those for most math functions have actual implementations
2641	in libraries so make sure to output references into the symbol table to
2642	make those libraries referenced. Note this is incomplete handling for
2643	now and only covers math functions. */
2644	return builtin_with_linkage_p (decl);
2645	}
2646
2647	/* We have real symbol that should be in symbol table. However try to trim
2648	down the references to libraries bit more because linker will otherwise
2649	bring unnecessary object files into the final link.
2650	FIXME: The following checks can easily be confused i.e. by self recursive
2651	function or self-referring variable. */
2652
2653	/* We keep external functions in symtab for sake of inlining
2654	and devirtualization. We do not want to see them in symbol table as
2655	references unless they are really used. */
2656	cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2657	if (cnode && (!definition || DECL_EXTERNAL (decl))
2658	&& cnode->callers)
2659	return true;
2660
2661	/* Ignore all references from external vars initializers - they are not really
2662	part of the compilation unit until they are used by folding. Some symbols,
2663	like references to external construction vtables cannot be referred to at
2664	all. We decide this at can_refer_decl_in_current_unit_p. */
2665	if (!definition || DECL_EXTERNAL (decl))
2666	{
2667	int i;
2668	struct ipa_ref *ref;
2669	for (i = 0; iterate_referring (i, ref); i++)
2670	{
2671	if (ref->use == IPA_REF_ALIAS)
2672	continue;
2673	if (is_a <cgraph_node *> (p: ref->referring))
2674	return true;
2675	if (!DECL_EXTERNAL (ref->referring->decl))
2676	return true;
2677	}
2678	return false;
2679	}
2680	return true;
2681	}
2682