Daily bump.
[official-gcc.git] / gcc / symtab.c
blobc7ea8ecef74f8ac9d112328466c56ebb5f8e0abe
1 /* Symbol table.
2 Copyright (C) 2012-2021 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
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.
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.
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/>. */
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"
42 static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
44 const char * const ld_plugin_symbol_resolution_names[]=
46 "",
47 "undef",
48 "prevailing_def",
49 "prevailing_def_ironly",
50 "preempted_reg",
51 "preempted_ir",
52 "resolved_ir",
53 "resolved_exec",
54 "resolved_dyn",
55 "prevailing_def_ironly_exp"
58 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
59 until we find an identifier that is not itself a transparent alias. */
61 static inline tree
62 ultimate_transparent_alias_target (tree alias)
64 tree target = alias;
66 while (IDENTIFIER_TRANSPARENT_ALIAS (target))
68 gcc_checking_assert (TREE_CHAIN (target));
69 target = TREE_CHAIN (target);
71 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
72 && ! TREE_CHAIN (target));
74 return target;
78 /* Hash asmnames ignoring the user specified marks. */
80 hashval_t
81 symbol_table::decl_assembler_name_hash (const_tree asmname)
83 if (IDENTIFIER_POINTER (asmname)[0] == '*')
85 const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
86 size_t ulp_len = strlen (user_label_prefix);
88 if (ulp_len == 0)
90 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
91 decl_str += ulp_len;
93 return htab_hash_string (decl_str);
96 return htab_hash_string (IDENTIFIER_POINTER (asmname));
99 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
100 name. */
102 bool
103 symbol_table::assembler_names_equal_p (const char *name1, const char *name2)
105 if (name1 != name2)
107 if (name1[0] == '*')
109 size_t ulp_len = strlen (user_label_prefix);
111 name1 ++;
113 if (ulp_len == 0)
115 else if (strncmp (name1, user_label_prefix, ulp_len) == 0)
116 name1 += ulp_len;
117 else
118 return false;
120 if (name2[0] == '*')
122 size_t ulp_len = strlen (user_label_prefix);
124 name2 ++;
126 if (ulp_len == 0)
128 else if (strncmp (name2, user_label_prefix, ulp_len) == 0)
129 name2 += ulp_len;
130 else
131 return false;
133 return !strcmp (name1, name2);
135 return true;
138 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
140 bool
141 symbol_table::decl_assembler_name_equal (tree decl, const_tree asmname)
143 tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
144 const char *decl_str;
145 const char *asmname_str;
147 if (decl_asmname == asmname)
148 return true;
150 decl_str = IDENTIFIER_POINTER (decl_asmname);
151 asmname_str = IDENTIFIER_POINTER (asmname);
152 return assembler_names_equal_p (decl_str, asmname_str);
156 /* Returns nonzero if P1 and P2 are equal. */
158 /* Insert NODE to assembler name hash. */
160 void
161 symbol_table::insert_to_assembler_name_hash (symtab_node *node,
162 bool with_clones)
164 if (is_a <varpool_node *> (node) && DECL_HARD_REGISTER (node->decl))
165 return;
166 gcc_checking_assert (!node->previous_sharing_asm_name
167 && !node->next_sharing_asm_name);
168 if (assembler_name_hash)
170 symtab_node **aslot;
171 cgraph_node *cnode;
172 tree decl = node->decl;
174 tree name = DECL_ASSEMBLER_NAME (node->decl);
176 /* C++ FE can produce decls without associated assembler name and insert
177 them to symtab to hold section or TLS information. */
178 if (!name)
179 return;
181 hashval_t hash = decl_assembler_name_hash (name);
182 aslot = assembler_name_hash->find_slot_with_hash (name, hash, INSERT);
183 gcc_assert (*aslot != node);
184 node->next_sharing_asm_name = (symtab_node *)*aslot;
185 if (*aslot != NULL)
186 (*aslot)->previous_sharing_asm_name = node;
187 *aslot = node;
189 /* Update also possible inline clones sharing a decl. */
190 cnode = dyn_cast <cgraph_node *> (node);
191 if (cnode && cnode->clones && with_clones)
192 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
193 if (cnode->decl == decl)
194 insert_to_assembler_name_hash (cnode, true);
199 /* Remove NODE from assembler name hash. */
201 void
202 symbol_table::unlink_from_assembler_name_hash (symtab_node *node,
203 bool with_clones)
205 if (assembler_name_hash)
207 cgraph_node *cnode;
208 tree decl = node->decl;
210 if (node->next_sharing_asm_name)
211 node->next_sharing_asm_name->previous_sharing_asm_name
212 = node->previous_sharing_asm_name;
213 if (node->previous_sharing_asm_name)
215 node->previous_sharing_asm_name->next_sharing_asm_name
216 = node->next_sharing_asm_name;
218 else
220 tree name = DECL_ASSEMBLER_NAME (node->decl);
221 symtab_node **slot;
223 if (!name)
224 return;
226 hashval_t hash = decl_assembler_name_hash (name);
227 slot = assembler_name_hash->find_slot_with_hash (name, hash,
228 NO_INSERT);
229 gcc_assert (*slot == node);
230 if (!node->next_sharing_asm_name)
231 assembler_name_hash->clear_slot (slot);
232 else
233 *slot = node->next_sharing_asm_name;
235 node->next_sharing_asm_name = NULL;
236 node->previous_sharing_asm_name = NULL;
238 /* Update also possible inline clones sharing a decl. */
239 cnode = dyn_cast <cgraph_node *> (node);
240 if (cnode && cnode->clones && with_clones)
241 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
242 if (cnode->decl == decl)
243 unlink_from_assembler_name_hash (cnode, true);
247 /* Arrange node to be first in its entry of assembler_name_hash. */
249 void
250 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node *node)
252 unlink_from_assembler_name_hash (node, false);
253 insert_to_assembler_name_hash (node, false);
256 /* Initialize asm name hash unless. */
258 void
259 symbol_table::symtab_initialize_asm_name_hash (void)
261 symtab_node *node;
262 if (!assembler_name_hash)
264 assembler_name_hash = hash_table<asmname_hasher>::create_ggc (10);
265 FOR_EACH_SYMBOL (node)
266 insert_to_assembler_name_hash (node, false);
270 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
272 void
273 symbol_table::change_decl_assembler_name (tree decl, tree name)
275 symtab_node *node = NULL;
277 /* We can have user ASM names on things, like global register variables, that
278 are not in the symbol table. */
279 if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
280 || TREE_CODE (decl) == FUNCTION_DECL)
281 node = symtab_node::get (decl);
282 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
284 SET_DECL_ASSEMBLER_NAME (decl, name);
285 if (node)
286 insert_to_assembler_name_hash (node, true);
288 else
290 if (name == DECL_ASSEMBLER_NAME (decl))
291 return;
293 tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl))
294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
295 : NULL);
296 if (node)
297 unlink_from_assembler_name_hash (node, true);
299 const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
300 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
301 && DECL_RTL_SET_P (decl))
302 warning (0, "%qD renamed after being referenced in assembly", decl);
304 SET_DECL_ASSEMBLER_NAME (decl, name);
305 if (alias)
307 IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
308 TREE_CHAIN (name) = alias;
310 /* If we change assembler name, also all transparent aliases must
311 be updated. There are three kinds - those having same assembler name,
312 those being renamed in varasm.c and weakref being renamed by the
313 assembler. */
314 if (node)
316 insert_to_assembler_name_hash (node, true);
317 ipa_ref *ref;
318 for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++)
320 struct symtab_node *alias = ref->referring;
321 if (alias->transparent_alias && !alias->weakref
322 && symbol_table::assembler_names_equal_p
323 (old_name, IDENTIFIER_POINTER (
324 DECL_ASSEMBLER_NAME (alias->decl))))
325 change_decl_assembler_name (alias->decl, name);
326 else if (alias->transparent_alias
327 && IDENTIFIER_TRANSPARENT_ALIAS (alias->decl))
329 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl))
330 && IDENTIFIER_TRANSPARENT_ALIAS
331 (DECL_ASSEMBLER_NAME (alias->decl)));
333 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) =
334 ultimate_transparent_alias_target
335 (DECL_ASSEMBLER_NAME (node->decl));
337 #ifdef ASM_OUTPUT_WEAKREF
338 else gcc_assert (!alias->transparent_alias || alias->weakref);
339 #else
340 else gcc_assert (!alias->transparent_alias);
341 #endif
343 gcc_assert (!node->transparent_alias || !node->definition
344 || node->weakref
345 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
346 || symbol_table::assembler_names_equal_p
347 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
348 IDENTIFIER_POINTER
349 (DECL_ASSEMBLER_NAME
350 (node->get_alias_target ()->decl))));
355 /* Hash sections by their names. */
357 hashval_t
358 section_name_hasher::hash (section_hash_entry *n)
360 return htab_hash_string (n->name);
363 /* Return true if section P1 name equals to P2. */
365 bool
366 section_name_hasher::equal (section_hash_entry *n1, const char *name)
368 return n1->name == name || !strcmp (n1->name, name);
371 /* Bump the reference count on ENTRY so that it is retained. */
373 static section_hash_entry *
374 retain_section_hash_entry (section_hash_entry *entry)
376 entry->ref_count++;
377 return entry;
380 /* Drop the reference count on ENTRY and remove it if the reference
381 count drops to zero. */
383 static void
384 release_section_hash_entry (section_hash_entry *entry)
386 if (entry)
388 entry->ref_count--;
389 if (!entry->ref_count)
391 hashval_t hash = htab_hash_string (entry->name);
392 section_hash_entry **slot
393 = symtab->section_hash->find_slot_with_hash (entry->name,
394 hash, INSERT);
395 ggc_free (entry);
396 symtab->section_hash->clear_slot (slot);
401 /* Add node into symbol table. This function is not used directly, but via
402 cgraph/varpool node creation routines. */
404 void
405 symtab_node::register_symbol (void)
407 symtab->register_symbol (this);
409 if (!decl->decl_with_vis.symtab_node)
410 decl->decl_with_vis.symtab_node = this;
412 ref_list.clear ();
414 /* Be sure to do this last; C++ FE might create new nodes via
415 DECL_ASSEMBLER_NAME langhook! */
416 symtab->insert_to_assembler_name_hash (this, false);
419 /* Remove NODE from same comdat group. */
421 void
422 symtab_node::remove_from_same_comdat_group (void)
424 if (same_comdat_group)
426 symtab_node *prev;
427 for (prev = same_comdat_group;
428 prev->same_comdat_group != this;
429 prev = prev->same_comdat_group)
431 if (same_comdat_group == prev)
432 prev->same_comdat_group = NULL;
433 else
434 prev->same_comdat_group = same_comdat_group;
435 same_comdat_group = NULL;
436 set_comdat_group (NULL);
440 /* Remove node from symbol table. This function is not used directly, but via
441 cgraph/varpool node removal routines.
442 INFO is a clone info to attach to new root of clone tree (if any). */
444 void
445 symtab_node::unregister (clone_info *info)
447 remove_all_references ();
448 remove_all_referring ();
450 /* Remove reference to section. */
451 set_section_for_node (NULL);
453 remove_from_same_comdat_group ();
455 symtab->unregister (this);
457 /* During LTO symtab merging we temporarily corrupt decl to symtab node
458 hash. */
459 gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p);
460 if (decl->decl_with_vis.symtab_node == this)
462 symtab_node *replacement_node = NULL;
463 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
464 replacement_node = cnode->find_replacement (info);
465 decl->decl_with_vis.symtab_node = replacement_node;
467 if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl))
468 symtab->unlink_from_assembler_name_hash (this, false);
469 if (in_init_priority_hash)
470 symtab->init_priority_hash->remove (this);
474 /* Remove symbol from symbol table. */
476 void
477 symtab_node::remove (void)
479 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
480 cnode->remove ();
481 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
482 vnode->remove ();
485 /* Add NEW_ to the same comdat group that OLD is in. */
487 void
488 symtab_node::add_to_same_comdat_group (symtab_node *old_node)
490 gcc_assert (old_node->get_comdat_group ());
491 gcc_assert (!same_comdat_group);
492 gcc_assert (this != old_node);
494 set_comdat_group (old_node->get_comdat_group ());
495 same_comdat_group = old_node;
496 if (!old_node->same_comdat_group)
497 old_node->same_comdat_group = this;
498 else
500 symtab_node *n;
501 for (n = old_node->same_comdat_group;
502 n->same_comdat_group != old_node;
503 n = n->same_comdat_group)
505 n->same_comdat_group = this;
508 cgraph_node *n;
509 if (comdat_local_p ()
510 && (n = dyn_cast <cgraph_node *> (this)) != NULL)
512 for (cgraph_edge *e = n->callers; e; e = e->next_caller)
513 if (e->caller->inlined_to)
514 e->caller->inlined_to->calls_comdat_local = true;
515 else
516 e->caller->calls_comdat_local = true;
520 /* Dissolve the same_comdat_group list in which NODE resides. */
522 void
523 symtab_node::dissolve_same_comdat_group_list (void)
525 symtab_node *n = this;
526 symtab_node *next;
528 if (!same_comdat_group)
529 return;
532 next = n->same_comdat_group;
533 n->same_comdat_group = NULL;
534 if (dyn_cast <cgraph_node *> (n))
535 dyn_cast <cgraph_node *> (n)->calls_comdat_local = false;
536 /* Clear comdat_group for comdat locals, since
537 make_decl_local doesn't. */
538 if (!TREE_PUBLIC (n->decl))
539 n->set_comdat_group (NULL);
540 n = next;
542 while (n != this);
545 /* Return printable assembler name of NODE.
546 This function is used only for debugging. When assembler name
547 is unknown go with identifier name. */
549 const char *
550 symtab_node::asm_name () const
552 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
553 return name ();
554 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
557 /* Return printable identifier name. */
559 const char *
560 symtab_node::name () const
562 if (!DECL_NAME (decl))
564 if (DECL_ASSEMBLER_NAME_SET_P (decl))
565 return asm_name ();
566 else
567 return "<unnamed>";
569 return lang_hooks.decl_printable_name (decl, 2);
572 const char *
573 symtab_node::get_dump_name (bool asm_name_p) const
575 #define EXTRA 16
576 const char *fname = asm_name_p ? asm_name () : name ();
577 unsigned l = strlen (fname);
579 char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA);
580 snprintf (s, l + EXTRA, "%s/%d", fname, order);
582 return s;
585 const char *
586 symtab_node::dump_name () const
588 return get_dump_name (false);
591 const char *
592 symtab_node::dump_asm_name () const
594 return get_dump_name (true);
597 /* Return ipa reference from this symtab_node to
598 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
599 of the use. */
601 ipa_ref *
602 symtab_node::create_reference (symtab_node *referred_node,
603 enum ipa_ref_use use_type)
605 return create_reference (referred_node, use_type, NULL);
609 /* Return ipa reference from this symtab_node to
610 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
611 of the use and STMT the statement (if it exists). */
613 ipa_ref *
614 symtab_node::create_reference (symtab_node *referred_node,
615 enum ipa_ref_use use_type, gimple *stmt)
617 ipa_ref *ref = NULL, *ref2 = NULL;
618 ipa_ref_list *list, *list2;
619 ipa_ref_t *old_references;
621 gcc_checking_assert (!stmt || is_a <cgraph_node *> (this));
622 gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
624 list = &ref_list;
625 old_references = list->references.address ();
626 list->references.safe_grow (list->references.length () + 1, false);
627 ref = &list->references.last ();
629 list2 = &referred_node->ref_list;
631 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
632 if(use_type == IPA_REF_ALIAS)
634 list2->referring.safe_insert (0, ref);
635 ref->referred_index = 0;
637 for (unsigned int i = 1; i < list2->referring.length (); i++)
638 list2->referring[i]->referred_index = i;
640 else
642 list2->referring.safe_push (ref);
643 ref->referred_index = list2->referring.length () - 1;
646 ref->referring = this;
647 ref->referred = referred_node;
648 ref->stmt = stmt;
649 ref->lto_stmt_uid = 0;
650 ref->speculative_id = 0;
651 ref->use = use_type;
652 ref->speculative = 0;
654 /* If vector was moved in memory, update pointers. */
655 if (old_references != list->references.address ())
657 int i;
658 for (i = 0; iterate_reference(i, ref2); i++)
659 ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2;
661 return ref;
664 ipa_ref *
665 symtab_node::maybe_create_reference (tree val, gimple *stmt)
667 STRIP_NOPS (val);
668 ipa_ref_use use_type;
670 switch (TREE_CODE (val))
672 case VAR_DECL:
673 use_type = IPA_REF_LOAD;
674 break;
675 case ADDR_EXPR:
676 use_type = IPA_REF_ADDR;
677 break;
678 default:
679 gcc_assert (!handled_component_p (val));
680 return NULL;
683 val = get_base_var (val);
684 if (val && VAR_OR_FUNCTION_DECL_P (val))
686 symtab_node *referred = symtab_node::get (val);
687 gcc_checking_assert (referred);
688 return create_reference (referred, use_type, stmt);
690 return NULL;
693 /* Clone all references from symtab NODE to this symtab_node. */
695 void
696 symtab_node::clone_references (symtab_node *node)
698 ipa_ref *ref = NULL, *ref2 = NULL;
699 int i;
700 for (i = 0; node->iterate_reference (i, ref); i++)
702 bool speculative = ref->speculative;
703 unsigned int stmt_uid = ref->lto_stmt_uid;
704 unsigned int spec_id = ref->speculative_id;
706 ref2 = create_reference (ref->referred, ref->use, ref->stmt);
707 ref2->speculative = speculative;
708 ref2->lto_stmt_uid = stmt_uid;
709 ref2->speculative_id = spec_id;
713 /* Clone all referring from symtab NODE to this symtab_node. */
715 void
716 symtab_node::clone_referring (symtab_node *node)
718 ipa_ref *ref = NULL, *ref2 = NULL;
719 int i;
720 for (i = 0; node->iterate_referring(i, ref); i++)
722 bool speculative = ref->speculative;
723 unsigned int stmt_uid = ref->lto_stmt_uid;
724 unsigned int spec_id = ref->speculative_id;
726 ref2 = ref->referring->create_reference (this, ref->use, ref->stmt);
727 ref2->speculative = speculative;
728 ref2->lto_stmt_uid = stmt_uid;
729 ref2->speculative_id = spec_id;
733 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
735 ipa_ref *
736 symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
738 bool speculative = ref->speculative;
739 unsigned int stmt_uid = ref->lto_stmt_uid;
740 unsigned int spec_id = ref->speculative_id;
741 ipa_ref *ref2;
743 ref2 = create_reference (ref->referred, ref->use, stmt);
744 ref2->speculative = speculative;
745 ref2->lto_stmt_uid = stmt_uid;
746 ref2->speculative_id = spec_id;
747 return ref2;
750 /* Find the structure describing a reference to REFERRED_NODE
751 and associated with statement STMT. */
753 ipa_ref *
754 symtab_node::find_reference (symtab_node *referred_node,
755 gimple *stmt, unsigned int lto_stmt_uid)
757 ipa_ref *r = NULL;
758 int i;
760 for (i = 0; iterate_reference (i, r); i++)
761 if (r->referred == referred_node
762 && !r->speculative
763 && ((stmt && r->stmt == stmt)
764 || (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid)
765 || (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid)))
766 return r;
767 return NULL;
770 /* Remove all references that are associated with statement STMT. */
772 void
773 symtab_node::remove_stmt_references (gimple *stmt)
775 ipa_ref *r = NULL;
776 int i = 0;
778 while (iterate_reference (i, r))
779 if (r->stmt == stmt)
780 r->remove_reference ();
781 else
782 i++;
785 /* Remove all stmt references in non-speculative references in THIS
786 and all clones.
787 Those are not maintained during inlining & cloning.
788 The exception are speculative references that are updated along
789 with callgraph edges associated with them. */
791 void
792 symtab_node::clear_stmts_in_references (void)
794 ipa_ref *r = NULL;
795 int i;
797 for (i = 0; iterate_reference (i, r); i++)
798 if (!r->speculative)
800 r->stmt = NULL;
801 r->lto_stmt_uid = 0;
802 r->speculative_id = 0;
804 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
805 if (cnode)
807 if (cnode->clones)
808 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
809 cnode->clear_stmts_in_references ();
813 /* Remove all references in ref list. */
815 void
816 symtab_node::remove_all_references (void)
818 while (ref_list.references.length ())
819 ref_list.references.last ().remove_reference ();
820 ref_list.references.release ();
823 /* Remove all referring items in ref list. */
825 void
826 symtab_node::remove_all_referring (void)
828 while (ref_list.referring.length ())
829 ref_list.referring.last ()->remove_reference ();
830 ref_list.referring.release ();
833 /* Dump references in ref list to FILE. */
835 void
836 symtab_node::dump_references (FILE *file)
838 ipa_ref *ref = NULL;
839 int i;
840 for (i = 0; iterate_reference (i, ref); i++)
842 fprintf (file, "%s (%s) ", ref->referred->dump_asm_name (),
843 ipa_ref_use_name[ref->use]);
844 if (ref->speculative)
845 fprintf (file, "(speculative) ");
847 fprintf (file, "\n");
850 /* Dump referring in list to FILE. */
852 void
853 symtab_node::dump_referring (FILE *file)
855 ipa_ref *ref = NULL;
856 int i;
857 for (i = 0; iterate_referring(i, ref); i++)
859 fprintf (file, "%s (%s) ", ref->referring->dump_asm_name (),
860 ipa_ref_use_name[ref->use]);
861 if (ref->speculative)
862 fprintf (file, "(speculative) ");
864 fprintf (file, "\n");
867 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
869 /* Dump the visibility of the symbol. */
871 const char *
872 symtab_node::get_visibility_string () const
874 static const char * const visibility_types[]
875 = { "default", "protected", "hidden", "internal" };
876 return visibility_types[DECL_VISIBILITY (decl)];
879 /* Dump the type_name of the symbol. */
880 const char *
881 symtab_node::get_symtab_type_string () const
883 return symtab_type_names[type];
886 /* Dump base fields of symtab nodes to F. Not to be used directly. */
888 void
889 symtab_node::dump_base (FILE *f)
891 static const char * const visibility_types[] = {
892 "default", "protected", "hidden", "internal"
895 fprintf (f, "%s (%s)", dump_asm_name (), name ());
896 dump_addr (f, " @", (void *)this);
897 fprintf (f, "\n Type: %s", symtab_type_names[type]);
899 if (definition)
900 fprintf (f, " definition");
901 if (analyzed)
902 fprintf (f, " analyzed");
903 if (alias)
904 fprintf (f, " alias");
905 if (transparent_alias)
906 fprintf (f, " transparent_alias");
907 if (weakref)
908 fprintf (f, " weakref");
909 if (symver)
910 fprintf (f, " symver");
911 if (cpp_implicit_alias)
912 fprintf (f, " cpp_implicit_alias");
913 if (alias_target)
914 fprintf (f, " target:%s",
915 DECL_P (alias_target)
916 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
917 (alias_target))
918 : IDENTIFIER_POINTER (alias_target));
919 if (body_removed)
920 fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes");
921 fprintf (f, "\n Visibility:");
922 if (in_other_partition)
923 fprintf (f, " in_other_partition");
924 if (used_from_other_partition)
925 fprintf (f, " used_from_other_partition");
926 if (force_output)
927 fprintf (f, " force_output");
928 if (forced_by_abi)
929 fprintf (f, " forced_by_abi");
930 if (externally_visible)
931 fprintf (f, " externally_visible");
932 if (no_reorder)
933 fprintf (f, " no_reorder");
934 if (resolution != LDPR_UNKNOWN)
935 fprintf (f, " %s",
936 ld_plugin_symbol_resolution_names[(int)resolution]);
937 if (TREE_ASM_WRITTEN (decl))
938 fprintf (f, " asm_written");
939 if (DECL_EXTERNAL (decl))
940 fprintf (f, " external");
941 if (TREE_PUBLIC (decl))
942 fprintf (f, " public");
943 if (DECL_COMMON (decl))
944 fprintf (f, " common");
945 if (DECL_WEAK (decl))
946 fprintf (f, " weak");
947 if (DECL_DLLIMPORT_P (decl))
948 fprintf (f, " dll_import");
949 if (DECL_COMDAT (decl))
950 fprintf (f, " comdat");
951 if (get_comdat_group ())
952 fprintf (f, " comdat_group:%s",
953 IDENTIFIER_POINTER (get_comdat_group_id ()));
954 if (DECL_ONE_ONLY (decl))
955 fprintf (f, " one_only");
956 if (get_section ())
957 fprintf (f, " section:%s",
958 get_section ());
959 if (implicit_section)
960 fprintf (f," (implicit_section)");
961 if (DECL_VISIBILITY_SPECIFIED (decl))
962 fprintf (f, " visibility_specified");
963 if (DECL_VISIBILITY (decl))
964 fprintf (f, " visibility:%s",
965 visibility_types [DECL_VISIBILITY (decl)]);
966 if (DECL_VIRTUAL_P (decl))
967 fprintf (f, " virtual");
968 if (DECL_ARTIFICIAL (decl))
969 fprintf (f, " artificial");
970 if (TREE_CODE (decl) == FUNCTION_DECL)
972 if (DECL_STATIC_CONSTRUCTOR (decl))
973 fprintf (f, " constructor");
974 if (DECL_STATIC_DESTRUCTOR (decl))
975 fprintf (f, " destructor");
977 if (ifunc_resolver)
978 fprintf (f, " ifunc_resolver");
979 fprintf (f, "\n");
981 if (same_comdat_group)
982 fprintf (f, " Same comdat group as: %s\n",
983 same_comdat_group->dump_asm_name ());
984 if (next_sharing_asm_name)
985 fprintf (f, " next sharing asm name: %i\n",
986 next_sharing_asm_name->order);
987 if (previous_sharing_asm_name)
988 fprintf (f, " previous sharing asm name: %i\n",
989 previous_sharing_asm_name->order);
991 if (address_taken)
992 fprintf (f, " Address is taken.\n");
993 if (aux)
995 fprintf (f, " Aux:");
996 dump_addr (f, " @", (void *)aux);
997 fprintf (f, "\n");
1000 fprintf (f, " References: ");
1001 dump_references (f);
1002 fprintf (f, " Referring: ");
1003 dump_referring (f);
1004 if (lto_file_data)
1005 fprintf (f, " Read from file: %s\n",
1006 lto_file_data->file_name);
1009 /* Dump symtab node to F. */
1011 void
1012 symtab_node::dump (FILE *f)
1014 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
1015 cnode->dump (f);
1016 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
1017 vnode->dump (f);
1020 void
1021 symtab_node::dump_graphviz (FILE *f)
1023 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
1024 cnode->dump_graphviz (f);
1027 void
1028 symbol_table::dump (FILE *f)
1030 symtab_node *node;
1031 fprintf (f, "Symbol table:\n\n");
1032 FOR_EACH_SYMBOL (node)
1033 node->dump (f);
1036 void
1037 symbol_table::dump_graphviz (FILE *f)
1039 symtab_node *node;
1040 fprintf (f, "digraph symtab {\n");
1041 FOR_EACH_SYMBOL (node)
1042 node->dump_graphviz (f);
1043 fprintf (f, "}\n");
1046 DEBUG_FUNCTION void
1047 symbol_table::debug (void)
1049 dump (stderr);
1052 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1053 Return NULL if there's no such node. */
1055 symtab_node *
1056 symtab_node::get_for_asmname (const_tree asmname)
1058 symtab_node *node;
1060 symtab->symtab_initialize_asm_name_hash ();
1061 hashval_t hash = symtab->decl_assembler_name_hash (asmname);
1062 symtab_node **slot
1063 = symtab->assembler_name_hash->find_slot_with_hash (asmname, hash,
1064 NO_INSERT);
1066 if (slot)
1068 node = *slot;
1069 return node;
1071 return NULL;
1074 /* Dump symtab node NODE to stderr. */
1076 DEBUG_FUNCTION void
1077 symtab_node::debug (void)
1079 dump (stderr);
1082 /* Verify common part of symtab nodes. */
1084 #if __GNUC__ >= 10
1085 /* Disable warnings about missing quoting in GCC diagnostics for
1086 the verification errors. Their format strings don't follow GCC
1087 diagnostic conventions and the calls are ultimately followed by
1088 one to internal_error. */
1089 # pragma GCC diagnostic push
1090 # pragma GCC diagnostic ignored "-Wformat-diag"
1091 #endif
1093 DEBUG_FUNCTION bool
1094 symtab_node::verify_base (void)
1096 bool error_found = false;
1097 symtab_node *hashed_node;
1099 if (is_a <cgraph_node *> (this))
1101 if (TREE_CODE (decl) != FUNCTION_DECL)
1103 error ("function symbol is not function");
1104 error_found = true;
1106 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))
1107 != NULL)
1108 != dyn_cast <cgraph_node *> (this)->ifunc_resolver)
1110 error ("inconsistent %<ifunc%> attribute");
1111 error_found = true;
1114 else if (is_a <varpool_node *> (this))
1116 if (!VAR_P (decl))
1118 error ("variable symbol is not variable");
1119 error_found = true;
1122 else
1124 error ("node has unknown type");
1125 error_found = true;
1127 if (order < 0 || order >= symtab->order)
1129 error ("node has invalid order %i", order);
1130 error_found = true;
1133 if (symtab->state != LTO_STREAMING)
1135 hashed_node = symtab_node::get (decl);
1136 if (!hashed_node)
1138 error ("node not found node->decl->decl_with_vis.symtab_node");
1139 error_found = true;
1141 if (hashed_node != this
1142 && (!is_a <cgraph_node *> (this)
1143 || !dyn_cast <cgraph_node *> (this)->clone_of
1144 || dyn_cast <cgraph_node *> (this)->clone_of->decl != decl))
1146 error ("node differs from node->decl->decl_with_vis.symtab_node");
1147 error_found = true;
1150 if (symtab->assembler_name_hash)
1152 hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
1153 if (hashed_node)
1155 if (hashed_node->previous_sharing_asm_name)
1157 error ("assembler name hash list corrupted");
1158 error_found = true;
1160 else if (previous_sharing_asm_name == NULL)
1162 if (hashed_node != this)
1164 error ("assembler name hash list corrupted");
1165 error_found = true;
1168 else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl)))
1170 if (!asmname_hasher::equal (previous_sharing_asm_name,
1171 DECL_ASSEMBLER_NAME (decl)))
1173 error ("node not found in symtab assembler name hash");
1174 error_found = true;
1179 if (previous_sharing_asm_name
1180 && previous_sharing_asm_name->next_sharing_asm_name != this)
1182 error ("double linked list of assembler names corrupted");
1183 error_found = true;
1185 if (body_removed && definition)
1187 error ("node has body_removed but is definition");
1188 error_found = true;
1190 if (analyzed && !definition)
1192 error ("node is analyzed but it is not a definition");
1193 error_found = true;
1195 if (cpp_implicit_alias && !alias)
1197 error ("node is alias but not implicit alias");
1198 error_found = true;
1200 if (alias && !definition && !weakref)
1202 error ("node is alias but not definition");
1203 error_found = true;
1205 if (weakref && !transparent_alias)
1207 error ("node is weakref but not an transparent_alias");
1208 error_found = true;
1210 if (transparent_alias && !alias)
1212 error ("node is transparent_alias but not an alias");
1213 error_found = true;
1215 if (symver && !alias)
1217 error ("node is symver but not alias");
1218 error_found = true;
1220 /* Limitation of gas requires us to output targets of symver aliases as
1221 global symbols. This is binutils PR 25295. */
1222 if (symver
1223 && (!TREE_PUBLIC (get_alias_target ()->decl)
1224 || DECL_VISIBILITY (get_alias_target ()->decl) != VISIBILITY_DEFAULT))
1226 error ("symver target is not exported with default visibility");
1227 error_found = true;
1229 if (symver
1230 && (!TREE_PUBLIC (decl)
1231 || DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT))
1233 error ("symver is not exported with default visibility");
1234 error_found = true;
1236 if (same_comdat_group)
1238 symtab_node *n = same_comdat_group;
1240 if (!n->get_comdat_group ())
1242 error ("node is in same_comdat_group list but has no comdat_group");
1243 error_found = true;
1245 if (n->get_comdat_group () != get_comdat_group ())
1247 error ("same_comdat_group list across different groups");
1248 error_found = true;
1250 if (n->type != type)
1252 error ("mixing different types of symbol in same comdat groups is not supported");
1253 error_found = true;
1255 if (n == this)
1257 error ("node is alone in a comdat group");
1258 error_found = true;
1262 if (!n->same_comdat_group)
1264 error ("same_comdat_group is not a circular list");
1265 error_found = true;
1266 break;
1268 n = n->same_comdat_group;
1270 while (n != this);
1271 if (comdat_local_p ())
1273 ipa_ref *ref = NULL;
1275 for (int i = 0; iterate_referring (i, ref); ++i)
1277 if (!in_same_comdat_group_p (ref->referring))
1279 error ("comdat-local symbol referred to by %s outside its "
1280 "comdat",
1281 identifier_to_locale (ref->referring->name()));
1282 error_found = true;
1287 if (implicit_section && !get_section ())
1289 error ("implicit_section flag is set but section isn%'t");
1290 error_found = true;
1292 if (get_section () && get_comdat_group ()
1293 && !implicit_section
1294 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl)))
1296 error ("Both section and comdat group is set");
1297 error_found = true;
1299 /* TODO: Add string table for sections, so we do not keep holding duplicated
1300 strings. */
1301 if (alias && definition
1302 && get_section () != get_alias_target ()->get_section ()
1303 && (!get_section()
1304 || !get_alias_target ()->get_section ()
1305 || strcmp (get_section(),
1306 get_alias_target ()->get_section ())))
1308 error ("Alias and target%'s section differs");
1309 get_alias_target ()->dump (stderr);
1310 error_found = true;
1312 if (alias && definition
1313 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1315 error ("Alias and target%'s comdat groups differs");
1316 get_alias_target ()->dump (stderr);
1317 error_found = true;
1319 if (transparent_alias && definition && !weakref)
1321 symtab_node *to = get_alias_target ();
1322 const char *name1
1323 = IDENTIFIER_POINTER (
1324 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
1325 const char *name2
1326 = IDENTIFIER_POINTER (
1327 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
1328 if (!symbol_table::assembler_names_equal_p (name1, name2))
1330 error ("Transparent alias and target%'s assembler names differs");
1331 get_alias_target ()->dump (stderr);
1332 error_found = true;
1335 if (transparent_alias && definition
1336 && get_alias_target()->transparent_alias && get_alias_target()->analyzed)
1338 error ("Chained transparent aliases");
1339 get_alias_target ()->dump (stderr);
1340 error_found = true;
1343 return error_found;
1346 /* Verify consistency of NODE. */
1348 DEBUG_FUNCTION void
1349 symtab_node::verify (void)
1351 if (seen_error ())
1352 return;
1354 timevar_push (TV_CGRAPH_VERIFY);
1355 if (cgraph_node *node = dyn_cast <cgraph_node *> (this))
1356 node->verify_node ();
1357 else
1358 if (verify_base ())
1360 debug ();
1361 internal_error ("symtab_node::verify failed");
1363 timevar_pop (TV_CGRAPH_VERIFY);
1366 /* Verify symbol table for internal consistency. */
1368 DEBUG_FUNCTION void
1369 symtab_node::verify_symtab_nodes (void)
1371 symtab_node *node;
1372 hash_map<tree, symtab_node *> comdat_head_map (251);
1373 asm_node *anode;
1375 for (anode = symtab->first_asm_symbol (); anode; anode = anode->next)
1376 if (anode->order < 0 || anode->order >= symtab->order)
1378 error ("invalid order in asm node %i", anode->order);
1379 internal_error ("symtab_node::verify failed");
1382 FOR_EACH_SYMBOL (node)
1384 node->verify ();
1385 if (node->get_comdat_group ())
1387 symtab_node **entry, *s;
1388 bool existed;
1390 entry = &comdat_head_map.get_or_insert (node->get_comdat_group (),
1391 &existed);
1392 if (!existed)
1393 *entry = node;
1394 else if (!DECL_EXTERNAL (node->decl))
1396 for (s = (*entry)->same_comdat_group;
1397 s != NULL && s != node && s != *entry;
1398 s = s->same_comdat_group)
1400 if (!s || s == *entry)
1402 error ("Two symbols with same comdat_group are not linked by "
1403 "the same_comdat_group list.");
1404 (*entry)->debug ();
1405 node->debug ();
1406 internal_error ("symtab_node::verify failed");
1413 #if __GNUC__ >= 10
1414 # pragma GCC diagnostic pop
1415 #endif
1417 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1418 but other code such as notice_global_symbol generates rtl. */
1420 void
1421 symtab_node::make_decl_local (void)
1423 rtx rtl, symbol;
1425 if (weakref)
1427 weakref = false;
1428 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
1429 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
1430 symtab->change_decl_assembler_name
1431 (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
1432 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
1433 DECL_ATTRIBUTES (decl));
1435 /* Avoid clearing comdat_groups on comdat-local decls. */
1436 else if (TREE_PUBLIC (decl) == 0)
1437 return;
1439 /* Localizing a symbol also make all its transparent aliases local. */
1440 ipa_ref *ref;
1441 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1443 struct symtab_node *alias = ref->referring;
1444 if (alias->transparent_alias)
1445 alias->make_decl_local ();
1448 if (VAR_P (decl))
1450 DECL_COMMON (decl) = 0;
1451 /* ADDRESSABLE flag is not defined for public symbols. */
1452 TREE_ADDRESSABLE (decl) = 1;
1453 TREE_STATIC (decl) = 1;
1455 else
1456 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1458 DECL_COMDAT (decl) = 0;
1459 DECL_WEAK (decl) = 0;
1460 DECL_EXTERNAL (decl) = 0;
1461 DECL_VISIBILITY_SPECIFIED (decl) = 0;
1462 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
1463 TREE_PUBLIC (decl) = 0;
1464 DECL_DLLIMPORT_P (decl) = 0;
1465 if (!DECL_RTL_SET_P (decl))
1466 return;
1468 /* Update rtl flags. */
1469 make_decl_rtl (decl);
1471 rtl = DECL_RTL (decl);
1472 if (!MEM_P (rtl))
1473 return;
1475 symbol = XEXP (rtl, 0);
1476 if (GET_CODE (symbol) != SYMBOL_REF)
1477 return;
1479 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1482 /* Copy visibility from N.
1483 This is useful when THIS becomes a transparent alias of N. */
1485 void
1486 symtab_node::copy_visibility_from (symtab_node *n)
1488 gcc_checking_assert (n->weakref == weakref);
1490 ipa_ref *ref;
1491 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1493 struct symtab_node *alias = ref->referring;
1494 if (alias->transparent_alias)
1495 alias->copy_visibility_from (n);
1498 if (VAR_P (decl))
1500 DECL_COMMON (decl) = DECL_COMMON (n->decl);
1501 /* ADDRESSABLE flag is not defined for public symbols. */
1502 if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
1503 TREE_ADDRESSABLE (decl) = 1;
1504 TREE_STATIC (decl) = TREE_STATIC (n->decl);
1506 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1508 DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
1509 DECL_WEAK (decl) = DECL_WEAK (n->decl);
1510 DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
1511 DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
1512 DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
1513 TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
1514 DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
1515 resolution = n->resolution;
1516 set_comdat_group (n->get_comdat_group ());
1517 set_section (*n);
1518 externally_visible = n->externally_visible;
1519 if (!DECL_RTL_SET_P (decl))
1520 return;
1522 /* Update rtl flags. */
1523 make_decl_rtl (decl);
1525 rtx rtl = DECL_RTL (decl);
1526 if (!MEM_P (rtl))
1527 return;
1529 rtx symbol = XEXP (rtl, 0);
1530 if (GET_CODE (symbol) != SYMBOL_REF)
1531 return;
1533 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1536 /* Walk the alias chain to return the symbol NODE is alias of.
1537 If NODE is not an alias, return NODE.
1538 Assumes NODE is known to be alias. */
1540 symtab_node *
1541 symtab_node::ultimate_alias_target_1 (enum availability *availability,
1542 symtab_node *ref)
1544 bool transparent_p = false;
1546 /* To determine visibility of the target, we follow ELF semantic of aliases.
1547 Here alias is an alternative assembler name of a given definition. Its
1548 availability prevails the availability of its target (i.e. static alias of
1549 weak definition is available.
1551 Transparent alias is just alternative name of a given symbol used within
1552 one compilation unit and is translated prior hitting the object file. It
1553 inherits the visibility of its target.
1554 Weakref is a different animal (and noweak definition is weak).
1556 If we ever get into supporting targets with different semantics, a target
1557 hook will be needed here. */
1559 if (availability)
1561 transparent_p = transparent_alias;
1562 if (!transparent_p)
1563 *availability = get_availability (ref);
1564 else
1565 *availability = AVAIL_NOT_AVAILABLE;
1568 symtab_node *node = this;
1569 while (node)
1571 if (node->alias && node->analyzed)
1572 node = node->get_alias_target ();
1573 else
1575 if (!availability || (!transparent_p && node->analyzed))
1577 else if (node->analyzed && !node->transparent_alias)
1578 *availability = node->get_availability (ref);
1579 else
1580 *availability = AVAIL_NOT_AVAILABLE;
1581 return node;
1583 if (node && availability && transparent_p
1584 && node->transparent_alias)
1586 *availability = node->get_availability (ref);
1587 transparent_p = false;
1590 if (availability)
1591 *availability = AVAIL_NOT_AVAILABLE;
1592 return NULL;
1595 /* C++ FE sometimes change linkage flags after producing same body aliases.
1597 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1598 are obviously equivalent. The way it is doing so is however somewhat
1599 kludgy and interferes with the visibility code. As a result we need to
1600 copy the visibility from the target to get things right. */
1602 void
1603 symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
1605 if (is_a <cgraph_node *> (this))
1607 DECL_DECLARED_INLINE_P (decl)
1608 = DECL_DECLARED_INLINE_P (target->decl);
1609 DECL_DISREGARD_INLINE_LIMITS (decl)
1610 = DECL_DISREGARD_INLINE_LIMITS (target->decl);
1612 /* FIXME: It is not really clear why those flags should not be copied for
1613 functions, too. */
1614 else
1616 DECL_WEAK (decl) = DECL_WEAK (target->decl);
1617 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1618 DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
1620 if (TREE_PUBLIC (decl))
1622 tree group;
1624 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1625 DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
1626 group = target->get_comdat_group ();
1627 set_comdat_group (group);
1628 if (group && !same_comdat_group)
1629 add_to_same_comdat_group (target);
1631 externally_visible = target->externally_visible;
1634 /* Set section, do not recurse into aliases.
1635 When one wants to change section of a symbol and its aliases,
1636 use set_section. */
1638 void
1639 symtab_node::set_section_for_node (const char *section)
1641 const char *current = get_section ();
1643 if (current == section
1644 || (current && section
1645 && !strcmp (current, section)))
1646 return;
1648 release_section_hash_entry (x_section);
1649 if (!section)
1651 x_section = NULL;
1652 implicit_section = false;
1653 return;
1655 if (!symtab->section_hash)
1656 symtab->section_hash = hash_table<section_name_hasher>::create_ggc (10);
1657 section_hash_entry **slot = symtab->section_hash->find_slot_with_hash
1658 (section, htab_hash_string (section), INSERT);
1659 if (*slot)
1660 x_section = retain_section_hash_entry (*slot);
1661 else
1663 int len = strlen (section);
1664 *slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
1665 x_section->ref_count = 1;
1666 x_section->name = ggc_vec_alloc<char> (len + 1);
1667 memcpy (x_section->name, section, len + 1);
1671 /* Set the section of node THIS to be the same as the section
1672 of node OTHER. Keep reference counts of the sections
1673 up-to-date as needed. */
1675 void
1676 symtab_node::set_section_for_node (const symtab_node &other)
1678 if (x_section == other.x_section)
1679 return;
1680 if (get_section () && other.get_section ())
1681 gcc_checking_assert (strcmp (get_section (), other.get_section ()) != 0);
1682 release_section_hash_entry (x_section);
1683 if (other.x_section)
1684 x_section = retain_section_hash_entry (other.x_section);
1685 else
1687 x_section = NULL;
1688 implicit_section = false;
1692 /* Workers for set_section. */
1694 bool
1695 symtab_node::set_section_from_string (symtab_node *n, void *s)
1697 n->set_section_for_node ((char *)s);
1698 return false;
1701 /* Set the section of node N to be the same as the section
1702 of node O. */
1704 bool
1705 symtab_node::set_section_from_node (symtab_node *n, void *o)
1707 const symtab_node &other = *static_cast<const symtab_node *> (o);
1708 n->set_section_for_node (other);
1709 return false;
1712 /* Set section of symbol and its aliases. */
1714 void
1715 symtab_node::set_section (const char *section)
1717 gcc_assert (!this->alias || !this->analyzed);
1718 call_for_symbol_and_aliases
1719 (symtab_node::set_section_from_string, const_cast<char *>(section), true);
1722 void
1723 symtab_node::set_section (const symtab_node &other)
1725 call_for_symbol_and_aliases
1726 (symtab_node::set_section_from_node, const_cast<symtab_node *>(&other), true);
1729 /* Return the initialization priority. */
1731 priority_type
1732 symtab_node::get_init_priority ()
1734 if (!this->in_init_priority_hash)
1735 return DEFAULT_INIT_PRIORITY;
1737 symbol_priority_map *h = symtab->init_priority_hash->get (this);
1738 return h ? h->init : DEFAULT_INIT_PRIORITY;
1741 /* Return the finalization priority. */
1743 priority_type
1744 cgraph_node::get_fini_priority ()
1746 if (!this->in_init_priority_hash)
1747 return DEFAULT_INIT_PRIORITY;
1748 symbol_priority_map *h = symtab->init_priority_hash->get (this);
1749 return h ? h->fini : DEFAULT_INIT_PRIORITY;
1752 /* Return the initialization and finalization priority information for
1753 DECL. If there is no previous priority information, a freshly
1754 allocated structure is returned. */
1756 symbol_priority_map *
1757 symtab_node::priority_info (void)
1759 if (!symtab->init_priority_hash)
1760 symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (13);
1762 bool existed;
1763 symbol_priority_map *h
1764 = &symtab->init_priority_hash->get_or_insert (this, &existed);
1765 if (!existed)
1767 h->init = DEFAULT_INIT_PRIORITY;
1768 h->fini = DEFAULT_INIT_PRIORITY;
1769 in_init_priority_hash = true;
1772 return h;
1775 /* Set initialization priority to PRIORITY. */
1777 void
1778 symtab_node::set_init_priority (priority_type priority)
1780 symbol_priority_map *h;
1782 if (is_a <cgraph_node *> (this))
1783 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
1785 if (priority == DEFAULT_INIT_PRIORITY)
1787 gcc_assert (get_init_priority() == priority);
1788 return;
1790 h = priority_info ();
1791 h->init = priority;
1794 /* Set finalization priority to PRIORITY. */
1796 void
1797 cgraph_node::set_fini_priority (priority_type priority)
1799 symbol_priority_map *h;
1801 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
1803 if (priority == DEFAULT_INIT_PRIORITY)
1805 gcc_assert (get_fini_priority() == priority);
1806 return;
1808 h = priority_info ();
1809 h->fini = priority;
1812 /* Worker for symtab_resolve_alias. */
1814 bool
1815 symtab_node::set_implicit_section (symtab_node *n,
1816 void *data ATTRIBUTE_UNUSED)
1818 n->implicit_section = true;
1819 return false;
1822 /* Add reference recording that symtab node is alias of TARGET.
1823 The function can fail in the case of aliasing cycles; in this case
1824 it returns false. */
1826 bool
1827 symtab_node::resolve_alias (symtab_node *target, bool transparent)
1829 symtab_node *n;
1831 gcc_assert (!analyzed && !ref_list.references.length ());
1833 /* Never let cycles to creep into the symbol table alias references;
1834 those will make alias walkers to be infinite. */
1835 for (n = target; n && n->alias;
1836 n = n->analyzed ? n->get_alias_target () : NULL)
1837 if (n == this)
1839 if (is_a <cgraph_node *> (this))
1840 error ("function %q+D part of alias cycle", decl);
1841 else if (is_a <varpool_node *> (this))
1842 error ("variable %q+D part of alias cycle", decl);
1843 else
1844 gcc_unreachable ();
1845 alias = false;
1846 return false;
1849 /* "analyze" the node - i.e. mark the reference. */
1850 definition = true;
1851 alias = true;
1852 analyzed = true;
1853 transparent |= transparent_alias;
1854 transparent_alias = transparent;
1855 if (transparent)
1856 while (target->transparent_alias && target->analyzed)
1857 target = target->get_alias_target ();
1858 create_reference (target, IPA_REF_ALIAS, NULL);
1860 /* Add alias into the comdat group of its target unless it is already there. */
1861 if (same_comdat_group)
1862 remove_from_same_comdat_group ();
1863 set_comdat_group (NULL);
1864 if (target->get_comdat_group ())
1865 add_to_same_comdat_group (target);
1867 if ((get_section () != target->get_section ()
1868 || target->get_comdat_group ()) && get_section () && !implicit_section)
1870 error ("section of alias %q+D must match section of its target", decl);
1872 set_section (*target);
1873 if (target->implicit_section)
1874 call_for_symbol_and_aliases (set_implicit_section, NULL, true);
1876 /* Alias targets become redundant after alias is resolved into an reference.
1877 We do not want to keep it around or we would have to mind updating them
1878 when renaming symbols. */
1879 alias_target = NULL;
1881 if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
1882 fixup_same_cpp_alias_visibility (target);
1884 /* If alias has address taken, so does the target. */
1885 if (address_taken)
1886 target->ultimate_alias_target ()->address_taken = true;
1888 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1889 If alias is transparent, also all transparent aliases of THIS are now
1890 aliases of TARGET.
1891 Also merge same comdat group lists. */
1892 ipa_ref *ref;
1893 for (unsigned i = 0; iterate_direct_aliases (i, ref);)
1895 struct symtab_node *alias_alias = ref->referring;
1896 if (alias_alias->get_comdat_group ())
1898 alias_alias->remove_from_same_comdat_group ();
1899 alias_alias->set_comdat_group (NULL);
1900 if (target->get_comdat_group ())
1901 alias_alias->add_to_same_comdat_group (target);
1903 if ((!alias_alias->transparent_alias
1904 && !alias_alias->symver)
1905 || transparent)
1907 alias_alias->remove_all_references ();
1908 alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
1910 else i++;
1912 return true;
1915 /* Worker searching noninterposable alias. */
1917 bool
1918 symtab_node::noninterposable_alias (symtab_node *node, void *data)
1920 if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
1922 symtab_node *fn = node->ultimate_alias_target ();
1924 /* Ensure that the alias is well formed this may not be the case
1925 of user defined aliases and currently it is not always the case
1926 of C++ same body aliases (that is a bug). */
1927 if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
1928 || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
1929 || (TREE_CODE (node->decl) == FUNCTION_DECL
1930 && flags_from_decl_or_type (node->decl)
1931 != flags_from_decl_or_type (fn->decl))
1932 || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
1933 return false;
1934 *(symtab_node **)data = node;
1935 return true;
1937 return false;
1940 /* If node cannot be overwriten by static or dynamic linker to point to
1941 different definition, return NODE. Otherwise look for alias with such
1942 property and if none exists, introduce new one. */
1944 symtab_node *
1945 symtab_node::noninterposable_alias (void)
1947 tree new_decl;
1948 symtab_node *new_node = NULL;
1950 /* First try to look up existing alias or base object
1951 (if that is already non-overwritable). */
1952 symtab_node *node = ultimate_alias_target ();
1953 gcc_assert (!node->alias && !node->weakref);
1954 node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias,
1955 (void *)&new_node, true);
1956 if (new_node)
1957 return new_node;
1959 /* If aliases aren't supported by the assembler, fail. */
1960 if (!TARGET_SUPPORTS_ALIASES)
1961 return NULL;
1962 else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (node->decl)))
1963 return NULL;
1965 /* Otherwise create a new one. */
1966 new_decl = copy_node (node->decl);
1967 DECL_DLLIMPORT_P (new_decl) = 0;
1968 tree name = clone_function_name (node->decl, "localalias");
1969 if (!flag_wpa)
1971 unsigned long num = 0;
1972 /* In the rare case we already have a localalias, but the above
1973 node->call_for_symbol_and_aliases call didn't find any suitable,
1974 iterate until we find one not used yet. */
1975 while (symtab_node::get_for_asmname (name))
1976 name = clone_function_name (node->decl, "localalias", num++);
1978 DECL_NAME (new_decl) = name;
1979 if (TREE_CODE (new_decl) == FUNCTION_DECL)
1980 DECL_STRUCT_FUNCTION (new_decl) = NULL;
1981 DECL_INITIAL (new_decl) = NULL;
1982 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1983 SET_DECL_RTL (new_decl, NULL);
1985 /* Update the properties. */
1986 DECL_EXTERNAL (new_decl) = 0;
1987 TREE_PUBLIC (new_decl) = 0;
1988 DECL_COMDAT (new_decl) = 0;
1989 DECL_WEAK (new_decl) = 0;
1991 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1992 DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
1993 if (TREE_CODE (new_decl) == FUNCTION_DECL)
1995 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
1996 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
1997 new_node = cgraph_node::create_alias (new_decl, node->decl);
1999 cgraph_node *new_cnode = dyn_cast <cgraph_node *> (new_node),
2000 *cnode = dyn_cast <cgraph_node *> (node);
2002 new_cnode->unit_id = cnode->unit_id;
2003 new_cnode->merged_comdat = cnode->merged_comdat;
2004 new_cnode->merged_extern_inline = cnode->merged_extern_inline;
2006 else
2008 TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
2009 DECL_INITIAL (new_decl) = error_mark_node;
2010 new_node = varpool_node::create_alias (new_decl, node->decl);
2012 new_node->resolve_alias (node);
2013 gcc_assert (decl_binds_to_current_def_p (new_decl)
2014 && targetm.binds_local_p (new_decl));
2015 return new_node;
2018 /* Return true if symtab node and TARGET represents
2019 semantically equivalent symbols. */
2021 bool
2022 symtab_node::semantically_equivalent_p (symtab_node *target)
2024 enum availability avail;
2025 symtab_node *ba;
2026 symtab_node *bb;
2028 /* Equivalent functions are equivalent. */
2029 if (decl == target->decl)
2030 return true;
2032 /* If symbol is not overwritable by different implementation,
2033 walk to the base object it defines. */
2034 ba = ultimate_alias_target (&avail);
2035 if (avail >= AVAIL_AVAILABLE)
2037 if (target == ba)
2038 return true;
2040 else
2041 ba = this;
2042 bb = target->ultimate_alias_target (&avail);
2043 if (avail >= AVAIL_AVAILABLE)
2045 if (this == bb)
2046 return true;
2048 else
2049 bb = target;
2050 return bb == ba;
2053 /* Classify symbol symtab node for partitioning. */
2055 enum symbol_partitioning_class
2056 symtab_node::get_partitioning_class (void)
2058 /* Inline clones are always duplicated.
2059 This include external declarations. */
2060 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
2062 if (DECL_ABSTRACT_P (decl))
2063 return SYMBOL_EXTERNAL;
2065 if (cnode && (cnode->inlined_to || cnode->declare_variant_alt))
2066 return SYMBOL_DUPLICATE;
2068 /* Transparent aliases are always duplicated. */
2069 if (transparent_alias)
2070 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
2072 /* External declarations are external. */
2073 if (DECL_EXTERNAL (decl))
2074 return SYMBOL_EXTERNAL;
2076 /* Even static aliases of external functions as external. Those can happen
2077 when COMDAT got resolved to non-IL implementation. */
2078 if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
2079 return SYMBOL_EXTERNAL;
2081 if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
2083 if (alias && definition && !ultimate_alias_target ()->definition)
2084 return SYMBOL_EXTERNAL;
2085 /* Constant pool references use local symbol names that cannot
2086 be promoted global. We should never put into a constant pool
2087 objects that cannot be duplicated across partitions. */
2088 if (DECL_IN_CONSTANT_POOL (decl))
2089 return SYMBOL_DUPLICATE;
2090 if (DECL_HARD_REGISTER (decl))
2091 return SYMBOL_DUPLICATE;
2092 gcc_checking_assert (vnode->definition);
2094 /* Functions that are cloned may stay in callgraph even if they are unused.
2095 Handle them as external; compute_ltrans_boundary take care to make
2096 proper things to happen (i.e. to make them appear in the boundary but
2097 with body streamed, so clone can me materialized). */
2098 else if (!dyn_cast <cgraph_node *> (this)->function_symbol ()->definition)
2099 return SYMBOL_EXTERNAL;
2101 /* Linker discardable symbols are duplicated to every use unless they are
2102 keyed. */
2103 if (DECL_ONE_ONLY (decl)
2104 && !force_output
2105 && !forced_by_abi
2106 && !used_from_object_file_p ())
2107 return SYMBOL_DUPLICATE;
2109 return SYMBOL_PARTITION;
2112 /* Return true when symbol is known to be non-zero. */
2114 bool
2115 symtab_node::nonzero_address ()
2117 /* Weakrefs may be NULL when their target is not defined. */
2118 if (alias && weakref)
2120 if (analyzed)
2122 symtab_node *target = ultimate_alias_target ();
2124 if (target->alias && target->weakref)
2125 return false;
2126 /* We cannot recurse to target::nonzero. It is possible that the
2127 target is used only via the alias.
2128 We may walk references and look for strong use, but we do not know
2129 if this strong use will survive to final binary, so be
2130 conservative here.
2131 ??? Maybe we could do the lookup during late optimization that
2132 could be useful to eliminate the NULL pointer checks in LTO
2133 programs. */
2134 if (target->definition && !DECL_EXTERNAL (target->decl))
2135 return true;
2136 if (target->resolution != LDPR_UNKNOWN
2137 && target->resolution != LDPR_UNDEF
2138 && !target->can_be_discarded_p ()
2139 && flag_delete_null_pointer_checks)
2140 return true;
2141 return false;
2143 else
2144 return false;
2147 /* With !flag_delete_null_pointer_checks we assume that symbols may
2148 bind to NULL. This is on by default on embedded targets only.
2150 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2151 linking fails. Important case of WEAK we want to do well are comdats,
2152 which also must be defined somewhere.
2154 When parsing, beware the cases when WEAK attribute is added later. */
2155 if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
2156 && flag_delete_null_pointer_checks)
2158 refuse_visibility_changes = true;
2159 return true;
2162 /* If target is defined and not extern, we know it will be
2163 output and thus it will bind to non-NULL.
2164 Play safe for flag_delete_null_pointer_checks where weak definition may
2165 be re-defined by NULL. */
2166 if (definition && !DECL_EXTERNAL (decl)
2167 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
2169 if (!DECL_WEAK (decl))
2170 refuse_visibility_changes = true;
2171 return true;
2174 /* As the last resort, check the resolution info. */
2175 if (resolution != LDPR_UNKNOWN
2176 && resolution != LDPR_UNDEF
2177 && !can_be_discarded_p ()
2178 && flag_delete_null_pointer_checks)
2179 return true;
2180 return false;
2183 /* Return 0 if symbol is known to have different address than S2,
2184 Return 1 if symbol is known to have same address as S2,
2185 return -1 otherwise.
2187 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2188 and S2 is going to be accessed. This eliminates the situations when
2189 either THIS or S2 is NULL and is useful for comparing bases when deciding
2190 about memory aliasing. */
2192 symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
2194 enum availability avail1, avail2;
2196 /* A Shortcut: equivalent symbols are always equivalent. */
2197 if (this == s2)
2198 return 1;
2200 /* Unwind transparent aliases first; those are always equal to their
2201 target. */
2202 if (this->transparent_alias && this->analyzed)
2203 return this->get_alias_target ()->equal_address_to (s2);
2204 while (s2->transparent_alias && s2->analyzed)
2205 s2 = s2->get_alias_target();
2207 if (this == s2)
2208 return 1;
2210 /* For non-interposable aliases, lookup and compare their actual definitions.
2211 Also check if the symbol needs to bind to given definition. */
2212 symtab_node *rs1 = ultimate_alias_target (&avail1);
2213 symtab_node *rs2 = s2->ultimate_alias_target (&avail2);
2214 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
2215 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
2216 bool really_binds_local1 = binds_local1;
2217 bool really_binds_local2 = binds_local2;
2219 /* Addresses of vtables and virtual functions cannot be used by user
2220 code and are used only within speculation. In this case we may make
2221 symbol equivalent to its alias even if interposition may break this
2222 rule. Doing so will allow us to turn speculative inlining into
2223 non-speculative more aggressively. */
2224 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
2225 binds_local1 = true;
2226 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
2227 binds_local2 = true;
2229 /* If both definitions are available we know that even if they are bound
2230 to other unit they must be defined same way and therefore we can use
2231 equivalence test. */
2232 if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
2233 binds_local1 = binds_local2 = true;
2235 if (binds_local1 && binds_local2 && rs1 == rs2)
2237 /* We made use of the fact that alias is not weak. */
2238 if (rs1 != this)
2239 refuse_visibility_changes = true;
2240 if (rs2 != s2)
2241 s2->refuse_visibility_changes = true;
2242 return 1;
2245 /* If both symbols may resolve to NULL, we cannot really prove them
2246 different. */
2247 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
2248 return -1;
2250 /* Except for NULL, functions and variables never overlap. */
2251 if (TREE_CODE (decl) != TREE_CODE (s2->decl))
2252 return 0;
2254 /* If one of the symbols is unresolved alias, punt. */
2255 if (rs1->alias || rs2->alias)
2256 return -1;
2258 /* If we have a non-interposale definition of at least one of the symbols
2259 and the other symbol is different, we know other unit cannot interpose
2260 it to the first symbol; all aliases of the definition needs to be
2261 present in the current unit. */
2262 if (((really_binds_local1 || really_binds_local2)
2263 /* If we have both definitions and they are different, we know they
2264 will be different even in units they binds to. */
2265 || (binds_local1 && binds_local2))
2266 && rs1 != rs2)
2268 /* We make use of the fact that one symbol is not alias of the other
2269 and that the definition is non-interposable. */
2270 refuse_visibility_changes = true;
2271 s2->refuse_visibility_changes = true;
2272 rs1->refuse_visibility_changes = true;
2273 rs2->refuse_visibility_changes = true;
2274 return 0;
2277 /* TODO: Alias oracle basically assume that addresses of global variables
2278 are different unless they are declared as alias of one to another while
2279 the code folding comparisons doesn't.
2280 We probably should be consistent and use this fact here, too, but for
2281 the moment return false only when we are called from the alias oracle. */
2283 return memory_accessed && rs1 != rs2 ? 0 : -1;
2286 /* Worker for call_for_symbol_and_aliases. */
2288 bool
2289 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
2290 void *),
2291 void *data,
2292 bool include_overwritable)
2294 ipa_ref *ref;
2295 FOR_EACH_ALIAS (this, ref)
2297 symtab_node *alias = ref->referring;
2298 if (include_overwritable
2299 || alias->get_availability () > AVAIL_INTERPOSABLE)
2300 if (alias->call_for_symbol_and_aliases (callback, data,
2301 include_overwritable))
2302 return true;
2304 return false;
2307 /* Return true if address of N is possibly compared. */
2309 static bool
2310 address_matters_1 (symtab_node *n, void *)
2312 struct ipa_ref *ref;
2314 if (!n->address_can_be_compared_p ())
2315 return false;
2316 if (n->externally_visible || n->force_output)
2317 return true;
2319 for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
2320 if (ref->address_matters_p ())
2321 return true;
2322 return false;
2325 /* Return true if symbol's address may possibly be compared to other
2326 symbol's address. */
2328 bool
2329 symtab_node::address_matters_p ()
2331 gcc_assert (!alias);
2332 return call_for_symbol_and_aliases (address_matters_1, NULL, true);
2335 /* Return true if symbol's alignment may be increased. */
2337 bool
2338 symtab_node::can_increase_alignment_p (void)
2340 symtab_node *target = ultimate_alias_target ();
2342 /* For now support only variables. */
2343 if (!VAR_P (decl))
2344 return false;
2346 /* With -fno-toplevel-reorder we may have already output the constant. */
2347 if (TREE_ASM_WRITTEN (target->decl))
2348 return false;
2350 /* If target is already placed in an anchor, we cannot touch its
2351 alignment. */
2352 if (DECL_RTL_SET_P (target->decl)
2353 && MEM_P (DECL_RTL (target->decl))
2354 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
2355 return false;
2357 /* Constant pool entries may be shared. */
2358 if (DECL_IN_CONSTANT_POOL (target->decl))
2359 return false;
2361 /* We cannot change alignment of symbols that may bind to symbols
2362 in other translation unit that may contain a definition with lower
2363 alignment. */
2364 if (!decl_binds_to_current_def_p (decl))
2365 return false;
2367 /* When compiling partition, be sure the symbol is not output by other
2368 partition. */
2369 if (flag_ltrans
2370 && (target->in_other_partition
2371 || target->get_partitioning_class () == SYMBOL_DUPLICATE))
2372 return false;
2374 /* Do not override the alignment as specified by the ABI when the used
2375 attribute is set. */
2376 if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
2377 return false;
2379 /* Do not override explicit alignment set by the user when an explicit
2380 section name is also used. This is a common idiom used by many
2381 software projects. */
2382 if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
2383 return false;
2385 return true;
2388 /* Worker for symtab_node::increase_alignment. */
2390 static bool
2391 increase_alignment_1 (symtab_node *n, void *v)
2393 unsigned int align = (size_t)v;
2394 if (DECL_ALIGN (n->decl) < align
2395 && n->can_increase_alignment_p ())
2397 SET_DECL_ALIGN (n->decl, align);
2398 DECL_USER_ALIGN (n->decl) = 1;
2400 return false;
2403 /* Increase alignment of THIS to ALIGN. */
2405 void
2406 symtab_node::increase_alignment (unsigned int align)
2408 gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
2409 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1,
2410 (void *)(size_t) align,
2411 true);
2412 gcc_assert (DECL_ALIGN (decl) >= align);
2415 /* Helper for symtab_node::definition_alignment. */
2417 static bool
2418 get_alignment_1 (symtab_node *n, void *v)
2420 *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
2421 return false;
2424 /* Return desired alignment of the definition. This is NOT alignment useful
2425 to access THIS, because THIS may be interposable and DECL_ALIGN should
2426 be used instead. It however must be guaranteed when output definition
2427 of THIS. */
2429 unsigned int
2430 symtab_node::definition_alignment ()
2432 unsigned int align = 0;
2433 gcc_assert (!alias);
2434 call_for_symbol_and_aliases (get_alignment_1, &align, true);
2435 return align;
2438 /* Return symbol used to separate symbol name from suffix. */
2440 char
2441 symbol_table::symbol_suffix_separator ()
2443 #ifndef NO_DOT_IN_LABEL
2444 return '.';
2445 #elif !defined NO_DOLLAR_IN_LABEL
2446 return '$';
2447 #else
2448 return '_';
2449 #endif
2452 /* Return true when references to this symbol from REF must bind to current
2453 definition in final executable. */
2455 bool
2456 symtab_node::binds_to_current_def_p (symtab_node *ref)
2458 if (!definition && !in_other_partition)
2459 return false;
2460 if (transparent_alias)
2461 return definition
2462 && get_alias_target()->binds_to_current_def_p (ref);
2463 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
2464 if (cnode && cnode->ifunc_resolver)
2465 return false;
2466 if (decl_binds_to_current_def_p (decl))
2467 return true;
2469 /* Inline clones always binds locally. */
2470 if (cnode && cnode->inlined_to)
2471 return true;
2473 if (DECL_EXTERNAL (decl))
2474 return false;
2476 gcc_assert (externally_visible);
2478 if (ref)
2480 cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
2481 if (cref)
2482 ref = cref->inlined_to;
2485 /* If this is a reference from symbol itself and there are no aliases, we
2486 may be sure that the symbol was not interposed by something else because
2487 the symbol itself would be unreachable otherwise. This is important
2488 to optimize recursive functions well.
2490 This assumption may be broken by inlining: if symbol is interposable
2491 but the body is available (i.e. declared inline), inliner may make
2492 the body reachable even with interposition. */
2493 if (this == ref && !has_aliases_p ()
2494 && (!cnode
2495 || symtab->state >= IPA_SSA_AFTER_INLINING
2496 || get_availability () >= AVAIL_INTERPOSABLE))
2497 return true;
2500 /* References within one comdat group are always bound in a group. */
2501 if (ref
2502 && symtab->state >= IPA_SSA_AFTER_INLINING
2503 && get_comdat_group ()
2504 && get_comdat_group () == ref->get_comdat_group ())
2505 return true;
2507 return false;
2510 /* Return true if symbol should be output to the symbol table. */
2512 bool
2513 symtab_node::output_to_lto_symbol_table_p (void)
2515 /* Only externally visible symbols matter. */
2516 if (!TREE_PUBLIC (decl))
2517 return false;
2518 if (!real_symbol_p ())
2519 return false;
2520 /* FIXME: variables probably should not be considered as real symbols at
2521 first place. */
2522 if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
2523 return false;
2524 if (TREE_CODE (decl) == FUNCTION_DECL && !definition
2525 && fndecl_built_in_p (decl))
2527 /* Builtins like those for most math functions have actual implementations
2528 in libraries so make sure to output references into the symbol table to
2529 make those libraries referenced. Note this is incomplete handling for
2530 now and only covers math functions. */
2531 return builtin_with_linkage_p (decl);
2534 /* We have real symbol that should be in symbol table. However try to trim
2535 down the references to libraries bit more because linker will otherwise
2536 bring unnecessary object files into the final link.
2537 FIXME: The following checks can easily be confused i.e. by self recursive
2538 function or self-referring variable. */
2540 /* We keep external functions in symtab for sake of inlining
2541 and devirtualization. We do not want to see them in symbol table as
2542 references unless they are really used. */
2543 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
2544 if (cnode && (!definition || DECL_EXTERNAL (decl))
2545 && cnode->callers)
2546 return true;
2548 /* Ignore all references from external vars initializers - they are not really
2549 part of the compilation unit until they are used by folding. Some symbols,
2550 like references to external construction vtables cannot be referred to at
2551 all. We decide this at can_refer_decl_in_current_unit_p. */
2552 if (!definition || DECL_EXTERNAL (decl))
2554 int i;
2555 struct ipa_ref *ref;
2556 for (i = 0; iterate_referring (i, ref); i++)
2558 if (ref->use == IPA_REF_ALIAS)
2559 continue;
2560 if (is_a <cgraph_node *> (ref->referring))
2561 return true;
2562 if (!DECL_EXTERNAL (ref->referring->decl))
2563 return true;
2565 return false;
2567 return true;