Daily bump.
[official-gcc.git] / gcc / symtab.c
blobb54183fbd49c22549ea6c03e87ed50fa3434c63c
1 /* Symbol table.
2 Copyright (C) 2012-2018 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","chkp"};
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 /* Initalize 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 /* Add node into symbol table. This function is not used directly, but via
372 cgraph/varpool node creation routines. */
374 void
375 symtab_node::register_symbol (void)
377 symtab->register_symbol (this);
379 if (!decl->decl_with_vis.symtab_node)
380 decl->decl_with_vis.symtab_node = this;
382 ref_list.clear ();
384 /* Be sure to do this last; C++ FE might create new nodes via
385 DECL_ASSEMBLER_NAME langhook! */
386 symtab->insert_to_assembler_name_hash (this, false);
389 /* Remove NODE from same comdat group. */
391 void
392 symtab_node::remove_from_same_comdat_group (void)
394 if (same_comdat_group)
396 symtab_node *prev;
397 for (prev = same_comdat_group;
398 prev->same_comdat_group != this;
399 prev = prev->same_comdat_group)
401 if (same_comdat_group == prev)
402 prev->same_comdat_group = NULL;
403 else
404 prev->same_comdat_group = same_comdat_group;
405 same_comdat_group = NULL;
406 set_comdat_group (NULL);
410 /* Remove node from symbol table. This function is not used directly, but via
411 cgraph/varpool node removal routines. */
413 void
414 symtab_node::unregister (void)
416 remove_all_references ();
417 remove_all_referring ();
419 /* Remove reference to section. */
420 set_section_for_node (NULL);
422 remove_from_same_comdat_group ();
424 symtab->unregister (this);
426 /* During LTO symtab merging we temporarily corrupt decl to symtab node
427 hash. */
428 gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p);
429 if (decl->decl_with_vis.symtab_node == this)
431 symtab_node *replacement_node = NULL;
432 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
433 replacement_node = cnode->find_replacement ();
434 decl->decl_with_vis.symtab_node = replacement_node;
436 if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl))
437 symtab->unlink_from_assembler_name_hash (this, false);
438 if (in_init_priority_hash)
439 symtab->init_priority_hash->remove (this);
443 /* Remove symbol from symbol table. */
445 void
446 symtab_node::remove (void)
448 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
449 cnode->remove ();
450 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
451 vnode->remove ();
454 /* Add NEW_ to the same comdat group that OLD is in. */
456 void
457 symtab_node::add_to_same_comdat_group (symtab_node *old_node)
459 gcc_assert (old_node->get_comdat_group ());
460 gcc_assert (!same_comdat_group);
461 gcc_assert (this != old_node);
463 set_comdat_group (old_node->get_comdat_group ());
464 same_comdat_group = old_node;
465 if (!old_node->same_comdat_group)
466 old_node->same_comdat_group = this;
467 else
469 symtab_node *n;
470 for (n = old_node->same_comdat_group;
471 n->same_comdat_group != old_node;
472 n = n->same_comdat_group)
474 n->same_comdat_group = this;
478 /* Dissolve the same_comdat_group list in which NODE resides. */
480 void
481 symtab_node::dissolve_same_comdat_group_list (void)
483 symtab_node *n = this;
484 symtab_node *next;
486 if (!same_comdat_group)
487 return;
490 next = n->same_comdat_group;
491 n->same_comdat_group = NULL;
492 /* Clear comdat_group for comdat locals, since
493 make_decl_local doesn't. */
494 if (!TREE_PUBLIC (n->decl))
495 n->set_comdat_group (NULL);
496 n = next;
498 while (n != this);
501 /* Return printable assembler name of NODE.
502 This function is used only for debugging. When assembler name
503 is unknown go with identifier name. */
505 const char *
506 symtab_node::asm_name () const
508 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
509 return name ();
510 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
513 /* Return printable identifier name. */
515 const char *
516 symtab_node::name () const
518 if (!DECL_NAME (decl))
520 if (DECL_ASSEMBLER_NAME_SET_P (decl))
521 return asm_name ();
522 else
523 return "<unnamed>";
525 return lang_hooks.decl_printable_name (decl, 2);
528 const char *
529 symtab_node::get_dump_name (bool asm_name_p) const
531 #define EXTRA 16
532 const char *fname = asm_name_p ? asm_name () : name ();
533 unsigned l = strlen (fname);
535 char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA);
536 snprintf (s, l + EXTRA, "%s/%d", fname, order);
538 return s;
541 const char *
542 symtab_node::dump_name () const
544 return get_dump_name (false);
547 const char *
548 symtab_node::dump_asm_name () const
550 return get_dump_name (true);
553 /* Return ipa reference from this symtab_node to
554 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
555 of the use. */
557 ipa_ref *
558 symtab_node::create_reference (symtab_node *referred_node,
559 enum ipa_ref_use use_type)
561 return create_reference (referred_node, use_type, NULL);
565 /* Return ipa reference from this symtab_node to
566 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
567 of the use and STMT the statement (if it exists). */
569 ipa_ref *
570 symtab_node::create_reference (symtab_node *referred_node,
571 enum ipa_ref_use use_type, gimple *stmt)
573 ipa_ref *ref = NULL, *ref2 = NULL;
574 ipa_ref_list *list, *list2;
575 ipa_ref_t *old_references;
577 gcc_checking_assert (!stmt || is_a <cgraph_node *> (this));
578 gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
580 list = &ref_list;
581 old_references = vec_safe_address (list->references);
582 vec_safe_grow (list->references, vec_safe_length (list->references) + 1);
583 ref = &list->references->last ();
585 list2 = &referred_node->ref_list;
587 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
588 if(use_type == IPA_REF_ALIAS)
590 list2->referring.safe_insert (0, ref);
591 ref->referred_index = 0;
593 for (unsigned int i = 1; i < list2->referring.length (); i++)
594 list2->referring[i]->referred_index = i;
596 else
598 list2->referring.safe_push (ref);
599 ref->referred_index = list2->referring.length () - 1;
602 ref->referring = this;
603 ref->referred = referred_node;
604 ref->stmt = stmt;
605 ref->lto_stmt_uid = 0;
606 ref->use = use_type;
607 ref->speculative = 0;
609 /* If vector was moved in memory, update pointers. */
610 if (old_references != list->references->address ())
612 int i;
613 for (i = 0; iterate_reference(i, ref2); i++)
614 ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2;
616 return ref;
619 ipa_ref *
620 symtab_node::maybe_create_reference (tree val, gimple *stmt)
622 STRIP_NOPS (val);
623 ipa_ref_use use_type;
625 switch (TREE_CODE (val))
627 case VAR_DECL:
628 use_type = IPA_REF_LOAD;
629 break;
630 case ADDR_EXPR:
631 use_type = IPA_REF_ADDR;
632 break;
633 default:
634 gcc_assert (!handled_component_p (val));
635 return NULL;
638 val = get_base_var (val);
639 if (val && VAR_OR_FUNCTION_DECL_P (val))
641 symtab_node *referred = symtab_node::get (val);
642 gcc_checking_assert (referred);
643 return create_reference (referred, use_type, stmt);
645 return NULL;
648 /* Clone all references from symtab NODE to this symtab_node. */
650 void
651 symtab_node::clone_references (symtab_node *node)
653 ipa_ref *ref = NULL, *ref2 = NULL;
654 int i;
655 for (i = 0; node->iterate_reference (i, ref); i++)
657 bool speculative = ref->speculative;
658 unsigned int stmt_uid = ref->lto_stmt_uid;
660 ref2 = create_reference (ref->referred, ref->use, ref->stmt);
661 ref2->speculative = speculative;
662 ref2->lto_stmt_uid = stmt_uid;
666 /* Clone all referring from symtab NODE to this symtab_node. */
668 void
669 symtab_node::clone_referring (symtab_node *node)
671 ipa_ref *ref = NULL, *ref2 = NULL;
672 int i;
673 for (i = 0; node->iterate_referring(i, ref); i++)
675 bool speculative = ref->speculative;
676 unsigned int stmt_uid = ref->lto_stmt_uid;
678 ref2 = ref->referring->create_reference (this, ref->use, ref->stmt);
679 ref2->speculative = speculative;
680 ref2->lto_stmt_uid = stmt_uid;
684 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
686 ipa_ref *
687 symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
689 bool speculative = ref->speculative;
690 unsigned int stmt_uid = ref->lto_stmt_uid;
691 ipa_ref *ref2;
693 ref2 = create_reference (ref->referred, ref->use, stmt);
694 ref2->speculative = speculative;
695 ref2->lto_stmt_uid = stmt_uid;
696 return ref2;
699 /* Find the structure describing a reference to REFERRED_NODE
700 and associated with statement STMT. */
702 ipa_ref *
703 symtab_node::find_reference (symtab_node *referred_node,
704 gimple *stmt, unsigned int lto_stmt_uid)
706 ipa_ref *r = NULL;
707 int i;
709 for (i = 0; iterate_reference (i, r); i++)
710 if (r->referred == referred_node
711 && !r->speculative
712 && ((stmt && r->stmt == stmt)
713 || (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid)
714 || (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid)))
715 return r;
716 return NULL;
719 /* Remove all references that are associated with statement STMT. */
721 void
722 symtab_node::remove_stmt_references (gimple *stmt)
724 ipa_ref *r = NULL;
725 int i = 0;
727 while (iterate_reference (i, r))
728 if (r->stmt == stmt)
729 r->remove_reference ();
730 else
731 i++;
734 /* Remove all stmt references in non-speculative references.
735 Those are not maintained during inlining & clonning.
736 The exception are speculative references that are updated along
737 with callgraph edges associated with them. */
739 void
740 symtab_node::clear_stmts_in_references (void)
742 ipa_ref *r = NULL;
743 int i;
745 for (i = 0; iterate_reference (i, r); i++)
746 if (!r->speculative)
748 r->stmt = NULL;
749 r->lto_stmt_uid = 0;
753 /* Remove all references in ref list. */
755 void
756 symtab_node::remove_all_references (void)
758 while (vec_safe_length (ref_list.references))
759 ref_list.references->last ().remove_reference ();
760 vec_free (ref_list.references);
763 /* Remove all referring items in ref list. */
765 void
766 symtab_node::remove_all_referring (void)
768 while (ref_list.referring.length ())
769 ref_list.referring.last ()->remove_reference ();
770 ref_list.referring.release ();
773 /* Dump references in ref list to FILE. */
775 void
776 symtab_node::dump_references (FILE *file)
778 ipa_ref *ref = NULL;
779 int i;
780 for (i = 0; iterate_reference (i, ref); i++)
782 fprintf (file, "%s (%s)",
783 ref->referred->dump_asm_name (),
784 ipa_ref_use_name [ref->use]);
785 if (ref->speculative)
786 fprintf (file, " (speculative)");
788 fprintf (file, "\n");
791 /* Dump referring in list to FILE. */
793 void
794 symtab_node::dump_referring (FILE *file)
796 ipa_ref *ref = NULL;
797 int i;
798 for (i = 0; iterate_referring(i, ref); i++)
800 fprintf (file, "%s (%s)",
801 ref->referring->dump_asm_name (),
802 ipa_ref_use_name [ref->use]);
803 if (ref->speculative)
804 fprintf (file, " (speculative)");
806 fprintf (file, "\n");
809 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
811 /* Dump base fields of symtab nodes to F. Not to be used directly. */
813 void
814 symtab_node::dump_base (FILE *f)
816 static const char * const visibility_types[] = {
817 "default", "protected", "hidden", "internal"
820 fprintf (f, "%s (%s)", dump_asm_name (), name ());
821 dump_addr (f, " @", (void *)this);
822 fprintf (f, "\n Type: %s", symtab_type_names[type]);
824 if (definition)
825 fprintf (f, " definition");
826 if (analyzed)
827 fprintf (f, " analyzed");
828 if (alias)
829 fprintf (f, " alias");
830 if (transparent_alias)
831 fprintf (f, " transparent_alias");
832 if (weakref)
833 fprintf (f, " weakref");
834 if (cpp_implicit_alias)
835 fprintf (f, " cpp_implicit_alias");
836 if (alias_target)
837 fprintf (f, " target:%s",
838 DECL_P (alias_target)
839 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
840 (alias_target))
841 : IDENTIFIER_POINTER (alias_target));
842 if (body_removed)
843 fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes");
844 fprintf (f, "\n Visibility:");
845 if (in_other_partition)
846 fprintf (f, " in_other_partition");
847 if (used_from_other_partition)
848 fprintf (f, " used_from_other_partition");
849 if (force_output)
850 fprintf (f, " force_output");
851 if (forced_by_abi)
852 fprintf (f, " forced_by_abi");
853 if (externally_visible)
854 fprintf (f, " externally_visible");
855 if (no_reorder)
856 fprintf (f, " no_reorder");
857 if (resolution != LDPR_UNKNOWN)
858 fprintf (f, " %s",
859 ld_plugin_symbol_resolution_names[(int)resolution]);
860 if (TREE_ASM_WRITTEN (decl))
861 fprintf (f, " asm_written");
862 if (DECL_EXTERNAL (decl))
863 fprintf (f, " external");
864 if (TREE_PUBLIC (decl))
865 fprintf (f, " public");
866 if (DECL_COMMON (decl))
867 fprintf (f, " common");
868 if (DECL_WEAK (decl))
869 fprintf (f, " weak");
870 if (DECL_DLLIMPORT_P (decl))
871 fprintf (f, " dll_import");
872 if (DECL_COMDAT (decl))
873 fprintf (f, " comdat");
874 if (get_comdat_group ())
875 fprintf (f, " comdat_group:%s",
876 IDENTIFIER_POINTER (get_comdat_group_id ()));
877 if (DECL_ONE_ONLY (decl))
878 fprintf (f, " one_only");
879 if (get_section ())
880 fprintf (f, " section:%s",
881 get_section ());
882 if (implicit_section)
883 fprintf (f," (implicit_section)");
884 if (DECL_VISIBILITY_SPECIFIED (decl))
885 fprintf (f, " visibility_specified");
886 if (DECL_VISIBILITY (decl))
887 fprintf (f, " visibility:%s",
888 visibility_types [DECL_VISIBILITY (decl)]);
889 if (DECL_VIRTUAL_P (decl))
890 fprintf (f, " virtual");
891 if (DECL_ARTIFICIAL (decl))
892 fprintf (f, " artificial");
893 if (TREE_CODE (decl) == FUNCTION_DECL)
895 if (DECL_STATIC_CONSTRUCTOR (decl))
896 fprintf (f, " constructor");
897 if (DECL_STATIC_DESTRUCTOR (decl))
898 fprintf (f, " destructor");
900 fprintf (f, "\n");
902 if (same_comdat_group)
903 fprintf (f, " Same comdat group as: %s\n",
904 same_comdat_group->dump_asm_name ());
905 if (next_sharing_asm_name)
906 fprintf (f, " next sharing asm name: %i\n",
907 next_sharing_asm_name->order);
908 if (previous_sharing_asm_name)
909 fprintf (f, " previous sharing asm name: %i\n",
910 previous_sharing_asm_name->order);
912 if (address_taken)
913 fprintf (f, " Address is taken.\n");
914 if (aux)
916 fprintf (f, " Aux:");
917 dump_addr (f, " @", (void *)aux);
918 fprintf (f, "\n");
921 fprintf (f, " References: ");
922 dump_references (f);
923 fprintf (f, " Referring: ");
924 dump_referring (f);
925 if (lto_file_data)
926 fprintf (f, " Read from file: %s\n",
927 lto_file_data->file_name);
930 /* Dump symtab node to F. */
932 void
933 symtab_node::dump (FILE *f)
935 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
936 cnode->dump (f);
937 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
938 vnode->dump (f);
941 void
942 symbol_table::dump (FILE *f)
944 symtab_node *node;
945 fprintf (f, "Symbol table:\n\n");
946 FOR_EACH_SYMBOL (node)
947 node->dump (f);
950 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
951 Return NULL if there's no such node. */
953 symtab_node *
954 symtab_node::get_for_asmname (const_tree asmname)
956 symtab_node *node;
958 symtab->symtab_initialize_asm_name_hash ();
959 hashval_t hash = symtab->decl_assembler_name_hash (asmname);
960 symtab_node **slot
961 = symtab->assembler_name_hash->find_slot_with_hash (asmname, hash,
962 NO_INSERT);
964 if (slot)
966 node = *slot;
967 return node;
969 return NULL;
972 /* Dump symtab node NODE to stderr. */
974 DEBUG_FUNCTION void
975 symtab_node::debug (void)
977 dump (stderr);
980 /* Verify common part of symtab nodes. */
982 DEBUG_FUNCTION bool
983 symtab_node::verify_base (void)
985 bool error_found = false;
986 symtab_node *hashed_node;
988 if (is_a <cgraph_node *> (this))
990 if (TREE_CODE (decl) != FUNCTION_DECL)
992 error ("function symbol is not function");
993 error_found = true;
996 else if (is_a <varpool_node *> (this))
998 if (!VAR_P (decl))
1000 error ("variable symbol is not variable");
1001 error_found = true;
1004 else
1006 error ("node has unknown type");
1007 error_found = true;
1010 if (symtab->state != LTO_STREAMING)
1012 hashed_node = symtab_node::get (decl);
1013 if (!hashed_node)
1015 error ("node not found node->decl->decl_with_vis.symtab_node");
1016 error_found = true;
1018 if (hashed_node != this
1019 && (!is_a <cgraph_node *> (this)
1020 || !dyn_cast <cgraph_node *> (this)->clone_of
1021 || dyn_cast <cgraph_node *> (this)->clone_of->decl != decl))
1023 error ("node differs from node->decl->decl_with_vis.symtab_node");
1024 error_found = true;
1027 if (symtab->assembler_name_hash)
1029 hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
1030 if (hashed_node && hashed_node->previous_sharing_asm_name)
1032 error ("assembler name hash list corrupted");
1033 error_found = true;
1035 while (hashed_node)
1037 if (hashed_node == this)
1038 break;
1039 hashed_node = hashed_node->next_sharing_asm_name;
1041 if (!hashed_node
1042 && !(is_a <varpool_node *> (this)
1043 && DECL_HARD_REGISTER (decl)))
1045 error ("node not found in symtab assembler name hash");
1046 error_found = true;
1049 if (previous_sharing_asm_name
1050 && previous_sharing_asm_name->next_sharing_asm_name != this)
1052 error ("double linked list of assembler names corrupted");
1053 error_found = true;
1055 if (body_removed && definition)
1057 error ("node has body_removed but is definition");
1058 error_found = true;
1060 if (analyzed && !definition)
1062 error ("node is analyzed but it is not a definition");
1063 error_found = true;
1065 if (cpp_implicit_alias && !alias)
1067 error ("node is alias but not implicit alias");
1068 error_found = true;
1070 if (alias && !definition && !weakref)
1072 error ("node is alias but not definition");
1073 error_found = true;
1075 if (weakref && !transparent_alias)
1077 error ("node is weakref but not an transparent_alias");
1078 error_found = true;
1080 if (transparent_alias && !alias)
1082 error ("node is transparent_alias but not an alias");
1083 error_found = true;
1085 if (same_comdat_group)
1087 symtab_node *n = same_comdat_group;
1089 if (!n->get_comdat_group ())
1091 error ("node is in same_comdat_group list but has no comdat_group");
1092 error_found = true;
1094 if (n->get_comdat_group () != get_comdat_group ())
1096 error ("same_comdat_group list across different groups");
1097 error_found = true;
1099 if (n->type != type)
1101 error ("mixing different types of symbol in same comdat groups is not supported");
1102 error_found = true;
1104 if (n == this)
1106 error ("node is alone in a comdat group");
1107 error_found = true;
1111 if (!n->same_comdat_group)
1113 error ("same_comdat_group is not a circular list");
1114 error_found = true;
1115 break;
1117 n = n->same_comdat_group;
1119 while (n != this);
1120 if (comdat_local_p ())
1122 ipa_ref *ref = NULL;
1124 for (int i = 0; iterate_referring (i, ref); ++i)
1126 if (!in_same_comdat_group_p (ref->referring))
1128 error ("comdat-local symbol referred to by %s outside its "
1129 "comdat",
1130 identifier_to_locale (ref->referring->name()));
1131 error_found = true;
1136 if (implicit_section && !get_section ())
1138 error ("implicit_section flag is set but section isn't");
1139 error_found = true;
1141 if (get_section () && get_comdat_group ()
1142 && !implicit_section
1143 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl)))
1145 error ("Both section and comdat group is set");
1146 error_found = true;
1148 /* TODO: Add string table for sections, so we do not keep holding duplicated
1149 strings. */
1150 if (alias && definition
1151 && get_section () != get_alias_target ()->get_section ()
1152 && (!get_section()
1153 || !get_alias_target ()->get_section ()
1154 || strcmp (get_section(),
1155 get_alias_target ()->get_section ())))
1157 error ("Alias and target's section differs");
1158 get_alias_target ()->dump (stderr);
1159 error_found = true;
1161 if (alias && definition
1162 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1164 error ("Alias and target's comdat groups differs");
1165 get_alias_target ()->dump (stderr);
1166 error_found = true;
1168 if (transparent_alias && definition && !weakref)
1170 symtab_node *to = get_alias_target ();
1171 const char *name1
1172 = IDENTIFIER_POINTER (
1173 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
1174 const char *name2
1175 = IDENTIFIER_POINTER (
1176 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
1177 if (!symbol_table::assembler_names_equal_p (name1, name2))
1179 error ("Transparent alias and target's assembler names differs");
1180 get_alias_target ()->dump (stderr);
1181 error_found = true;
1184 if (transparent_alias && definition
1185 && get_alias_target()->transparent_alias && get_alias_target()->analyzed)
1187 error ("Chained transparent aliases");
1188 get_alias_target ()->dump (stderr);
1189 error_found = true;
1192 return error_found;
1195 /* Verify consistency of NODE. */
1197 DEBUG_FUNCTION void
1198 symtab_node::verify (void)
1200 if (seen_error ())
1201 return;
1203 timevar_push (TV_CGRAPH_VERIFY);
1204 if (cgraph_node *node = dyn_cast <cgraph_node *> (this))
1205 node->verify_node ();
1206 else
1207 if (verify_base ())
1209 debug ();
1210 internal_error ("symtab_node::verify failed");
1212 timevar_pop (TV_CGRAPH_VERIFY);
1215 /* Verify symbol table for internal consistency. */
1217 DEBUG_FUNCTION void
1218 symtab_node::verify_symtab_nodes (void)
1220 symtab_node *node;
1221 hash_map<tree, symtab_node *> comdat_head_map (251);
1223 FOR_EACH_SYMBOL (node)
1225 node->verify ();
1226 if (node->get_comdat_group ())
1228 symtab_node **entry, *s;
1229 bool existed;
1231 entry = &comdat_head_map.get_or_insert (node->get_comdat_group (),
1232 &existed);
1233 if (!existed)
1234 *entry = node;
1235 else if (!DECL_EXTERNAL (node->decl))
1237 for (s = (*entry)->same_comdat_group;
1238 s != NULL && s != node && s != *entry;
1239 s = s->same_comdat_group)
1241 if (!s || s == *entry)
1243 error ("Two symbols with same comdat_group are not linked by "
1244 "the same_comdat_group list.");
1245 (*entry)->debug ();
1246 node->debug ();
1247 internal_error ("symtab_node::verify failed");
1254 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1255 but other code such as notice_global_symbol generates rtl. */
1257 void
1258 symtab_node::make_decl_local (void)
1260 rtx rtl, symbol;
1262 if (weakref)
1264 weakref = false;
1265 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
1266 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
1267 symtab->change_decl_assembler_name
1268 (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
1269 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
1270 DECL_ATTRIBUTES (decl));
1272 /* Avoid clearing comdat_groups on comdat-local decls. */
1273 else if (TREE_PUBLIC (decl) == 0)
1274 return;
1276 /* Localizing a symbol also make all its transparent aliases local. */
1277 ipa_ref *ref;
1278 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1280 struct symtab_node *alias = ref->referring;
1281 if (alias->transparent_alias)
1282 alias->make_decl_local ();
1285 if (VAR_P (decl))
1287 DECL_COMMON (decl) = 0;
1288 /* ADDRESSABLE flag is not defined for public symbols. */
1289 TREE_ADDRESSABLE (decl) = 1;
1290 TREE_STATIC (decl) = 1;
1292 else
1293 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1295 DECL_COMDAT (decl) = 0;
1296 DECL_WEAK (decl) = 0;
1297 DECL_EXTERNAL (decl) = 0;
1298 DECL_VISIBILITY_SPECIFIED (decl) = 0;
1299 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
1300 TREE_PUBLIC (decl) = 0;
1301 DECL_DLLIMPORT_P (decl) = 0;
1302 if (!DECL_RTL_SET_P (decl))
1303 return;
1305 /* Update rtl flags. */
1306 make_decl_rtl (decl);
1308 rtl = DECL_RTL (decl);
1309 if (!MEM_P (rtl))
1310 return;
1312 symbol = XEXP (rtl, 0);
1313 if (GET_CODE (symbol) != SYMBOL_REF)
1314 return;
1316 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1319 /* Copy visibility from N.
1320 This is useful when THIS becomes a transparent alias of N. */
1322 void
1323 symtab_node::copy_visibility_from (symtab_node *n)
1325 gcc_checking_assert (n->weakref == weakref);
1327 ipa_ref *ref;
1328 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
1330 struct symtab_node *alias = ref->referring;
1331 if (alias->transparent_alias)
1332 alias->copy_visibility_from (n);
1335 if (VAR_P (decl))
1337 DECL_COMMON (decl) = DECL_COMMON (n->decl);
1338 /* ADDRESSABLE flag is not defined for public symbols. */
1339 if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
1340 TREE_ADDRESSABLE (decl) = 1;
1341 TREE_STATIC (decl) = TREE_STATIC (n->decl);
1343 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1345 DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
1346 DECL_WEAK (decl) = DECL_WEAK (n->decl);
1347 DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
1348 DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
1349 DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
1350 TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
1351 DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
1352 resolution = n->resolution;
1353 set_comdat_group (n->get_comdat_group ());
1354 call_for_symbol_and_aliases (symtab_node::set_section,
1355 const_cast<char *>(n->get_section ()), true);
1356 externally_visible = n->externally_visible;
1357 if (!DECL_RTL_SET_P (decl))
1358 return;
1360 /* Update rtl flags. */
1361 make_decl_rtl (decl);
1363 rtx rtl = DECL_RTL (decl);
1364 if (!MEM_P (rtl))
1365 return;
1367 rtx symbol = XEXP (rtl, 0);
1368 if (GET_CODE (symbol) != SYMBOL_REF)
1369 return;
1371 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
1374 /* Walk the alias chain to return the symbol NODE is alias of.
1375 If NODE is not an alias, return NODE.
1376 Assumes NODE is known to be alias. */
1378 symtab_node *
1379 symtab_node::ultimate_alias_target_1 (enum availability *availability,
1380 symtab_node *ref)
1382 bool transparent_p = false;
1384 /* To determine visibility of the target, we follow ELF semantic of aliases.
1385 Here alias is an alternative assembler name of a given definition. Its
1386 availability prevails the availability of its target (i.e. static alias of
1387 weak definition is available.
1389 Transaparent alias is just alternative anme of a given symbol used within
1390 one compilation unit and is translated prior hitting the object file. It
1391 inherits the visibility of its target.
1392 Weakref is a different animal (and noweak definition is weak).
1394 If we ever get into supporting targets with different semantics, a target
1395 hook will be needed here. */
1397 if (availability)
1399 transparent_p = transparent_alias;
1400 if (!transparent_p)
1401 *availability = get_availability (ref);
1402 else
1403 *availability = AVAIL_NOT_AVAILABLE;
1406 symtab_node *node = this;
1407 while (node)
1409 if (node->alias && node->analyzed)
1410 node = node->get_alias_target ();
1411 else
1413 if (!availability || (!transparent_p && node->analyzed))
1415 else if (node->analyzed && !node->transparent_alias)
1416 *availability = node->get_availability (ref);
1417 else
1418 *availability = AVAIL_NOT_AVAILABLE;
1419 return node;
1421 if (node && availability && transparent_p
1422 && node->transparent_alias)
1424 *availability = node->get_availability (ref);
1425 transparent_p = false;
1428 if (availability)
1429 *availability = AVAIL_NOT_AVAILABLE;
1430 return NULL;
1433 /* C++ FE sometimes change linkage flags after producing same body aliases.
1435 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1436 are obviously equivalent. The way it is doing so is however somewhat
1437 kludgy and interferes with the visibility code. As a result we need to
1438 copy the visibility from the target to get things right. */
1440 void
1441 symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
1443 if (is_a <cgraph_node *> (this))
1445 DECL_DECLARED_INLINE_P (decl)
1446 = DECL_DECLARED_INLINE_P (target->decl);
1447 DECL_DISREGARD_INLINE_LIMITS (decl)
1448 = DECL_DISREGARD_INLINE_LIMITS (target->decl);
1450 /* FIXME: It is not really clear why those flags should not be copied for
1451 functions, too. */
1452 else
1454 DECL_WEAK (decl) = DECL_WEAK (target->decl);
1455 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1456 DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
1458 if (TREE_PUBLIC (decl))
1460 tree group;
1462 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
1463 DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
1464 group = target->get_comdat_group ();
1465 set_comdat_group (group);
1466 if (group && !same_comdat_group)
1467 add_to_same_comdat_group (target);
1469 externally_visible = target->externally_visible;
1472 /* Set section, do not recurse into aliases.
1473 When one wants to change section of a symbol and its aliases,
1474 use set_section. */
1476 void
1477 symtab_node::set_section_for_node (const char *section)
1479 const char *current = get_section ();
1480 section_hash_entry **slot;
1482 if (current == section
1483 || (current && section
1484 && !strcmp (current, section)))
1485 return;
1487 if (current)
1489 x_section->ref_count--;
1490 if (!x_section->ref_count)
1492 hashval_t hash = htab_hash_string (x_section->name);
1493 slot = symtab->section_hash->find_slot_with_hash (x_section->name,
1494 hash, INSERT);
1495 ggc_free (x_section);
1496 symtab->section_hash->clear_slot (slot);
1498 x_section = NULL;
1500 if (!section)
1502 implicit_section = false;
1503 return;
1505 if (!symtab->section_hash)
1506 symtab->section_hash = hash_table<section_name_hasher>::create_ggc (10);
1507 slot = symtab->section_hash->find_slot_with_hash (section,
1508 htab_hash_string (section),
1509 INSERT);
1510 if (*slot)
1511 x_section = (section_hash_entry *)*slot;
1512 else
1514 int len = strlen (section);
1515 *slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
1516 x_section->name = ggc_vec_alloc<char> (len + 1);
1517 memcpy (x_section->name, section, len + 1);
1519 x_section->ref_count++;
1522 /* Worker for set_section. */
1524 bool
1525 symtab_node::set_section (symtab_node *n, void *s)
1527 n->set_section_for_node ((char *)s);
1528 return false;
1531 /* Set section of symbol and its aliases. */
1533 void
1534 symtab_node::set_section (const char *section)
1536 gcc_assert (!this->alias);
1537 call_for_symbol_and_aliases
1538 (symtab_node::set_section, const_cast<char *>(section), true);
1541 /* Return the initialization priority. */
1543 priority_type
1544 symtab_node::get_init_priority ()
1546 if (!this->in_init_priority_hash)
1547 return DEFAULT_INIT_PRIORITY;
1549 symbol_priority_map *h = symtab->init_priority_hash->get (this);
1550 return h ? h->init : DEFAULT_INIT_PRIORITY;
1553 /* Return the finalization priority. */
1555 priority_type
1556 cgraph_node::get_fini_priority ()
1558 if (!this->in_init_priority_hash)
1559 return DEFAULT_INIT_PRIORITY;
1560 symbol_priority_map *h = symtab->init_priority_hash->get (this);
1561 return h ? h->fini : DEFAULT_INIT_PRIORITY;
1564 /* Return the initialization and finalization priority information for
1565 DECL. If there is no previous priority information, a freshly
1566 allocated structure is returned. */
1568 symbol_priority_map *
1569 symtab_node::priority_info (void)
1571 if (!symtab->init_priority_hash)
1572 symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (13);
1574 bool existed;
1575 symbol_priority_map *h
1576 = &symtab->init_priority_hash->get_or_insert (this, &existed);
1577 if (!existed)
1579 h->init = DEFAULT_INIT_PRIORITY;
1580 h->fini = DEFAULT_INIT_PRIORITY;
1581 in_init_priority_hash = true;
1584 return h;
1587 /* Set initialization priority to PRIORITY. */
1589 void
1590 symtab_node::set_init_priority (priority_type priority)
1592 symbol_priority_map *h;
1594 if (is_a <cgraph_node *> (this))
1595 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
1597 if (priority == DEFAULT_INIT_PRIORITY)
1599 gcc_assert (get_init_priority() == priority);
1600 return;
1602 h = priority_info ();
1603 h->init = priority;
1606 /* Set fialization priority to PRIORITY. */
1608 void
1609 cgraph_node::set_fini_priority (priority_type priority)
1611 symbol_priority_map *h;
1613 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
1615 if (priority == DEFAULT_INIT_PRIORITY)
1617 gcc_assert (get_fini_priority() == priority);
1618 return;
1620 h = priority_info ();
1621 h->fini = priority;
1624 /* Worker for symtab_resolve_alias. */
1626 bool
1627 symtab_node::set_implicit_section (symtab_node *n,
1628 void *data ATTRIBUTE_UNUSED)
1630 n->implicit_section = true;
1631 return false;
1634 /* Add reference recording that symtab node is alias of TARGET.
1635 The function can fail in the case of aliasing cycles; in this case
1636 it returns false. */
1638 bool
1639 symtab_node::resolve_alias (symtab_node *target, bool transparent)
1641 symtab_node *n;
1643 gcc_assert (!analyzed && !vec_safe_length (ref_list.references));
1645 /* Never let cycles to creep into the symbol table alias references;
1646 those will make alias walkers to be infinite. */
1647 for (n = target; n && n->alias;
1648 n = n->analyzed ? n->get_alias_target () : NULL)
1649 if (n == this)
1651 if (is_a <cgraph_node *> (this))
1652 error ("function %q+D part of alias cycle", decl);
1653 else if (is_a <varpool_node *> (this))
1654 error ("variable %q+D part of alias cycle", decl);
1655 else
1656 gcc_unreachable ();
1657 alias = false;
1658 return false;
1661 /* "analyze" the node - i.e. mark the reference. */
1662 definition = true;
1663 alias = true;
1664 analyzed = true;
1665 transparent |= transparent_alias;
1666 transparent_alias = transparent;
1667 if (transparent)
1668 while (target->transparent_alias && target->analyzed)
1669 target = target->get_alias_target ();
1670 create_reference (target, IPA_REF_ALIAS, NULL);
1672 /* Add alias into the comdat group of its target unless it is already there. */
1673 if (same_comdat_group)
1674 remove_from_same_comdat_group ();
1675 set_comdat_group (NULL);
1676 if (target->get_comdat_group ())
1677 add_to_same_comdat_group (target);
1679 if ((get_section () != target->get_section ()
1680 || target->get_comdat_group ()) && get_section () && !implicit_section)
1682 error ("section of alias %q+D must match section of its target", decl);
1684 call_for_symbol_and_aliases (symtab_node::set_section,
1685 const_cast<char *>(target->get_section ()), true);
1686 if (target->implicit_section)
1687 call_for_symbol_and_aliases (set_implicit_section, NULL, true);
1689 /* Alias targets become redundant after alias is resolved into an reference.
1690 We do not want to keep it around or we would have to mind updating them
1691 when renaming symbols. */
1692 alias_target = NULL;
1694 if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
1695 fixup_same_cpp_alias_visibility (target);
1697 /* If alias has address taken, so does the target. */
1698 if (address_taken)
1699 target->ultimate_alias_target ()->address_taken = true;
1701 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1702 If alias is transparent, also all transparent aliases of THIS are now
1703 aliases of TARGET.
1704 Also merge same comdat group lists. */
1705 ipa_ref *ref;
1706 for (unsigned i = 0; iterate_direct_aliases (i, ref);)
1708 struct symtab_node *alias_alias = ref->referring;
1709 if (alias_alias->get_comdat_group ())
1711 alias_alias->remove_from_same_comdat_group ();
1712 alias_alias->set_comdat_group (NULL);
1713 if (target->get_comdat_group ())
1714 alias_alias->add_to_same_comdat_group (target);
1716 if (!alias_alias->transparent_alias || transparent)
1718 alias_alias->remove_all_references ();
1719 alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
1721 else i++;
1723 return true;
1726 /* Worker searching noninterposable alias. */
1728 bool
1729 symtab_node::noninterposable_alias (symtab_node *node, void *data)
1731 if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
1733 symtab_node *fn = node->ultimate_alias_target ();
1735 /* Ensure that the alias is well formed this may not be the case
1736 of user defined aliases and currently it is not always the case
1737 of C++ same body aliases (that is a bug). */
1738 if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
1739 || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
1740 || (TREE_CODE (node->decl) == FUNCTION_DECL
1741 && flags_from_decl_or_type (node->decl)
1742 != flags_from_decl_or_type (fn->decl))
1743 || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
1744 return false;
1745 *(symtab_node **)data = node;
1746 return true;
1748 return false;
1751 /* If node can not be overwriten by static or dynamic linker to point to
1752 different definition, return NODE. Otherwise look for alias with such
1753 property and if none exists, introduce new one. */
1755 symtab_node *
1756 symtab_node::noninterposable_alias (void)
1758 tree new_decl;
1759 symtab_node *new_node = NULL;
1761 /* First try to look up existing alias or base object
1762 (if that is already non-overwritable). */
1763 symtab_node *node = ultimate_alias_target ();
1764 gcc_assert (!node->alias && !node->weakref);
1765 node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias,
1766 (void *)&new_node, true);
1767 if (new_node)
1768 return new_node;
1770 /* If aliases aren't supported by the assembler, fail. */
1771 if (!TARGET_SUPPORTS_ALIASES)
1772 return NULL;
1774 /* Otherwise create a new one. */
1775 new_decl = copy_node (node->decl);
1776 DECL_DLLIMPORT_P (new_decl) = 0;
1777 DECL_NAME (new_decl) = clone_function_name (node->decl, "localalias");
1778 if (TREE_CODE (new_decl) == FUNCTION_DECL)
1779 DECL_STRUCT_FUNCTION (new_decl) = NULL;
1780 DECL_INITIAL (new_decl) = NULL;
1781 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1782 SET_DECL_RTL (new_decl, NULL);
1784 /* Update the properties. */
1785 DECL_EXTERNAL (new_decl) = 0;
1786 TREE_PUBLIC (new_decl) = 0;
1787 DECL_COMDAT (new_decl) = 0;
1788 DECL_WEAK (new_decl) = 0;
1790 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1791 DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
1792 if (TREE_CODE (new_decl) == FUNCTION_DECL)
1794 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
1795 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
1796 new_node = cgraph_node::create_alias (new_decl, node->decl);
1798 else
1800 TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
1801 DECL_INITIAL (new_decl) = error_mark_node;
1802 new_node = varpool_node::create_alias (new_decl, node->decl);
1804 new_node->resolve_alias (node);
1805 gcc_assert (decl_binds_to_current_def_p (new_decl)
1806 && targetm.binds_local_p (new_decl));
1807 return new_node;
1810 /* Return true if symtab node and TARGET represents
1811 semantically equivalent symbols. */
1813 bool
1814 symtab_node::semantically_equivalent_p (symtab_node *target)
1816 enum availability avail;
1817 symtab_node *ba;
1818 symtab_node *bb;
1820 /* Equivalent functions are equivalent. */
1821 if (decl == target->decl)
1822 return true;
1824 /* If symbol is not overwritable by different implementation,
1825 walk to the base object it defines. */
1826 ba = ultimate_alias_target (&avail);
1827 if (avail >= AVAIL_AVAILABLE)
1829 if (target == ba)
1830 return true;
1832 else
1833 ba = this;
1834 bb = target->ultimate_alias_target (&avail);
1835 if (avail >= AVAIL_AVAILABLE)
1837 if (this == bb)
1838 return true;
1840 else
1841 bb = target;
1842 return bb == ba;
1845 /* Classify symbol symtab node for partitioning. */
1847 enum symbol_partitioning_class
1848 symtab_node::get_partitioning_class (void)
1850 /* Inline clones are always duplicated.
1851 This include external delcarations. */
1852 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
1854 if (DECL_ABSTRACT_P (decl))
1855 return SYMBOL_EXTERNAL;
1857 if (cnode && cnode->global.inlined_to)
1858 return SYMBOL_DUPLICATE;
1860 /* Transparent aliases are always duplicated. */
1861 if (transparent_alias)
1862 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
1864 /* External declarations are external. */
1865 if (DECL_EXTERNAL (decl))
1866 return SYMBOL_EXTERNAL;
1868 if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
1870 if (alias && definition && !ultimate_alias_target ()->definition)
1871 return SYMBOL_EXTERNAL;
1872 /* Constant pool references use local symbol names that can not
1873 be promoted global. We should never put into a constant pool
1874 objects that can not be duplicated across partitions. */
1875 if (DECL_IN_CONSTANT_POOL (decl))
1876 return SYMBOL_DUPLICATE;
1877 if (DECL_HARD_REGISTER (decl))
1878 return SYMBOL_DUPLICATE;
1879 gcc_checking_assert (vnode->definition);
1881 /* Functions that are cloned may stay in callgraph even if they are unused.
1882 Handle them as external; compute_ltrans_boundary take care to make
1883 proper things to happen (i.e. to make them appear in the boundary but
1884 with body streamed, so clone can me materialized). */
1885 else if (!dyn_cast <cgraph_node *> (this)->function_symbol ()->definition)
1886 return SYMBOL_EXTERNAL;
1888 /* Linker discardable symbols are duplicated to every use unless they are
1889 keyed. */
1890 if (DECL_ONE_ONLY (decl)
1891 && !force_output
1892 && !forced_by_abi
1893 && !used_from_object_file_p ())
1894 return SYMBOL_DUPLICATE;
1896 return SYMBOL_PARTITION;
1899 /* Return true when symbol is known to be non-zero. */
1901 bool
1902 symtab_node::nonzero_address ()
1904 /* Weakrefs may be NULL when their target is not defined. */
1905 if (alias && weakref)
1907 if (analyzed)
1909 symtab_node *target = ultimate_alias_target ();
1911 if (target->alias && target->weakref)
1912 return false;
1913 /* We can not recurse to target::nonzero. It is possible that the
1914 target is used only via the alias.
1915 We may walk references and look for strong use, but we do not know
1916 if this strong use will survive to final binary, so be
1917 conservative here.
1918 ??? Maybe we could do the lookup during late optimization that
1919 could be useful to eliminate the NULL pointer checks in LTO
1920 programs. */
1921 if (target->definition && !DECL_EXTERNAL (target->decl))
1922 return true;
1923 if (target->resolution != LDPR_UNKNOWN
1924 && target->resolution != LDPR_UNDEF
1925 && !target->can_be_discarded_p ()
1926 && flag_delete_null_pointer_checks)
1927 return true;
1928 return false;
1930 else
1931 return false;
1934 /* With !flag_delete_null_pointer_checks we assume that symbols may
1935 bind to NULL. This is on by default on embedded targets only.
1937 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
1938 linking fails. Important case of WEAK we want to do well are comdats.
1939 Those are handled by later check for definition.
1941 When parsing, beware the cases when WEAK attribute is added later. */
1942 if (!DECL_WEAK (decl)
1943 && flag_delete_null_pointer_checks)
1945 refuse_visibility_changes = true;
1946 return true;
1949 /* If target is defined and not extern, we know it will be output and thus
1950 it will bind to non-NULL.
1951 Play safe for flag_delete_null_pointer_checks where weak definition maye
1952 be re-defined by NULL. */
1953 if (definition && !DECL_EXTERNAL (decl)
1954 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
1956 if (!DECL_WEAK (decl))
1957 refuse_visibility_changes = true;
1958 return true;
1961 /* As the last resort, check the resolution info. */
1962 if (resolution != LDPR_UNKNOWN
1963 && resolution != LDPR_UNDEF
1964 && !can_be_discarded_p ()
1965 && flag_delete_null_pointer_checks)
1966 return true;
1967 return false;
1970 /* Return 0 if symbol is known to have different address than S2,
1971 Return 1 if symbol is known to have same address as S2,
1972 return -1 otherwise.
1974 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
1975 and S2 is going to be accessed. This eliminates the situations when
1976 either THIS or S2 is NULL and is seful for comparing bases when deciding
1977 about memory aliasing. */
1979 symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
1981 enum availability avail1, avail2;
1983 /* A Shortcut: equivalent symbols are always equivalent. */
1984 if (this == s2)
1985 return 1;
1987 /* Unwind transparent aliases first; those are always equal to their
1988 target. */
1989 if (this->transparent_alias && this->analyzed)
1990 return this->get_alias_target ()->equal_address_to (s2);
1991 while (s2->transparent_alias && s2->analyzed)
1992 s2 = s2->get_alias_target();
1994 if (this == s2)
1995 return 1;
1997 /* For non-interposable aliases, lookup and compare their actual definitions.
1998 Also check if the symbol needs to bind to given definition. */
1999 symtab_node *rs1 = ultimate_alias_target (&avail1);
2000 symtab_node *rs2 = s2->ultimate_alias_target (&avail2);
2001 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
2002 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
2003 bool really_binds_local1 = binds_local1;
2004 bool really_binds_local2 = binds_local2;
2006 /* Addresses of vtables and virtual functions can not be used by user
2007 code and are used only within speculation. In this case we may make
2008 symbol equivalent to its alias even if interposition may break this
2009 rule. Doing so will allow us to turn speculative inlining into
2010 non-speculative more agressively. */
2011 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
2012 binds_local1 = true;
2013 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
2014 binds_local2 = true;
2016 /* If both definitions are available we know that even if they are bound
2017 to other unit they must be defined same way and therefore we can use
2018 equivalence test. */
2019 if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
2020 binds_local1 = binds_local2 = true;
2022 if (binds_local1 && binds_local2 && rs1 == rs2)
2024 /* We made use of the fact that alias is not weak. */
2025 if (rs1 != this)
2026 refuse_visibility_changes = true;
2027 if (rs2 != s2)
2028 s2->refuse_visibility_changes = true;
2029 return 1;
2032 /* If both symbols may resolve to NULL, we can not really prove them
2033 different. */
2034 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
2035 return -1;
2037 /* Except for NULL, functions and variables never overlap. */
2038 if (TREE_CODE (decl) != TREE_CODE (s2->decl))
2039 return 0;
2041 /* If one of the symbols is unresolved alias, punt. */
2042 if (rs1->alias || rs2->alias)
2043 return -1;
2045 /* If we have a non-interposale definition of at least one of the symbols
2046 and the other symbol is different, we know other unit can not interpose
2047 it to the first symbol; all aliases of the definition needs to be
2048 present in the current unit. */
2049 if (((really_binds_local1 || really_binds_local2)
2050 /* If we have both definitions and they are different, we know they
2051 will be different even in units they binds to. */
2052 || (binds_local1 && binds_local2))
2053 && rs1 != rs2)
2055 /* We make use of the fact that one symbol is not alias of the other
2056 and that the definition is non-interposable. */
2057 refuse_visibility_changes = true;
2058 s2->refuse_visibility_changes = true;
2059 rs1->refuse_visibility_changes = true;
2060 rs2->refuse_visibility_changes = true;
2061 return 0;
2064 /* TODO: Alias oracle basically assume that addresses of global variables
2065 are different unless they are declared as alias of one to another while
2066 the code folding comparsions doesn't.
2067 We probably should be consistent and use this fact here, too, but for
2068 the moment return false only when we are called from the alias oracle. */
2070 return memory_accessed && rs1 != rs2 ? 0 : -1;
2073 /* Worker for call_for_symbol_and_aliases. */
2075 bool
2076 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
2077 void *),
2078 void *data,
2079 bool include_overwritable)
2081 ipa_ref *ref;
2082 FOR_EACH_ALIAS (this, ref)
2084 symtab_node *alias = ref->referring;
2085 if (include_overwritable
2086 || alias->get_availability () > AVAIL_INTERPOSABLE)
2087 if (alias->call_for_symbol_and_aliases (callback, data,
2088 include_overwritable))
2089 return true;
2091 return false;
2094 /* Return true if address of N is possibly compared. */
2096 static bool
2097 address_matters_1 (symtab_node *n, void *)
2099 struct ipa_ref *ref;
2101 if (!n->address_can_be_compared_p ())
2102 return false;
2103 if (n->externally_visible || n->force_output)
2104 return true;
2106 for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
2107 if (ref->address_matters_p ())
2108 return true;
2109 return false;
2112 /* Return true if symbol's address may possibly be compared to other
2113 symbol's address. */
2115 bool
2116 symtab_node::address_matters_p ()
2118 gcc_assert (!alias);
2119 return call_for_symbol_and_aliases (address_matters_1, NULL, true);
2122 /* Return true if symbol's alignment may be increased. */
2124 bool
2125 symtab_node::can_increase_alignment_p (void)
2127 symtab_node *target = ultimate_alias_target ();
2129 /* For now support only variables. */
2130 if (!VAR_P (decl))
2131 return false;
2133 /* With -fno-toplevel-reorder we may have already output the constant. */
2134 if (TREE_ASM_WRITTEN (target->decl))
2135 return false;
2137 /* If target is already placed in an anchor, we can not touch its
2138 alignment. */
2139 if (DECL_RTL_SET_P (target->decl)
2140 && MEM_P (DECL_RTL (target->decl))
2141 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
2142 return false;
2144 /* Constant pool entries may be shared. */
2145 if (DECL_IN_CONSTANT_POOL (target->decl))
2146 return false;
2148 /* We cannot change alignment of symbols that may bind to symbols
2149 in other translation unit that may contain a definition with lower
2150 alignment. */
2151 if (!decl_binds_to_current_def_p (decl))
2152 return false;
2154 /* When compiling partition, be sure the symbol is not output by other
2155 partition. */
2156 if (flag_ltrans
2157 && (target->in_other_partition
2158 || target->get_partitioning_class () == SYMBOL_DUPLICATE))
2159 return false;
2161 /* Do not override the alignment as specified by the ABI when the used
2162 attribute is set. */
2163 if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
2164 return false;
2166 /* Do not override explicit alignment set by the user when an explicit
2167 section name is also used. This is a common idiom used by many
2168 software projects. */
2169 if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
2170 return false;
2172 return true;
2175 /* Worker for symtab_node::increase_alignment. */
2177 static bool
2178 increase_alignment_1 (symtab_node *n, void *v)
2180 unsigned int align = (size_t)v;
2181 if (DECL_ALIGN (n->decl) < align
2182 && n->can_increase_alignment_p ())
2184 SET_DECL_ALIGN (n->decl, align);
2185 DECL_USER_ALIGN (n->decl) = 1;
2187 return false;
2190 /* Increase alignment of THIS to ALIGN. */
2192 void
2193 symtab_node::increase_alignment (unsigned int align)
2195 gcc_assert (can_increase_alignment_p () && align < MAX_OFILE_ALIGNMENT);
2196 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1,
2197 (void *)(size_t) align,
2198 true);
2199 gcc_assert (DECL_ALIGN (decl) >= align);
2202 /* Helper for symtab_node::definition_alignment. */
2204 static bool
2205 get_alignment_1 (symtab_node *n, void *v)
2207 *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
2208 return false;
2211 /* Return desired alignment of the definition. This is NOT alignment useful
2212 to access THIS, because THIS may be interposable and DECL_ALIGN should
2213 be used instead. It however must be guaranteed when output definition
2214 of THIS. */
2216 unsigned int
2217 symtab_node::definition_alignment ()
2219 unsigned int align = 0;
2220 gcc_assert (!alias);
2221 call_for_symbol_and_aliases (get_alignment_1, &align, true);
2222 return align;
2225 /* Return symbol used to separate symbol name from suffix. */
2227 char
2228 symbol_table::symbol_suffix_separator ()
2230 #ifndef NO_DOT_IN_LABEL
2231 return '.';
2232 #elif !defined NO_DOLLAR_IN_LABEL
2233 return '$';
2234 #else
2235 return '_';
2236 #endif
2239 /* Return true when references to this symbol from REF must bind to current
2240 definition in final executable. */
2242 bool
2243 symtab_node::binds_to_current_def_p (symtab_node *ref)
2245 if (!definition)
2246 return false;
2247 if (transparent_alias)
2248 return definition
2249 && get_alias_target()->binds_to_current_def_p (ref);
2250 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
2251 return false;
2252 if (decl_binds_to_current_def_p (decl))
2253 return true;
2255 /* Inline clones always binds locally. */
2256 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
2257 if (cnode && cnode->global.inlined_to)
2258 return true;
2260 if (DECL_EXTERNAL (decl))
2261 return false;
2263 gcc_assert (externally_visible);
2265 if (ref)
2267 cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
2268 if (cref)
2269 ref = cref->global.inlined_to;
2272 /* If this is a reference from symbol itself and there are no aliases, we
2273 may be sure that the symbol was not interposed by something else because
2274 the symbol itself would be unreachable otherwise. This is important
2275 to optimize recursive functions well.
2277 This assumption may be broken by inlining: if symbol is interposable
2278 but the body is available (i.e. declared inline), inliner may make
2279 the body reachable even with interposition. */
2280 if (this == ref && !has_aliases_p ()
2281 && (!cnode
2282 || symtab->state >= IPA_SSA_AFTER_INLINING
2283 || get_availability () >= AVAIL_INTERPOSABLE))
2284 return true;
2287 /* References within one comdat group are always bound in a group. */
2288 if (ref
2289 && symtab->state >= IPA_SSA_AFTER_INLINING
2290 && get_comdat_group ()
2291 && get_comdat_group () == ref->get_comdat_group ())
2292 return true;
2294 return false;
2297 /* Return true if symbol should be output to the symbol table. */
2299 bool
2300 symtab_node::output_to_lto_symbol_table_p (void)
2302 /* Only externally visible symbols matter. */
2303 if (!TREE_PUBLIC (decl))
2304 return false;
2305 if (!real_symbol_p ())
2306 return false;
2307 /* FIXME: variables probably should not be considered as real symbols at
2308 first place. */
2309 if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
2310 return false;
2311 /* FIXME: Builtins corresponding to real functions probably should have
2312 symbol table entries. */
2313 if (is_builtin_fn (decl))
2314 return false;
2316 /* We have real symbol that should be in symbol table. However try to trim
2317 down the refernces to libraries bit more because linker will otherwise
2318 bring unnecesary object files into the final link.
2319 FIXME: The following checks can easily be confused i.e. by self recursive
2320 function or self-referring variable. */
2322 /* We keep external functions in symtab for sake of inlining
2323 and devirtualization. We do not want to see them in symbol table as
2324 references unless they are really used. */
2325 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
2326 if (cnode && (!definition || DECL_EXTERNAL (decl))
2327 && cnode->callers)
2328 return true;
2330 /* Ignore all references from external vars initializers - they are not really
2331 part of the compilation unit until they are used by folding. Some symbols,
2332 like references to external construction vtables can not be referred to at
2333 all. We decide this at can_refer_decl_in_current_unit_p. */
2334 if (!definition || DECL_EXTERNAL (decl))
2336 int i;
2337 struct ipa_ref *ref;
2338 for (i = 0; iterate_referring (i, ref); i++)
2340 if (ref->use == IPA_REF_ALIAS)
2341 continue;
2342 if (is_a <cgraph_node *> (ref->referring))
2343 return true;
2344 if (!DECL_EXTERNAL (ref->referring->decl))
2345 return true;
2347 return false;
2349 return true;