1/* Symbol table.
2 Copyright (C) 2012-2023 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along 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
43static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
44
45const 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
62static inline tree
63ultimate_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
81hashval_t
82symbol_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
103bool
104symbol_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
141bool
142symbol_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
161void
162symbol_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
202void
203symbol_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
250void
251symbol_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
259void
260symbol_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
273void
274symbol_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
358hashval_t
359section_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
366bool
367section_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
374static section_hash_entry *
375retain_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
384static void
385release_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
405void
406symtab_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
422void
423symtab_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
445void
446symtab_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
477void
478symtab_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
488void
489symtab_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
523void
524symtab_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
550const char *
551symtab_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
560const char *
561symtab_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
573const char *
574symtab_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
586const char *
587symtab_node::dump_name () const
588{
589 return get_dump_name (asm_name_p: false);
590}
591
592const char *
593symtab_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
602ipa_ref *
603symtab_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
614ipa_ref *
615symtab_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
665ipa_ref *
666symtab_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
696void
697symtab_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
716void
717symtab_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
736ipa_ref *
737symtab_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
754ipa_ref *
755symtab_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
775void
776symtab_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
794void
795symtab_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
818void
819symtab_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
828void
829symtab_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
838void
839symtab_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
855void
856symtab_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
870static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
871
872/* Dump the visibility of the symbol. */
873
874const char *
875symtab_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. */
883const char *
884symtab_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
891void
892symtab_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
1017void
1018symtab_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
1026void
1027symtab_node::dump_graphviz (FILE *f)
1028{
1029 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this))
1030 cnode->dump_graphviz (f);
1031}
1032
1033void
1034symbol_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
1042void
1043symbol_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
1052DEBUG_FUNCTION void
1053symbol_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
1061symtab_node *
1062symtab_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
1082DEBUG_FUNCTION void
1083symtab_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
1099DEBUG_FUNCTION bool
1100symtab_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
1354DEBUG_FUNCTION void
1355symtab_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/* Verify symbol table for internal consistency. */
1373
1374DEBUG_FUNCTION void
1375symtab_node::verify_symtab_nodes (void)
1376{
1377 symtab_node *node;
1378 hash_map<tree, symtab_node *> comdat_head_map (251);
1379 asm_node *anode;
1380
1381 for (anode = symtab->first_asm_symbol (); anode; anode = anode->next)
1382 if (anode->order < 0 || anode->order >= symtab->order)
1383 {
1384 error ("invalid order in asm node %i", anode->order);
1385 internal_error ("symtab_node::verify failed");
1386 }
1387
1388 FOR_EACH_SYMBOL (node)
1389 {
1390 node->verify ();
1391 if (node->get_comdat_group ())
1392 {
1393 symtab_node **entry, *s;
1394 bool existed;
1395
1396 entry = &comdat_head_map.get_or_insert (k: node->get_comdat_group (),
1397 existed: &existed);
1398 if (!existed)
1399 *entry = node;
1400 else if (!DECL_EXTERNAL (node->decl))
1401 {
1402 for (s = (*entry)->same_comdat_group;
1403 s != NULL && s != node && s != *entry;
1404 s = s->same_comdat_group)
1405 ;
1406 if (!s || s == *entry)
1407 {
1408 error ("Two symbols with same comdat_group are not linked by "
1409 "the same_comdat_group list.");
1410 (*entry)->debug ();
1411 node->debug ();
1412 internal_error ("symtab_node::verify failed");
1413 }
1414 }
1415 }
1416 }
1417}
1418
1419#if __GNUC__ >= 10
1420# pragma GCC diagnostic pop
1421#endif
1422
1423/* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1424 but other code such as notice_global_symbol generates rtl. */
1425
1426void
1427symtab_node::make_decl_local (void)
1428{
1429 rtx rtl, symbol;
1430
1431 if (weakref)
1432 {
1433 weakref = false;
1434 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
1435 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
1436 symtab->change_decl_assembler_name
1437 (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
1438 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
1439 DECL_ATTRIBUTES (decl));
1440 }
1441 /* Avoid clearing comdat_groups on comdat-local decls. */
1442 else if (TREE_PUBLIC (decl) == 0)
1443 return;
1444
1445 /* Localizing a symbol also make all its transparent aliases local. */
1446 ipa_ref *ref;
1447 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1448 {
1449 struct symtab_node *alias = ref->referring;
1450 if (alias->transparent_alias)
1451 alias->make_decl_local ();
1452 }
1453
1454 if (VAR_P (decl))
1455 {
1456 DECL_COMMON (decl) = 0;
1457 /* ADDRESSABLE flag is not defined for public symbols. */
1458 TREE_ADDRESSABLE (decl) = 1;
1459 TREE_STATIC (decl) = 1;
1460 }
1461 else
1462 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1463
1464 DECL_COMDAT (decl) = 0;
1465 DECL_WEAK (decl) = 0;
1466 DECL_EXTERNAL (decl) = 0;
1467 DECL_VISIBILITY_SPECIFIED (decl) = 0;
1468 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
1469 TREE_PUBLIC (decl) = 0;
1470 DECL_DLLIMPORT_P (decl) = 0;
1471 if (!DECL_RTL_SET_P (decl))
1472 return;
1473
1474 /* Update rtl flags. */
1475 make_decl_rtl (decl);
1476
1477 rtl = DECL_RTL (decl);
1478 if (!MEM_P (rtl))
1479 return;
1480
1481 symbol = XEXP (rtl, 0);
1482 if (GET_CODE (symbol) != SYMBOL_REF)
1483 return;
1484
1485 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1486}
1487
1488/* Copy visibility from N.
1489 This is useful when THIS becomes a transparent alias of N. */
1490
1491void
1492symtab_node::copy_visibility_from (symtab_node *n)
1493{
1494 gcc_checking_assert (n->weakref == weakref);
1495
1496 ipa_ref *ref;
1497 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1498 {
1499 struct symtab_node *alias = ref->referring;
1500 if (alias->transparent_alias)
1501 alias->copy_visibility_from (n);
1502 }
1503
1504 if (VAR_P (decl))
1505 {
1506 DECL_COMMON (decl) = DECL_COMMON (n->decl);
1507 /* ADDRESSABLE flag is not defined for public symbols. */
1508 if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
1509 TREE_ADDRESSABLE (decl) = 1;
1510 TREE_STATIC (decl) = TREE_STATIC (n->decl);
1511 }
1512 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1513
1514 DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
1515 DECL_WEAK (decl) = DECL_WEAK (n->decl);
1516 DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
1517 DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
1518 DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
1519 TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
1520 DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
1521 resolution = n->resolution;
1522 set_comdat_group (n->get_comdat_group ());
1523 set_section (*n);
1524 externally_visible = n->externally_visible;
1525 if (!DECL_RTL_SET_P (decl))
1526 return;
1527
1528 /* Update rtl flags. */
1529 make_decl_rtl (decl);
1530
1531 rtx rtl = DECL_RTL (decl);
1532 if (!MEM_P (rtl))
1533 return;
1534
1535 rtx symbol = XEXP (rtl, 0);
1536 if (GET_CODE (symbol) != SYMBOL_REF)
1537 return;
1538
1539 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1540}
1541
1542/* Walk the alias chain to return the symbol NODE is alias of.
1543 If NODE is not an alias, return NODE.
1544 Assumes NODE is known to be alias. */
1545
1546symtab_node *
1547symtab_node::ultimate_alias_target_1 (enum availability *availability,
1548 symtab_node *ref)
1549{
1550 bool transparent_p = false;
1551
1552 /* To determine visibility of the target, we follow ELF semantic of aliases.
1553 Here alias is an alternative assembler name of a given definition. Its
1554 availability prevails the availability of its target (i.e. static alias of
1555 weak definition is available.
1556
1557 Transparent alias is just alternative name of a given symbol used within
1558 one compilation unit and is translated prior hitting the object file. It
1559 inherits the visibility of its target.
1560 Weakref is a different animal (and noweak definition is weak).
1561
1562 If we ever get into supporting targets with different semantics, a target
1563 hook will be needed here. */
1564
1565 if (availability)
1566 {
1567 transparent_p = transparent_alias;
1568 if (!transparent_p)
1569 *availability = get_availability (ref);
1570 else
1571 *availability = AVAIL_NOT_AVAILABLE;
1572 }
1573
1574 symtab_node *node = this;
1575 while (node)
1576 {
1577 if (node->alias && node->analyzed)
1578 node = node->get_alias_target ();
1579 else
1580 {
1581 if (!availability || (!transparent_p && node->analyzed))
1582 ;
1583 else if (node->analyzed && !node->transparent_alias)
1584 *availability = node->get_availability (ref);
1585 else
1586 *availability = AVAIL_NOT_AVAILABLE;
1587 return node;
1588 }
1589 if (node && availability && transparent_p
1590 && node->transparent_alias)
1591 {
1592 *availability = node->get_availability (ref);
1593 transparent_p = false;
1594 }
1595 }
1596 if (availability)
1597 *availability = AVAIL_NOT_AVAILABLE;
1598 return NULL;
1599}
1600
1601/* C++ FE sometimes change linkage flags after producing same body aliases.
1602
1603 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1604 are obviously equivalent. The way it is doing so is however somewhat
1605 kludgy and interferes with the visibility code. As a result we need to
1606 copy the visibility from the target to get things right. */
1607
1608void
1609symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
1610{
1611 if (is_a <cgraph_node *> (p: this))
1612 {
1613 DECL_DECLARED_INLINE_P (decl)
1614 = DECL_DECLARED_INLINE_P (target->decl);
1615 DECL_DISREGARD_INLINE_LIMITS (decl)
1616 = DECL_DISREGARD_INLINE_LIMITS (target->decl);
1617 }
1618 /* FIXME: It is not really clear why those flags should not be copied for
1619 functions, too. */
1620 else
1621 {
1622 DECL_WEAK (decl) = DECL_WEAK (target->decl);
1623 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1624 DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
1625 }
1626 if (TREE_PUBLIC (decl))
1627 {
1628 tree group;
1629
1630 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1631 DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
1632 group = target->get_comdat_group ();
1633 set_comdat_group (group);
1634 if (group && !same_comdat_group)
1635 add_to_same_comdat_group (old_node: target);
1636 }
1637 externally_visible = target->externally_visible;
1638}
1639
1640/* Set section, do not recurse into aliases.
1641 When one wants to change section of a symbol and its aliases,
1642 use set_section. */
1643
1644void
1645symtab_node::set_section_for_node (const char *section)
1646{
1647 const char *current = get_section ();
1648
1649 if (current == section
1650 || (current && section
1651 && !strcmp (s1: current, s2: section)))
1652 return;
1653
1654 release_section_hash_entry (entry: x_section);
1655 if (!section)
1656 {
1657 x_section = NULL;
1658 implicit_section = false;
1659 return;
1660 }
1661 if (!symtab->section_hash)
1662 symtab->section_hash = hash_table<section_name_hasher>::create_ggc (n: 10);
1663 section_hash_entry **slot = symtab->section_hash->find_slot_with_hash
1664 (comparable: section, hash: htab_hash_string (section), insert: INSERT);
1665 if (*slot)
1666 x_section = retain_section_hash_entry (entry: *slot);
1667 else
1668 {
1669 int len = strlen (s: section);
1670 *slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
1671 x_section->ref_count = 1;
1672 x_section->name = ggc_vec_alloc<char> (c: len + 1);
1673 memcpy (dest: x_section->name, src: section, n: len + 1);
1674 }
1675}
1676
1677/* Set the section of node THIS to be the same as the section
1678 of node OTHER. Keep reference counts of the sections
1679 up-to-date as needed. */
1680
1681void
1682symtab_node::set_section_for_node (const symtab_node &other)
1683{
1684 if (x_section == other.x_section)
1685 return;
1686 if (get_section () && other.get_section ())
1687 gcc_checking_assert (strcmp (get_section (), other.get_section ()) != 0);
1688 release_section_hash_entry (entry: x_section);
1689 if (other.x_section)
1690 x_section = retain_section_hash_entry (entry: other.x_section);
1691 else
1692 {
1693 x_section = NULL;
1694 implicit_section = false;
1695 }
1696}
1697
1698/* Workers for set_section. */
1699
1700bool
1701symtab_node::set_section_from_string (symtab_node *n, void *s)
1702{
1703 n->set_section_for_node ((char *)s);
1704 return false;
1705}
1706
1707/* Set the section of node N to be the same as the section
1708 of node O. */
1709
1710bool
1711symtab_node::set_section_from_node (symtab_node *n, void *o)
1712{
1713 const symtab_node &other = *static_cast<const symtab_node *> (o);
1714 n->set_section_for_node (other);
1715 return false;
1716}
1717
1718/* Set section of symbol and its aliases. */
1719
1720void
1721symtab_node::set_section (const char *section)
1722{
1723 gcc_assert (!this->alias || !this->analyzed);
1724 call_for_symbol_and_aliases
1725 (callback: symtab_node::set_section_from_string, data: const_cast<char *>(section), include_overwritable: true);
1726}
1727
1728void
1729symtab_node::set_section (const symtab_node &other)
1730{
1731 call_for_symbol_and_aliases
1732 (callback: symtab_node::set_section_from_node, data: const_cast<symtab_node *>(&other), include_overwritable: true);
1733}
1734
1735/* Return the initialization priority. */
1736
1737priority_type
1738symtab_node::get_init_priority ()
1739{
1740 if (!this->in_init_priority_hash)
1741 return DEFAULT_INIT_PRIORITY;
1742
1743 symbol_priority_map *h = symtab->init_priority_hash->get (k: this);
1744 return h ? h->init : DEFAULT_INIT_PRIORITY;
1745}
1746
1747/* Return the finalization priority. */
1748
1749priority_type
1750cgraph_node::get_fini_priority ()
1751{
1752 if (!this->in_init_priority_hash)
1753 return DEFAULT_INIT_PRIORITY;
1754 symbol_priority_map *h = symtab->init_priority_hash->get (k: this);
1755 return h ? h->fini : DEFAULT_INIT_PRIORITY;
1756}
1757
1758/* Return the initialization and finalization priority information for
1759 DECL. If there is no previous priority information, a freshly
1760 allocated structure is returned. */
1761
1762symbol_priority_map *
1763symtab_node::priority_info (void)
1764{
1765 if (!symtab->init_priority_hash)
1766 symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (size: 13);
1767
1768 bool existed;
1769 symbol_priority_map *h
1770 = &symtab->init_priority_hash->get_or_insert (k: this, existed: &existed);
1771 if (!existed)
1772 {
1773 h->init = DEFAULT_INIT_PRIORITY;
1774 h->fini = DEFAULT_INIT_PRIORITY;
1775 in_init_priority_hash = true;
1776 }
1777
1778 return h;
1779}
1780
1781/* Set initialization priority to PRIORITY. */
1782
1783void
1784symtab_node::set_init_priority (priority_type priority)
1785{
1786 symbol_priority_map *h;
1787
1788 if (is_a <cgraph_node *> (p: this))
1789 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
1790
1791 if (priority == DEFAULT_INIT_PRIORITY)
1792 {
1793 gcc_assert (get_init_priority() == priority);
1794 return;
1795 }
1796 h = priority_info ();
1797 h->init = priority;
1798}
1799
1800/* Set finalization priority to PRIORITY. */
1801
1802void
1803cgraph_node::set_fini_priority (priority_type priority)
1804{
1805 symbol_priority_map *h;
1806
1807 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
1808
1809 if (priority == DEFAULT_INIT_PRIORITY)
1810 {
1811 gcc_assert (get_fini_priority() == priority);
1812 return;
1813 }
1814 h = priority_info ();
1815 h->fini = priority;
1816}
1817
1818/* Worker for symtab_resolve_alias. */
1819
1820bool
1821symtab_node::set_implicit_section (symtab_node *n,
1822 void *data ATTRIBUTE_UNUSED)
1823{
1824 n->implicit_section = true;
1825 return false;
1826}
1827
1828/* Add reference recording that symtab node is alias of TARGET.
1829 The function can fail in the case of aliasing cycles; in this case
1830 it returns false. */
1831
1832bool
1833symtab_node::resolve_alias (symtab_node *target, bool transparent)
1834{
1835 symtab_node *n;
1836
1837 gcc_assert (!analyzed && !ref_list.references.length ());
1838
1839 /* Never let cycles to creep into the symbol table alias references;
1840 those will make alias walkers to be infinite. */
1841 for (n = target; n && n->alias;
1842 n = n->analyzed ? n->get_alias_target () : NULL)
1843 if (n == this)
1844 {
1845 if (is_a <cgraph_node *> (p: this))
1846 error ("function %q+D part of alias cycle", decl);
1847 else if (is_a <varpool_node *> (p: this))
1848 error ("variable %q+D part of alias cycle", decl);
1849 else
1850 gcc_unreachable ();
1851 alias = false;
1852 return false;
1853 }
1854
1855 /* "analyze" the node - i.e. mark the reference. */
1856 definition = true;
1857 alias = true;
1858 analyzed = true;
1859 transparent |= transparent_alias;
1860 transparent_alias = transparent;
1861 if (transparent)
1862 while (target->transparent_alias && target->analyzed)
1863 target = target->get_alias_target ();
1864 create_reference (referred_node: target, use_type: IPA_REF_ALIAS, NULL);
1865
1866 /* Add alias into the comdat group of its target unless it is already there. */
1867 if (same_comdat_group)
1868 remove_from_same_comdat_group ();
1869 set_comdat_group (NULL);
1870 if (target->get_comdat_group ())
1871 add_to_same_comdat_group (old_node: target);
1872
1873 if ((get_section () != target->get_section ()
1874 || target->get_comdat_group ()) && get_section () && !implicit_section)
1875 {
1876 error ("section of alias %q+D must match section of its target", decl);
1877 }
1878 set_section (*target);
1879 if (target->implicit_section)
1880 call_for_symbol_and_aliases (callback: set_implicit_section, NULL, include_overwritable: true);
1881
1882 /* Alias targets become redundant after alias is resolved into an reference.
1883 We do not want to keep it around or we would have to mind updating them
1884 when renaming symbols. */
1885 alias_target = NULL;
1886
1887 if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
1888 fixup_same_cpp_alias_visibility (target);
1889
1890 /* If alias has address taken, so does the target. */
1891 if (address_taken)
1892 target->ultimate_alias_target ()->address_taken = true;
1893
1894 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1895 If alias is transparent, also all transparent aliases of THIS are now
1896 aliases of TARGET.
1897 Also merge same comdat group lists. */
1898 ipa_ref *ref;
1899 for (unsigned i = 0; iterate_direct_aliases (i, ref);)
1900 {
1901 struct symtab_node *alias_alias = ref->referring;
1902 if (alias_alias->get_comdat_group ())
1903 {
1904 alias_alias->remove_from_same_comdat_group ();
1905 alias_alias->set_comdat_group (NULL);
1906 if (target->get_comdat_group ())
1907 alias_alias->add_to_same_comdat_group (old_node: target);
1908 }
1909 if ((!alias_alias->transparent_alias
1910 && !alias_alias->symver)
1911 || transparent)
1912 {
1913 alias_alias->remove_all_references ();
1914 alias_alias->create_reference (referred_node: target, use_type: IPA_REF_ALIAS, NULL);
1915 }
1916 else i++;
1917 }
1918 return true;
1919}
1920
1921/* Worker searching noninterposable alias. */
1922
1923bool
1924symtab_node::noninterposable_alias (symtab_node *node, void *data)
1925{
1926 if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
1927 {
1928 symtab_node *fn = node->ultimate_alias_target ();
1929
1930 /* Ensure that the alias is well formed this may not be the case
1931 of user defined aliases and currently it is not always the case
1932 of C++ same body aliases (that is a bug). */
1933 if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
1934 || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
1935 || (TREE_CODE (node->decl) == FUNCTION_DECL
1936 && flags_from_decl_or_type (node->decl)
1937 != flags_from_decl_or_type (fn->decl))
1938 || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
1939 return false;
1940 *(symtab_node **)data = node;
1941 return true;
1942 }
1943 return false;
1944}
1945
1946/* If node cannot be overwriten by static or dynamic linker to point to
1947 different definition, return NODE. Otherwise look for alias with such
1948 property and if none exists, introduce new one. */
1949
1950symtab_node *
1951symtab_node::noninterposable_alias (void)
1952{
1953 tree new_decl;
1954 symtab_node *new_node = NULL;
1955
1956 /* First try to look up existing alias or base object
1957 (if that is already non-overwritable). */
1958 symtab_node *node = ultimate_alias_target ();
1959 gcc_assert (!node->alias && !node->weakref);
1960 node->call_for_symbol_and_aliases (callback: symtab_node::noninterposable_alias,
1961 data: (void *)&new_node, include_overwritable: true);
1962 if (new_node)
1963 return new_node;
1964
1965 /* If aliases aren't supported by the assembler, fail. */
1966 if (!TARGET_SUPPORTS_ALIASES)
1967 return NULL;
1968 else if (lookup_attribute (attr_name: "target_clones", DECL_ATTRIBUTES (node->decl)))
1969 return NULL;
1970
1971 /* Otherwise create a new one. */
1972 new_decl = copy_node (node->decl);
1973 DECL_DLLIMPORT_P (new_decl) = 0;
1974 tree name = clone_function_name (decl: node->decl, suffix: "localalias");
1975 if (!flag_wpa)
1976 {
1977 unsigned long num = 0;
1978 /* In the rare case we already have a localalias, but the above
1979 node->call_for_symbol_and_aliases call didn't find any suitable,
1980 iterate until we find one not used yet. */
1981 while (symtab_node::get_for_asmname (asmname: name))
1982 name = clone_function_name (decl: node->decl, suffix: "localalias", number: num++);
1983 }
1984 DECL_NAME (new_decl) = name;
1985 if (TREE_CODE (new_decl) == FUNCTION_DECL)
1986 DECL_STRUCT_FUNCTION (new_decl) = NULL;
1987 DECL_INITIAL (new_decl) = NULL;
1988 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1989 SET_DECL_RTL (new_decl, NULL);
1990
1991 /* Update the properties. */
1992 DECL_EXTERNAL (new_decl) = 0;
1993 TREE_PUBLIC (new_decl) = 0;
1994 DECL_COMDAT (new_decl) = 0;
1995 DECL_WEAK (new_decl) = 0;
1996
1997 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1998 DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
1999 if (TREE_CODE (new_decl) == FUNCTION_DECL)
2000 {
2001 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
2002 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
2003 new_node = cgraph_node::create_alias (alias: new_decl, target: node->decl);
2004
2005 cgraph_node *new_cnode = dyn_cast <cgraph_node *> (p: new_node),
2006 *cnode = dyn_cast <cgraph_node *> (p: node);
2007
2008 new_cnode->unit_id = cnode->unit_id;
2009 new_cnode->merged_comdat = cnode->merged_comdat;
2010 new_cnode->merged_extern_inline = cnode->merged_extern_inline;
2011 }
2012 else
2013 {
2014 TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
2015 DECL_INITIAL (new_decl) = error_mark_node;
2016 new_node = varpool_node::create_alias (new_decl, node->decl);
2017 }
2018 new_node->resolve_alias (target: node);
2019 gcc_assert (decl_binds_to_current_def_p (new_decl)
2020 && targetm.binds_local_p (new_decl));
2021 return new_node;
2022}
2023
2024/* Return true if symtab node and TARGET represents
2025 semantically equivalent symbols. */
2026
2027bool
2028symtab_node::semantically_equivalent_p (symtab_node *target)
2029{
2030 enum availability avail;
2031 symtab_node *ba;
2032 symtab_node *bb;
2033
2034 /* Equivalent functions are equivalent. */
2035 if (decl == target->decl)
2036 return true;
2037
2038 /* If symbol is not overwritable by different implementation,
2039 walk to the base object it defines. */
2040 ba = ultimate_alias_target (availability: &avail);
2041 if (avail >= AVAIL_AVAILABLE)
2042 {
2043 if (target == ba)
2044 return true;
2045 }
2046 else
2047 ba = this;
2048 bb = target->ultimate_alias_target (availability: &avail);
2049 if (avail >= AVAIL_AVAILABLE)
2050 {
2051 if (this == bb)
2052 return true;
2053 }
2054 else
2055 bb = target;
2056 return bb == ba;
2057}
2058
2059/* Classify symbol symtab node for partitioning. */
2060
2061enum symbol_partitioning_class
2062symtab_node::get_partitioning_class (void)
2063{
2064 /* Inline clones are always duplicated.
2065 This include external declarations. */
2066 cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2067
2068 if (DECL_ABSTRACT_P (decl))
2069 return SYMBOL_EXTERNAL;
2070
2071 if (cnode && (cnode->inlined_to || cnode->declare_variant_alt))
2072 return SYMBOL_DUPLICATE;
2073
2074 /* Transparent aliases are always duplicated. */
2075 if (transparent_alias)
2076 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
2077
2078 /* External declarations are external. */
2079 if (DECL_EXTERNAL (decl))
2080 return SYMBOL_EXTERNAL;
2081
2082 /* Even static aliases of external functions as external. Those can happen
2083 when COMDAT got resolved to non-IL implementation. */
2084 if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
2085 return SYMBOL_EXTERNAL;
2086
2087 if (varpool_node *vnode = dyn_cast <varpool_node *> (p: this))
2088 {
2089 if (alias && definition && !ultimate_alias_target ()->definition)
2090 return SYMBOL_EXTERNAL;
2091 /* Constant pool references use local symbol names that cannot
2092 be promoted global. We should never put into a constant pool
2093 objects that cannot be duplicated across partitions. */
2094 if (DECL_IN_CONSTANT_POOL (decl))
2095 return SYMBOL_DUPLICATE;
2096 if (DECL_HARD_REGISTER (decl))
2097 return SYMBOL_DUPLICATE;
2098 gcc_checking_assert (vnode->definition);
2099 }
2100 /* Functions that are cloned may stay in callgraph even if they are unused.
2101 Handle them as external; compute_ltrans_boundary take care to make
2102 proper things to happen (i.e. to make them appear in the boundary but
2103 with body streamed, so clone can me materialized). */
2104 else if (!dyn_cast <cgraph_node *> (p: this)->function_symbol ()->definition)
2105 return SYMBOL_EXTERNAL;
2106
2107 /* Linker discardable symbols are duplicated to every use unless they are
2108 keyed. */
2109 if (DECL_ONE_ONLY (decl)
2110 && !force_output
2111 && !forced_by_abi
2112 && !used_from_object_file_p ())
2113 return SYMBOL_DUPLICATE;
2114
2115 return SYMBOL_PARTITION;
2116}
2117
2118/* Return true when symbol is known to be non-zero. */
2119
2120bool
2121symtab_node::nonzero_address ()
2122{
2123 /* Weakrefs may be NULL when their target is not defined. */
2124 if (alias && weakref)
2125 {
2126 if (analyzed)
2127 {
2128 symtab_node *target = ultimate_alias_target ();
2129
2130 if (target->alias && target->weakref)
2131 return false;
2132 /* We cannot recurse to target::nonzero. It is possible that the
2133 target is used only via the alias.
2134 We may walk references and look for strong use, but we do not know
2135 if this strong use will survive to final binary, so be
2136 conservative here.
2137 ??? Maybe we could do the lookup during late optimization that
2138 could be useful to eliminate the NULL pointer checks in LTO
2139 programs. */
2140 if (target->definition && !DECL_EXTERNAL (target->decl))
2141 return true;
2142 if (target->resolution != LDPR_UNKNOWN
2143 && target->resolution != LDPR_UNDEF
2144 && !target->can_be_discarded_p ()
2145 && flag_delete_null_pointer_checks)
2146 return true;
2147 return false;
2148 }
2149 else
2150 return false;
2151 }
2152
2153 /* With !flag_delete_null_pointer_checks we assume that symbols may
2154 bind to NULL. This is on by default on embedded targets only.
2155
2156 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2157 linking fails. Important case of WEAK we want to do well are comdats,
2158 which also must be defined somewhere.
2159
2160 When parsing, beware the cases when WEAK attribute is added later. */
2161 if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
2162 && flag_delete_null_pointer_checks)
2163 {
2164 refuse_visibility_changes = true;
2165 return true;
2166 }
2167
2168 /* If target is defined and not extern, we know it will be
2169 output and thus it will bind to non-NULL.
2170 Play safe for flag_delete_null_pointer_checks where weak definition may
2171 be re-defined by NULL. */
2172 if (definition && !DECL_EXTERNAL (decl)
2173 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
2174 {
2175 if (!DECL_WEAK (decl))
2176 refuse_visibility_changes = true;
2177 return true;
2178 }
2179
2180 /* As the last resort, check the resolution info. */
2181 if (resolution != LDPR_UNKNOWN
2182 && resolution != LDPR_UNDEF
2183 && !can_be_discarded_p ()
2184 && flag_delete_null_pointer_checks)
2185 return true;
2186 return false;
2187}
2188
2189/* Return 0 if symbol is known to have different address than S2,
2190 Return 1 if symbol is known to have same address as S2,
2191 return -1 otherwise.
2192
2193 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2194 and S2 is going to be accessed. This eliminates the situations when
2195 either THIS or S2 is NULL and is useful for comparing bases when deciding
2196 about memory aliasing. */
2197int
2198symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
2199{
2200 enum availability avail1, avail2;
2201
2202 /* A Shortcut: equivalent symbols are always equivalent. */
2203 if (this == s2)
2204 return 1;
2205
2206 /* Unwind transparent aliases first; those are always equal to their
2207 target. */
2208 if (this->transparent_alias && this->analyzed)
2209 return this->get_alias_target ()->equal_address_to (s2);
2210 while (s2->transparent_alias && s2->analyzed)
2211 s2 = s2->get_alias_target();
2212
2213 if (this == s2)
2214 return 1;
2215
2216 /* For non-interposable aliases, lookup and compare their actual definitions.
2217 Also check if the symbol needs to bind to given definition. */
2218 symtab_node *rs1 = ultimate_alias_target (availability: &avail1);
2219 symtab_node *rs2 = s2->ultimate_alias_target (availability: &avail2);
2220 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
2221 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
2222 bool really_binds_local1 = binds_local1;
2223 bool really_binds_local2 = binds_local2;
2224
2225 /* Addresses of vtables and virtual functions cannot be used by user
2226 code and are used only within speculation. In this case we may make
2227 symbol equivalent to its alias even if interposition may break this
2228 rule. Doing so will allow us to turn speculative inlining into
2229 non-speculative more aggressively. */
2230 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
2231 binds_local1 = true;
2232 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
2233 binds_local2 = true;
2234
2235 /* If both definitions are available we know that even if they are bound
2236 to other unit they must be defined same way and therefore we can use
2237 equivalence test. */
2238 if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
2239 binds_local1 = binds_local2 = true;
2240
2241 if (binds_local1 && binds_local2 && rs1 == rs2)
2242 {
2243 /* We made use of the fact that alias is not weak. */
2244 if (rs1 != this)
2245 refuse_visibility_changes = true;
2246 if (rs2 != s2)
2247 s2->refuse_visibility_changes = true;
2248 return 1;
2249 }
2250
2251 /* If both symbols may resolve to NULL, we cannot really prove them
2252 different. */
2253 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
2254 return -1;
2255
2256 /* Except for NULL, functions and variables never overlap. */
2257 if (TREE_CODE (decl) != TREE_CODE (s2->decl))
2258 return 0;
2259
2260 /* If one of the symbols is unresolved alias, punt. */
2261 if (rs1->alias || rs2->alias)
2262 return -1;
2263
2264 /* If we have a non-interposable definition of at least one of the symbols
2265 and the other symbol is different, we know other unit cannot interpose
2266 it to the first symbol; all aliases of the definition needs to be
2267 present in the current unit. */
2268 if (((really_binds_local1 || really_binds_local2)
2269 /* If we have both definitions and they are different, we know they
2270 will be different even in units they binds to. */
2271 || (binds_local1 && binds_local2))
2272 && rs1 != rs2)
2273 {
2274 /* We make use of the fact that one symbol is not alias of the other
2275 and that the definition is non-interposable. */
2276 refuse_visibility_changes = true;
2277 s2->refuse_visibility_changes = true;
2278 rs1->refuse_visibility_changes = true;
2279 rs2->refuse_visibility_changes = true;
2280 return 0;
2281 }
2282
2283 if (rs1 == rs2)
2284 return -1;
2285
2286 /* If the FE tells us at least one of the decls will never be aliased nor
2287 overlapping with other vars in some other way, return 0. */
2288 if (VAR_P (decl)
2289 && (lookup_attribute (attr_name: "non overlapping", DECL_ATTRIBUTES (decl))
2290 || lookup_attribute (attr_name: "non overlapping", DECL_ATTRIBUTES (s2->decl))))
2291 return 0;
2292
2293 /* TODO: Alias oracle basically assume that addresses of global variables
2294 are different unless they are declared as alias of one to another while
2295 the code folding comparisons doesn't.
2296 We probably should be consistent and use this fact here, too, but for
2297 the moment return false only when we are called from the alias oracle.
2298 Return 0 in C constant initializers and C++ manifestly constant
2299 expressions, the likelyhood that different vars will be aliases is
2300 small and returning -1 lets us reject too many initializers. */
2301 if (memory_accessed || folding_initializer)
2302 return 0;
2303
2304 return -1;
2305}
2306
2307/* Worker for call_for_symbol_and_aliases. */
2308
2309bool
2310symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
2311 void *),
2312 void *data,
2313 bool include_overwritable)
2314{
2315 ipa_ref *ref;
2316 FOR_EACH_ALIAS (this, ref)
2317 {
2318 symtab_node *alias = ref->referring;
2319 if (include_overwritable
2320 || alias->get_availability () > AVAIL_INTERPOSABLE)
2321 if (alias->call_for_symbol_and_aliases (callback, data,
2322 include_overwritable))
2323 return true;
2324 }
2325 return false;
2326}
2327
2328/* Return true if address of N is possibly compared. */
2329
2330static bool
2331address_matters_1 (symtab_node *n, void *)
2332{
2333 struct ipa_ref *ref;
2334
2335 if (!n->address_can_be_compared_p ())
2336 return false;
2337 if (n->externally_visible || n->force_output)
2338 return true;
2339
2340 for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
2341 if (ref->address_matters_p ())
2342 return true;
2343 return false;
2344}
2345
2346/* Return true if symbol's address may possibly be compared to other
2347 symbol's address. */
2348
2349bool
2350symtab_node::address_matters_p ()
2351{
2352 gcc_assert (!alias);
2353 return call_for_symbol_and_aliases (callback: address_matters_1, NULL, include_overwritable: true);
2354}
2355
2356/* Return true if symbol's alignment may be increased. */
2357
2358bool
2359symtab_node::can_increase_alignment_p (void)
2360{
2361 symtab_node *target = ultimate_alias_target ();
2362
2363 /* For now support only variables. */
2364 if (!VAR_P (decl))
2365 return false;
2366
2367 /* With -fno-toplevel-reorder we may have already output the constant. */
2368 if (TREE_ASM_WRITTEN (target->decl))
2369 return false;
2370
2371 /* If target is already placed in an anchor, we cannot touch its
2372 alignment. */
2373 if (DECL_RTL_SET_P (target->decl)
2374 && MEM_P (DECL_RTL (target->decl))
2375 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
2376 return false;
2377
2378 /* Constant pool entries may be shared. */
2379 if (DECL_IN_CONSTANT_POOL (target->decl))
2380 return false;
2381
2382 /* We cannot change alignment of symbols that may bind to symbols
2383 in other translation unit that may contain a definition with lower
2384 alignment. */
2385 if (!decl_binds_to_current_def_p (decl))
2386 return false;
2387
2388 /* When compiling partition, be sure the symbol is not output by other
2389 partition. */
2390 if (flag_ltrans
2391 && (target->in_other_partition
2392 || target->get_partitioning_class () == SYMBOL_DUPLICATE))
2393 return false;
2394
2395 /* Do not override the alignment as specified by the ABI when the used
2396 attribute is set. */
2397 if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
2398 return false;
2399
2400 /* Do not override explicit alignment set by the user when an explicit
2401 section name is also used. This is a common idiom used by many
2402 software projects. */
2403 if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
2404 return false;
2405
2406 return true;
2407}
2408
2409/* Worker for symtab_node::increase_alignment. */
2410
2411static bool
2412increase_alignment_1 (symtab_node *n, void *v)
2413{
2414 unsigned int align = (size_t)v;
2415 if (DECL_ALIGN (n->decl) < align
2416 && n->can_increase_alignment_p ())
2417 {
2418 SET_DECL_ALIGN (n->decl, align);
2419 DECL_USER_ALIGN (n->decl) = 1;
2420 }
2421 return false;
2422}
2423
2424/* Increase alignment of THIS to ALIGN. */
2425
2426void
2427symtab_node::increase_alignment (unsigned int align)
2428{
2429 gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
2430 ultimate_alias_target()->call_for_symbol_and_aliases (callback: increase_alignment_1,
2431 data: (void *)(size_t) align,
2432 include_overwritable: true);
2433 gcc_assert (DECL_ALIGN (decl) >= align);
2434}
2435
2436/* Helper for symtab_node::definition_alignment. */
2437
2438static bool
2439get_alignment_1 (symtab_node *n, void *v)
2440{
2441 *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
2442 return false;
2443}
2444
2445/* Return desired alignment of the definition. This is NOT alignment useful
2446 to access THIS, because THIS may be interposable and DECL_ALIGN should
2447 be used instead. It however must be guaranteed when output definition
2448 of THIS. */
2449
2450unsigned int
2451symtab_node::definition_alignment ()
2452{
2453 unsigned int align = 0;
2454 gcc_assert (!alias);
2455 call_for_symbol_and_aliases (callback: get_alignment_1, data: &align, include_overwritable: true);
2456 return align;
2457}
2458
2459/* Return symbol used to separate symbol name from suffix. */
2460
2461char
2462symbol_table::symbol_suffix_separator ()
2463{
2464#ifndef NO_DOT_IN_LABEL
2465 return '.';
2466#elif !defined NO_DOLLAR_IN_LABEL
2467 return '$';
2468#else
2469 return '_';
2470#endif
2471}
2472
2473/* Return true when references to this symbol from REF must bind to current
2474 definition in final executable. */
2475
2476bool
2477symtab_node::binds_to_current_def_p (symtab_node *ref)
2478{
2479 if (!definition && !in_other_partition)
2480 return false;
2481 if (transparent_alias)
2482 return definition
2483 && get_alias_target()->binds_to_current_def_p (ref);
2484 cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2485 if (cnode && cnode->ifunc_resolver)
2486 return false;
2487 if (decl_binds_to_current_def_p (decl))
2488 return true;
2489
2490 /* Inline clones always binds locally. */
2491 if (cnode && cnode->inlined_to)
2492 return true;
2493
2494 if (DECL_EXTERNAL (decl))
2495 return false;
2496
2497 gcc_assert (externally_visible);
2498
2499 if (ref)
2500 {
2501 cgraph_node *cref = dyn_cast <cgraph_node *> (p: ref);
2502 if (cref)
2503 ref = cref->inlined_to;
2504 }
2505
2506 /* If this is a reference from symbol itself and there are no aliases, we
2507 may be sure that the symbol was not interposed by something else because
2508 the symbol itself would be unreachable otherwise. This is important
2509 to optimize recursive functions well.
2510
2511 This assumption may be broken by inlining: if symbol is interposable
2512 but the body is available (i.e. declared inline), inliner may make
2513 the body reachable even with interposition. */
2514 if (this == ref && !has_aliases_p ()
2515 && (!cnode
2516 || symtab->state >= IPA_SSA_AFTER_INLINING
2517 || get_availability () >= AVAIL_INTERPOSABLE))
2518 return true;
2519
2520
2521 /* References within one comdat group are always bound in a group. */
2522 if (ref
2523 && symtab->state >= IPA_SSA_AFTER_INLINING
2524 && get_comdat_group ()
2525 && get_comdat_group () == ref->get_comdat_group ())
2526 return true;
2527
2528 return false;
2529}
2530
2531/* Return true if symbol should be output to the symbol table. */
2532
2533bool
2534symtab_node::output_to_lto_symbol_table_p (void)
2535{
2536 /* Only externally visible symbols matter. */
2537 if (!TREE_PUBLIC (decl))
2538 return false;
2539 if (!real_symbol_p ())
2540 return false;
2541 /* FIXME: variables probably should not be considered as real symbols at
2542 first place. */
2543 if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
2544 return false;
2545 if (TREE_CODE (decl) == FUNCTION_DECL && !definition
2546 && fndecl_built_in_p (node: decl))
2547 {
2548 /* Builtins like those for most math functions have actual implementations
2549 in libraries so make sure to output references into the symbol table to
2550 make those libraries referenced. Note this is incomplete handling for
2551 now and only covers math functions. */
2552 return builtin_with_linkage_p (decl);
2553 }
2554
2555 /* We have real symbol that should be in symbol table. However try to trim
2556 down the references to libraries bit more because linker will otherwise
2557 bring unnecessary object files into the final link.
2558 FIXME: The following checks can easily be confused i.e. by self recursive
2559 function or self-referring variable. */
2560
2561 /* We keep external functions in symtab for sake of inlining
2562 and devirtualization. We do not want to see them in symbol table as
2563 references unless they are really used. */
2564 cgraph_node *cnode = dyn_cast <cgraph_node *> (p: this);
2565 if (cnode && (!definition || DECL_EXTERNAL (decl))
2566 && cnode->callers)
2567 return true;
2568
2569 /* Ignore all references from external vars initializers - they are not really
2570 part of the compilation unit until they are used by folding. Some symbols,
2571 like references to external construction vtables cannot be referred to at
2572 all. We decide this at can_refer_decl_in_current_unit_p. */
2573 if (!definition || DECL_EXTERNAL (decl))
2574 {
2575 int i;
2576 struct ipa_ref *ref;
2577 for (i = 0; iterate_referring (i, ref); i++)
2578 {
2579 if (ref->use == IPA_REF_ALIAS)
2580 continue;
2581 if (is_a <cgraph_node *> (p: ref->referring))
2582 return true;
2583 if (!DECL_EXTERNAL (ref->referring->decl))
2584 return true;
2585 }
2586 return false;
2587 }
2588 return true;
2589}
2590

source code of gcc/symtab.cc