2 Copyright (C) 2012-2022 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
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
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/>. */
23 #include "coretypes.h"
31 #include "lto-streamer.h"
32 #include "print-tree.h"
34 #include "langhooks.h"
36 #include "ipa-utils.h"
38 #include "stringpool.h"
41 #include "fold-const.h"
43 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias"};
45 const char * const ld_plugin_symbol_resolution_names
[]=
50 "prevailing_def_ironly",
56 "prevailing_def_ironly_exp"
59 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
60 until we find an identifier that is not itself a transparent alias. */
63 ultimate_transparent_alias_target (tree alias
)
67 while (IDENTIFIER_TRANSPARENT_ALIAS (target
))
69 gcc_checking_assert (TREE_CHAIN (target
));
70 target
= TREE_CHAIN (target
);
72 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
73 && ! TREE_CHAIN (target
));
79 /* Hash asmnames ignoring the user specified marks. */
82 symbol_table::decl_assembler_name_hash (const_tree asmname
)
84 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
86 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
87 size_t ulp_len
= strlen (user_label_prefix
);
91 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
94 return htab_hash_string (decl_str
);
97 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
100 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
104 symbol_table::assembler_names_equal_p (const char *name1
, const char *name2
)
110 size_t ulp_len
= strlen (user_label_prefix
);
116 else if (strncmp (name1
, user_label_prefix
, ulp_len
) == 0)
123 size_t ulp_len
= strlen (user_label_prefix
);
129 else if (strncmp (name2
, user_label_prefix
, ulp_len
) == 0)
134 return !strcmp (name1
, name2
);
139 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
142 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
144 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
145 const char *decl_str
;
146 const char *asmname_str
;
148 if (decl_asmname
== asmname
)
151 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
152 asmname_str
= IDENTIFIER_POINTER (asmname
);
153 return assembler_names_equal_p (decl_str
, asmname_str
);
157 /* Returns nonzero if P1 and P2 are equal. */
159 /* Insert NODE to assembler name hash. */
162 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
165 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
167 gcc_checking_assert (!node
->previous_sharing_asm_name
168 && !node
->next_sharing_asm_name
);
169 if (assembler_name_hash
)
173 tree decl
= node
->decl
;
175 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
177 /* C++ FE can produce decls without associated assembler name and insert
178 them to symtab to hold section or TLS information. */
182 hashval_t hash
= decl_assembler_name_hash (name
);
183 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
184 gcc_assert (*aslot
!= node
);
185 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
187 (*aslot
)->previous_sharing_asm_name
= node
;
190 /* Update also possible inline clones sharing a decl. */
191 cnode
= dyn_cast
<cgraph_node
*> (node
);
192 if (cnode
&& cnode
->clones
&& with_clones
)
193 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
194 if (cnode
->decl
== decl
)
195 insert_to_assembler_name_hash (cnode
, true);
200 /* Remove NODE from assembler name hash. */
203 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
206 if (assembler_name_hash
)
209 tree decl
= node
->decl
;
211 if (node
->next_sharing_asm_name
)
212 node
->next_sharing_asm_name
->previous_sharing_asm_name
213 = node
->previous_sharing_asm_name
;
214 if (node
->previous_sharing_asm_name
)
216 node
->previous_sharing_asm_name
->next_sharing_asm_name
217 = node
->next_sharing_asm_name
;
221 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
227 hashval_t hash
= decl_assembler_name_hash (name
);
228 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
230 gcc_assert (*slot
== node
);
231 if (!node
->next_sharing_asm_name
)
232 assembler_name_hash
->clear_slot (slot
);
234 *slot
= node
->next_sharing_asm_name
;
236 node
->next_sharing_asm_name
= NULL
;
237 node
->previous_sharing_asm_name
= NULL
;
239 /* Update also possible inline clones sharing a decl. */
240 cnode
= dyn_cast
<cgraph_node
*> (node
);
241 if (cnode
&& cnode
->clones
&& with_clones
)
242 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
243 if (cnode
->decl
== decl
)
244 unlink_from_assembler_name_hash (cnode
, true);
248 /* Arrange node to be first in its entry of assembler_name_hash. */
251 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
253 unlink_from_assembler_name_hash (node
, false);
254 insert_to_assembler_name_hash (node
, false);
257 /* Initialize asm name hash unless. */
260 symbol_table::symtab_initialize_asm_name_hash (void)
263 if (!assembler_name_hash
)
265 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
266 FOR_EACH_SYMBOL (node
)
267 insert_to_assembler_name_hash (node
, false);
271 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
274 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
276 symtab_node
*node
= NULL
;
278 /* We can have user ASM names on things, like global register variables, that
279 are not in the symbol table. */
280 if ((VAR_P (decl
) && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
281 || TREE_CODE (decl
) == FUNCTION_DECL
)
282 node
= symtab_node::get (decl
);
283 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
285 SET_DECL_ASSEMBLER_NAME (decl
, name
);
287 insert_to_assembler_name_hash (node
, true);
291 if (name
== DECL_ASSEMBLER_NAME (decl
))
294 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
295 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
298 unlink_from_assembler_name_hash (node
, true);
300 const char *old_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
301 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
302 && DECL_RTL_SET_P (decl
))
303 warning (0, "%qD renamed after being referenced in assembly", decl
);
305 SET_DECL_ASSEMBLER_NAME (decl
, name
);
308 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
309 TREE_CHAIN (name
) = alias
;
311 /* If we change assembler name, also all transparent aliases must
312 be updated. There are three kinds - those having same assembler name,
313 those being renamed in varasm.cc and weakref being renamed by the
317 insert_to_assembler_name_hash (node
, true);
319 for (unsigned i
= 0; node
->iterate_direct_aliases (i
, ref
); i
++)
321 struct symtab_node
*alias
= ref
->referring
;
322 if (alias
->transparent_alias
&& !alias
->weakref
323 && symbol_table::assembler_names_equal_p
324 (old_name
, IDENTIFIER_POINTER (
325 DECL_ASSEMBLER_NAME (alias
->decl
))))
326 change_decl_assembler_name (alias
->decl
, name
);
327 else if (alias
->transparent_alias
328 && IDENTIFIER_TRANSPARENT_ALIAS (alias
->decl
))
330 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
))
331 && IDENTIFIER_TRANSPARENT_ALIAS
332 (DECL_ASSEMBLER_NAME (alias
->decl
)));
334 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
)) =
335 ultimate_transparent_alias_target
336 (DECL_ASSEMBLER_NAME (node
->decl
));
338 #ifdef ASM_OUTPUT_WEAKREF
339 else gcc_assert (!alias
->transparent_alias
|| alias
->weakref
);
341 else gcc_assert (!alias
->transparent_alias
);
344 gcc_assert (!node
->transparent_alias
|| !node
->definition
346 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
347 || symbol_table::assembler_names_equal_p
348 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
351 (node
->get_alias_target ()->decl
))));
356 /* Hash sections by their names. */
359 section_name_hasher::hash (section_hash_entry
*n
)
361 return htab_hash_string (n
->name
);
364 /* Return true if section P1 name equals to P2. */
367 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
369 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
372 /* Bump the reference count on ENTRY so that it is retained. */
374 static section_hash_entry
*
375 retain_section_hash_entry (section_hash_entry
*entry
)
381 /* Drop the reference count on ENTRY and remove it if the reference
382 count drops to zero. */
385 release_section_hash_entry (section_hash_entry
*entry
)
390 if (!entry
->ref_count
)
392 hashval_t hash
= htab_hash_string (entry
->name
);
393 section_hash_entry
**slot
394 = symtab
->section_hash
->find_slot_with_hash (entry
->name
,
397 symtab
->section_hash
->clear_slot (slot
);
402 /* Add node into symbol table. This function is not used directly, but via
403 cgraph/varpool node creation routines. */
406 symtab_node::register_symbol (void)
408 symtab
->register_symbol (this);
410 if (!decl
->decl_with_vis
.symtab_node
)
411 decl
->decl_with_vis
.symtab_node
= this;
415 /* Be sure to do this last; C++ FE might create new nodes via
416 DECL_ASSEMBLER_NAME langhook! */
417 symtab
->insert_to_assembler_name_hash (this, false);
420 /* Remove NODE from same comdat group. */
423 symtab_node::remove_from_same_comdat_group (void)
425 if (same_comdat_group
)
428 for (prev
= same_comdat_group
;
429 prev
->same_comdat_group
!= this;
430 prev
= prev
->same_comdat_group
)
432 if (same_comdat_group
== prev
)
433 prev
->same_comdat_group
= NULL
;
435 prev
->same_comdat_group
= same_comdat_group
;
436 same_comdat_group
= NULL
;
437 set_comdat_group (NULL
);
441 /* Remove node from symbol table. This function is not used directly, but via
442 cgraph/varpool node removal routines.
443 INFO is a clone info to attach to new root of clone tree (if any). */
446 symtab_node::unregister (clone_info
*info
)
448 remove_all_references ();
449 remove_all_referring ();
451 /* Remove reference to section. */
452 set_section_for_node (NULL
);
454 remove_from_same_comdat_group ();
456 symtab
->unregister (this);
458 /* During LTO symtab merging we temporarily corrupt decl to symtab node
460 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
461 if (decl
->decl_with_vis
.symtab_node
== this)
463 symtab_node
*replacement_node
= NULL
;
464 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
465 replacement_node
= cnode
->find_replacement (info
);
466 decl
->decl_with_vis
.symtab_node
= replacement_node
;
468 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
469 symtab
->unlink_from_assembler_name_hash (this, false);
470 if (in_init_priority_hash
)
471 symtab
->init_priority_hash
->remove (this);
475 /* Remove symbol from symbol table. */
478 symtab_node::remove (void)
480 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
482 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
486 /* Add NEW_ to the same comdat group that OLD is in. */
489 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
491 gcc_assert (old_node
->get_comdat_group ());
492 gcc_assert (!same_comdat_group
);
493 gcc_assert (this != old_node
);
495 set_comdat_group (old_node
->get_comdat_group ());
496 same_comdat_group
= old_node
;
497 if (!old_node
->same_comdat_group
)
498 old_node
->same_comdat_group
= this;
502 for (n
= old_node
->same_comdat_group
;
503 n
->same_comdat_group
!= old_node
;
504 n
= n
->same_comdat_group
)
506 n
->same_comdat_group
= this;
510 if (comdat_local_p ()
511 && (n
= dyn_cast
<cgraph_node
*> (this)) != NULL
)
513 for (cgraph_edge
*e
= n
->callers
; e
; e
= e
->next_caller
)
514 if (e
->caller
->inlined_to
)
515 e
->caller
->inlined_to
->calls_comdat_local
= true;
517 e
->caller
->calls_comdat_local
= true;
521 /* Dissolve the same_comdat_group list in which NODE resides. */
524 symtab_node::dissolve_same_comdat_group_list (void)
526 symtab_node
*n
= this;
529 if (!same_comdat_group
)
533 next
= n
->same_comdat_group
;
534 n
->same_comdat_group
= NULL
;
535 if (dyn_cast
<cgraph_node
*> (n
))
536 dyn_cast
<cgraph_node
*> (n
)->calls_comdat_local
= false;
537 /* Clear comdat_group for comdat locals, since
538 make_decl_local doesn't. */
539 if (!TREE_PUBLIC (n
->decl
))
540 n
->set_comdat_group (NULL
);
546 /* Return printable assembler name of NODE.
547 This function is used only for debugging. When assembler name
548 is unknown go with identifier name. */
551 symtab_node::asm_name () const
553 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
555 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
558 /* Return printable identifier name. */
561 symtab_node::name () const
563 if (!DECL_NAME (decl
))
565 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
570 return lang_hooks
.decl_printable_name (decl
, 2);
574 symtab_node::get_dump_name (bool asm_name_p
) const
577 const char *fname
= asm_name_p
? asm_name () : name ();
578 unsigned l
= strlen (fname
);
580 char *s
= (char *)ggc_internal_cleared_alloc (l
+ EXTRA
);
581 snprintf (s
, l
+ EXTRA
, "%s/%d", fname
, order
);
587 symtab_node::dump_name () const
589 return get_dump_name (false);
593 symtab_node::dump_asm_name () const
595 return get_dump_name (true);
598 /* Return ipa reference from this symtab_node to
599 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
603 symtab_node::create_reference (symtab_node
*referred_node
,
604 enum ipa_ref_use use_type
)
606 return create_reference (referred_node
, use_type
, NULL
);
610 /* Return ipa reference from this symtab_node to
611 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
612 of the use and STMT the statement (if it exists). */
615 symtab_node::create_reference (symtab_node
*referred_node
,
616 enum ipa_ref_use use_type
, gimple
*stmt
)
618 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
619 ipa_ref_list
*list
, *list2
;
620 ipa_ref_t
*old_references
;
622 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
623 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
626 old_references
= list
->references
.address ();
627 list
->references
.safe_grow (list
->references
.length () + 1, false);
628 ref
= &list
->references
.last ();
630 list2
= &referred_node
->ref_list
;
632 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
633 if(use_type
== IPA_REF_ALIAS
)
635 list2
->referring
.safe_insert (0, ref
);
636 ref
->referred_index
= 0;
638 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
639 list2
->referring
[i
]->referred_index
= i
;
643 list2
->referring
.safe_push (ref
);
644 ref
->referred_index
= list2
->referring
.length () - 1;
647 ref
->referring
= this;
648 ref
->referred
= referred_node
;
650 ref
->lto_stmt_uid
= 0;
651 ref
->speculative_id
= 0;
653 ref
->speculative
= 0;
655 /* If vector was moved in memory, update pointers. */
656 if (old_references
!= list
->references
.address ())
659 for (i
= 0; iterate_reference(i
, ref2
); i
++)
660 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
666 symtab_node::maybe_create_reference (tree val
, gimple
*stmt
)
669 ipa_ref_use use_type
;
671 switch (TREE_CODE (val
))
674 use_type
= IPA_REF_LOAD
;
677 use_type
= IPA_REF_ADDR
;
680 gcc_assert (!handled_component_p (val
));
684 val
= get_base_var (val
);
685 if (val
&& VAR_OR_FUNCTION_DECL_P (val
))
687 symtab_node
*referred
= symtab_node::get (val
);
688 gcc_checking_assert (referred
);
689 return create_reference (referred
, use_type
, stmt
);
694 /* Clone all references from symtab NODE to this symtab_node. */
697 symtab_node::clone_references (symtab_node
*node
)
699 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
701 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
703 bool speculative
= ref
->speculative
;
704 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
705 unsigned int spec_id
= ref
->speculative_id
;
707 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
708 ref2
->speculative
= speculative
;
709 ref2
->lto_stmt_uid
= stmt_uid
;
710 ref2
->speculative_id
= spec_id
;
714 /* Clone all referring from symtab NODE to this symtab_node. */
717 symtab_node::clone_referring (symtab_node
*node
)
719 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
721 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
723 bool speculative
= ref
->speculative
;
724 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
725 unsigned int spec_id
= ref
->speculative_id
;
727 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
728 ref2
->speculative
= speculative
;
729 ref2
->lto_stmt_uid
= stmt_uid
;
730 ref2
->speculative_id
= spec_id
;
734 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
737 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
739 bool speculative
= ref
->speculative
;
740 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
741 unsigned int spec_id
= ref
->speculative_id
;
744 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
745 ref2
->speculative
= speculative
;
746 ref2
->lto_stmt_uid
= stmt_uid
;
747 ref2
->speculative_id
= spec_id
;
751 /* Find the structure describing a reference to REFERRED_NODE
752 and associated with statement STMT. */
755 symtab_node::find_reference (symtab_node
*referred_node
,
756 gimple
*stmt
, unsigned int lto_stmt_uid
)
761 for (i
= 0; iterate_reference (i
, r
); i
++)
762 if (r
->referred
== referred_node
764 && ((stmt
&& r
->stmt
== stmt
)
765 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
766 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
771 /* Remove all references that are associated with statement STMT. */
774 symtab_node::remove_stmt_references (gimple
*stmt
)
779 while (iterate_reference (i
, r
))
781 r
->remove_reference ();
786 /* Remove all stmt references in non-speculative references in THIS
788 Those are not maintained during inlining & cloning.
789 The exception are speculative references that are updated along
790 with callgraph edges associated with them. */
793 symtab_node::clear_stmts_in_references (void)
798 for (i
= 0; iterate_reference (i
, r
); i
++)
803 r
->speculative_id
= 0;
805 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
809 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
810 cnode
->clear_stmts_in_references ();
814 /* Remove all references in ref list. */
817 symtab_node::remove_all_references (void)
819 while (ref_list
.references
.length ())
820 ref_list
.references
.last ().remove_reference ();
821 ref_list
.references
.release ();
824 /* Remove all referring items in ref list. */
827 symtab_node::remove_all_referring (void)
829 while (ref_list
.referring
.length ())
830 ref_list
.referring
.last ()->remove_reference ();
831 ref_list
.referring
.release ();
834 /* Dump references in ref list to FILE. */
837 symtab_node::dump_references (FILE *file
)
841 for (i
= 0; iterate_reference (i
, ref
); i
++)
843 fprintf (file
, "%s (%s) ", ref
->referred
->dump_asm_name (),
844 ipa_ref_use_name
[ref
->use
]);
845 if (ref
->speculative
)
846 fprintf (file
, "(speculative) ");
848 fprintf (file
, "\n");
851 /* Dump referring in list to FILE. */
854 symtab_node::dump_referring (FILE *file
)
858 for (i
= 0; iterate_referring(i
, ref
); i
++)
860 fprintf (file
, "%s (%s) ", ref
->referring
->dump_asm_name (),
861 ipa_ref_use_name
[ref
->use
]);
862 if (ref
->speculative
)
863 fprintf (file
, "(speculative) ");
865 fprintf (file
, "\n");
868 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
870 /* Dump the visibility of the symbol. */
873 symtab_node::get_visibility_string () const
875 static const char * const visibility_types
[]
876 = { "default", "protected", "hidden", "internal" };
877 return visibility_types
[DECL_VISIBILITY (decl
)];
880 /* Dump the type_name of the symbol. */
882 symtab_node::get_symtab_type_string () const
884 return symtab_type_names
[type
];
887 /* Dump base fields of symtab nodes to F. Not to be used directly. */
890 symtab_node::dump_base (FILE *f
)
892 static const char * const visibility_types
[] = {
893 "default", "protected", "hidden", "internal"
896 fprintf (f
, "%s (%s)", dump_asm_name (), name ());
897 dump_addr (f
, " @", (void *)this);
898 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
901 fprintf (f
, " definition");
903 fprintf (f
, " analyzed");
905 fprintf (f
, " alias");
906 if (transparent_alias
)
907 fprintf (f
, " transparent_alias");
909 fprintf (f
, " weakref");
911 fprintf (f
, " symver");
912 if (cpp_implicit_alias
)
913 fprintf (f
, " cpp_implicit_alias");
915 fprintf (f
, " target:%s",
916 DECL_P (alias_target
)
917 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
919 : IDENTIFIER_POINTER (alias_target
));
921 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
922 fprintf (f
, "\n Visibility:");
923 if (in_other_partition
)
924 fprintf (f
, " in_other_partition");
925 if (used_from_other_partition
)
926 fprintf (f
, " used_from_other_partition");
928 fprintf (f
, " force_output");
930 fprintf (f
, " forced_by_abi");
931 if (externally_visible
)
932 fprintf (f
, " externally_visible");
933 if (semantic_interposition
)
934 fprintf (f
, " semantic_interposition");
936 fprintf (f
, " no_reorder");
937 if (resolution
!= LDPR_UNKNOWN
)
939 ld_plugin_symbol_resolution_names
[(int)resolution
]);
940 if (TREE_ASM_WRITTEN (decl
))
941 fprintf (f
, " asm_written");
942 if (DECL_EXTERNAL (decl
))
943 fprintf (f
, " external");
944 if (TREE_PUBLIC (decl
))
945 fprintf (f
, " public");
946 if (DECL_COMMON (decl
))
947 fprintf (f
, " common");
948 if (DECL_WEAK (decl
))
949 fprintf (f
, " weak");
950 if (DECL_DLLIMPORT_P (decl
))
951 fprintf (f
, " dll_import");
952 if (DECL_COMDAT (decl
))
953 fprintf (f
, " comdat");
954 if (get_comdat_group ())
955 fprintf (f
, " comdat_group:%s",
956 IDENTIFIER_POINTER (get_comdat_group_id ()));
957 if (DECL_ONE_ONLY (decl
))
958 fprintf (f
, " one_only");
960 fprintf (f
, " section:%s",
962 if (implicit_section
)
963 fprintf (f
," (implicit_section)");
964 if (DECL_VISIBILITY_SPECIFIED (decl
))
965 fprintf (f
, " visibility_specified");
966 if (DECL_VISIBILITY (decl
))
967 fprintf (f
, " visibility:%s",
968 visibility_types
[DECL_VISIBILITY (decl
)]);
969 if (DECL_VIRTUAL_P (decl
))
970 fprintf (f
, " virtual");
971 if (DECL_ARTIFICIAL (decl
))
972 fprintf (f
, " artificial");
973 if (TREE_CODE (decl
) == FUNCTION_DECL
)
975 if (DECL_STATIC_CONSTRUCTOR (decl
))
976 fprintf (f
, " constructor");
977 if (DECL_STATIC_DESTRUCTOR (decl
))
978 fprintf (f
, " destructor");
981 fprintf (f
, " ifunc_resolver");
984 if (same_comdat_group
)
985 fprintf (f
, " Same comdat group as: %s\n",
986 same_comdat_group
->dump_asm_name ());
987 if (next_sharing_asm_name
)
988 fprintf (f
, " next sharing asm name: %i\n",
989 next_sharing_asm_name
->order
);
990 if (previous_sharing_asm_name
)
991 fprintf (f
, " previous sharing asm name: %i\n",
992 previous_sharing_asm_name
->order
);
995 fprintf (f
, " Address is taken.\n");
998 fprintf (f
, " Aux:");
999 dump_addr (f
, " @", (void *)aux
);
1003 fprintf (f
, " References: ");
1004 dump_references (f
);
1005 fprintf (f
, " Referring: ");
1008 fprintf (f
, " Read from file: %s\n",
1009 lto_file_data
->file_name
);
1012 /* Dump symtab node to F. */
1015 symtab_node::dump (FILE *f
)
1017 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
1019 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1024 symtab_node::dump_graphviz (FILE *f
)
1026 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
1027 cnode
->dump_graphviz (f
);
1031 symbol_table::dump (FILE *f
)
1034 fprintf (f
, "Symbol table:\n\n");
1035 FOR_EACH_SYMBOL (node
)
1040 symbol_table::dump_graphviz (FILE *f
)
1043 fprintf (f
, "digraph symtab {\n");
1044 FOR_EACH_SYMBOL (node
)
1045 node
->dump_graphviz (f
);
1050 symbol_table::debug (void)
1055 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1056 Return NULL if there's no such node. */
1059 symtab_node::get_for_asmname (const_tree asmname
)
1063 symtab
->symtab_initialize_asm_name_hash ();
1064 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
1066 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
1077 /* Dump symtab node NODE to stderr. */
1080 symtab_node::debug (void)
1085 /* Verify common part of symtab nodes. */
1088 /* Disable warnings about missing quoting in GCC diagnostics for
1089 the verification errors. Their format strings don't follow GCC
1090 diagnostic conventions and the calls are ultimately followed by
1091 one to internal_error. */
1092 # pragma GCC diagnostic push
1093 # pragma GCC diagnostic ignored "-Wformat-diag"
1097 symtab_node::verify_base (void)
1099 bool error_found
= false;
1100 symtab_node
*hashed_node
;
1102 if (is_a
<cgraph_node
*> (this))
1104 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1106 error ("function symbol is not function");
1109 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
))
1111 != dyn_cast
<cgraph_node
*> (this)->ifunc_resolver
)
1113 error ("inconsistent %<ifunc%> attribute");
1117 else if (is_a
<varpool_node
*> (this))
1121 error ("variable symbol is not variable");
1127 error ("node has unknown type");
1130 if (order
< 0 || order
>= symtab
->order
)
1132 error ("node has invalid order %i", order
);
1136 if (symtab
->state
!= LTO_STREAMING
)
1138 hashed_node
= symtab_node::get (decl
);
1141 error ("node not found node->decl->decl_with_vis.symtab_node");
1144 if (hashed_node
!= this
1145 && (!is_a
<cgraph_node
*> (this)
1146 || !dyn_cast
<cgraph_node
*> (this)->clone_of
1147 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1149 error ("node differs from node->decl->decl_with_vis.symtab_node");
1153 if (symtab
->assembler_name_hash
)
1155 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1158 if (hashed_node
->previous_sharing_asm_name
)
1160 error ("assembler name hash list corrupted");
1163 else if (previous_sharing_asm_name
== NULL
)
1165 if (hashed_node
!= this)
1167 error ("assembler name hash list corrupted");
1171 else if (!(is_a
<varpool_node
*> (this) && DECL_HARD_REGISTER (decl
)))
1173 if (!asmname_hasher::equal (previous_sharing_asm_name
,
1174 DECL_ASSEMBLER_NAME (decl
)))
1176 error ("node not found in symtab assembler name hash");
1182 if (previous_sharing_asm_name
1183 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1185 error ("double linked list of assembler names corrupted");
1188 if (body_removed
&& definition
)
1190 error ("node has body_removed but is definition");
1193 if (analyzed
&& !definition
)
1195 error ("node is analyzed but it is not a definition");
1198 if (cpp_implicit_alias
&& !alias
)
1200 error ("node is alias but not implicit alias");
1203 if (alias
&& !definition
&& !weakref
)
1205 error ("node is alias but not definition");
1208 if (weakref
&& !transparent_alias
)
1210 error ("node is weakref but not an transparent_alias");
1213 if (transparent_alias
&& !alias
)
1215 error ("node is transparent_alias but not an alias");
1218 if (symver
&& !alias
)
1220 error ("node is symver but not alias");
1223 /* Limitation of gas requires us to output targets of symver aliases as
1224 global symbols. This is binutils PR 25295. */
1226 && (!TREE_PUBLIC (get_alias_target ()->decl
)
1227 || DECL_VISIBILITY (get_alias_target ()->decl
) != VISIBILITY_DEFAULT
))
1229 error ("symver target is not exported with default visibility");
1233 && (!TREE_PUBLIC (decl
)
1234 || DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
))
1236 error ("symver is not exported with default visibility");
1239 if (same_comdat_group
)
1241 symtab_node
*n
= same_comdat_group
;
1243 if (!n
->get_comdat_group ())
1245 error ("node is in same_comdat_group list but has no comdat_group");
1248 if (n
->get_comdat_group () != get_comdat_group ())
1250 error ("same_comdat_group list across different groups");
1253 if (n
->type
!= type
)
1255 error ("mixing different types of symbol in same comdat groups is not supported");
1260 error ("node is alone in a comdat group");
1265 if (!n
->same_comdat_group
)
1267 error ("same_comdat_group is not a circular list");
1271 n
= n
->same_comdat_group
;
1274 if (comdat_local_p ())
1276 ipa_ref
*ref
= NULL
;
1278 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1280 if (!in_same_comdat_group_p (ref
->referring
))
1282 error ("comdat-local symbol referred to by %s outside its "
1284 identifier_to_locale (ref
->referring
->name()));
1290 if (implicit_section
&& !get_section ())
1292 error ("implicit_section flag is set but section isn%'t");
1295 if (get_section () && get_comdat_group ()
1296 && !implicit_section
1297 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1299 error ("Both section and comdat group is set");
1302 /* TODO: Add string table for sections, so we do not keep holding duplicated
1304 if (alias
&& definition
1305 && get_section () != get_alias_target ()->get_section ()
1307 || !get_alias_target ()->get_section ()
1308 || strcmp (get_section(),
1309 get_alias_target ()->get_section ())))
1311 error ("Alias and target%'s section differs");
1312 get_alias_target ()->dump (stderr
);
1315 if (alias
&& definition
1316 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1318 error ("Alias and target%'s comdat groups differs");
1319 get_alias_target ()->dump (stderr
);
1322 if (transparent_alias
&& definition
&& !weakref
)
1324 symtab_node
*to
= get_alias_target ();
1326 = IDENTIFIER_POINTER (
1327 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1329 = IDENTIFIER_POINTER (
1330 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1331 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1333 error ("Transparent alias and target%'s assembler names differs");
1334 get_alias_target ()->dump (stderr
);
1338 if (transparent_alias
&& definition
1339 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1341 error ("Chained transparent aliases");
1342 get_alias_target ()->dump (stderr
);
1349 /* Verify consistency of NODE. */
1352 symtab_node::verify (void)
1357 timevar_push (TV_CGRAPH_VERIFY
);
1358 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1359 node
->verify_node ();
1364 internal_error ("symtab_node::verify failed");
1366 timevar_pop (TV_CGRAPH_VERIFY
);
1369 /* Verify symbol table for internal consistency. */
1372 symtab_node::verify_symtab_nodes (void)
1375 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1378 for (anode
= symtab
->first_asm_symbol (); anode
; anode
= anode
->next
)
1379 if (anode
->order
< 0 || anode
->order
>= symtab
->order
)
1381 error ("invalid order in asm node %i", anode
->order
);
1382 internal_error ("symtab_node::verify failed");
1385 FOR_EACH_SYMBOL (node
)
1388 if (node
->get_comdat_group ())
1390 symtab_node
**entry
, *s
;
1393 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1397 else if (!DECL_EXTERNAL (node
->decl
))
1399 for (s
= (*entry
)->same_comdat_group
;
1400 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1401 s
= s
->same_comdat_group
)
1403 if (!s
|| s
== *entry
)
1405 error ("Two symbols with same comdat_group are not linked by "
1406 "the same_comdat_group list.");
1409 internal_error ("symtab_node::verify failed");
1417 # pragma GCC diagnostic pop
1420 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1421 but other code such as notice_global_symbol generates rtl. */
1424 symtab_node::make_decl_local (void)
1431 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1432 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1433 symtab
->change_decl_assembler_name
1434 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1435 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1436 DECL_ATTRIBUTES (decl
));
1438 /* Avoid clearing comdat_groups on comdat-local decls. */
1439 else if (TREE_PUBLIC (decl
) == 0)
1442 /* Localizing a symbol also make all its transparent aliases local. */
1444 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1446 struct symtab_node
*alias
= ref
->referring
;
1447 if (alias
->transparent_alias
)
1448 alias
->make_decl_local ();
1453 DECL_COMMON (decl
) = 0;
1454 /* ADDRESSABLE flag is not defined for public symbols. */
1455 TREE_ADDRESSABLE (decl
) = 1;
1456 TREE_STATIC (decl
) = 1;
1459 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1461 DECL_COMDAT (decl
) = 0;
1462 DECL_WEAK (decl
) = 0;
1463 DECL_EXTERNAL (decl
) = 0;
1464 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1465 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1466 TREE_PUBLIC (decl
) = 0;
1467 DECL_DLLIMPORT_P (decl
) = 0;
1468 if (!DECL_RTL_SET_P (decl
))
1471 /* Update rtl flags. */
1472 make_decl_rtl (decl
);
1474 rtl
= DECL_RTL (decl
);
1478 symbol
= XEXP (rtl
, 0);
1479 if (GET_CODE (symbol
) != SYMBOL_REF
)
1482 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1485 /* Copy visibility from N.
1486 This is useful when THIS becomes a transparent alias of N. */
1489 symtab_node::copy_visibility_from (symtab_node
*n
)
1491 gcc_checking_assert (n
->weakref
== weakref
);
1494 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1496 struct symtab_node
*alias
= ref
->referring
;
1497 if (alias
->transparent_alias
)
1498 alias
->copy_visibility_from (n
);
1503 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1504 /* ADDRESSABLE flag is not defined for public symbols. */
1505 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1506 TREE_ADDRESSABLE (decl
) = 1;
1507 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1509 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1511 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1512 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1513 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1514 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1515 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1516 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1517 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1518 resolution
= n
->resolution
;
1519 set_comdat_group (n
->get_comdat_group ());
1521 externally_visible
= n
->externally_visible
;
1522 if (!DECL_RTL_SET_P (decl
))
1525 /* Update rtl flags. */
1526 make_decl_rtl (decl
);
1528 rtx rtl
= DECL_RTL (decl
);
1532 rtx symbol
= XEXP (rtl
, 0);
1533 if (GET_CODE (symbol
) != SYMBOL_REF
)
1536 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1539 /* Walk the alias chain to return the symbol NODE is alias of.
1540 If NODE is not an alias, return NODE.
1541 Assumes NODE is known to be alias. */
1544 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1547 bool transparent_p
= false;
1549 /* To determine visibility of the target, we follow ELF semantic of aliases.
1550 Here alias is an alternative assembler name of a given definition. Its
1551 availability prevails the availability of its target (i.e. static alias of
1552 weak definition is available.
1554 Transparent alias is just alternative name of a given symbol used within
1555 one compilation unit and is translated prior hitting the object file. It
1556 inherits the visibility of its target.
1557 Weakref is a different animal (and noweak definition is weak).
1559 If we ever get into supporting targets with different semantics, a target
1560 hook will be needed here. */
1564 transparent_p
= transparent_alias
;
1566 *availability
= get_availability (ref
);
1568 *availability
= AVAIL_NOT_AVAILABLE
;
1571 symtab_node
*node
= this;
1574 if (node
->alias
&& node
->analyzed
)
1575 node
= node
->get_alias_target ();
1578 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1580 else if (node
->analyzed
&& !node
->transparent_alias
)
1581 *availability
= node
->get_availability (ref
);
1583 *availability
= AVAIL_NOT_AVAILABLE
;
1586 if (node
&& availability
&& transparent_p
1587 && node
->transparent_alias
)
1589 *availability
= node
->get_availability (ref
);
1590 transparent_p
= false;
1594 *availability
= AVAIL_NOT_AVAILABLE
;
1598 /* C++ FE sometimes change linkage flags after producing same body aliases.
1600 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1601 are obviously equivalent. The way it is doing so is however somewhat
1602 kludgy and interferes with the visibility code. As a result we need to
1603 copy the visibility from the target to get things right. */
1606 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1608 if (is_a
<cgraph_node
*> (this))
1610 DECL_DECLARED_INLINE_P (decl
)
1611 = DECL_DECLARED_INLINE_P (target
->decl
);
1612 DECL_DISREGARD_INLINE_LIMITS (decl
)
1613 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1615 /* FIXME: It is not really clear why those flags should not be copied for
1619 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1620 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1621 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1623 if (TREE_PUBLIC (decl
))
1627 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1628 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1629 group
= target
->get_comdat_group ();
1630 set_comdat_group (group
);
1631 if (group
&& !same_comdat_group
)
1632 add_to_same_comdat_group (target
);
1634 externally_visible
= target
->externally_visible
;
1637 /* Set section, do not recurse into aliases.
1638 When one wants to change section of a symbol and its aliases,
1642 symtab_node::set_section_for_node (const char *section
)
1644 const char *current
= get_section ();
1646 if (current
== section
1647 || (current
&& section
1648 && !strcmp (current
, section
)))
1651 release_section_hash_entry (x_section
);
1655 implicit_section
= false;
1658 if (!symtab
->section_hash
)
1659 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1660 section_hash_entry
**slot
= symtab
->section_hash
->find_slot_with_hash
1661 (section
, htab_hash_string (section
), INSERT
);
1663 x_section
= retain_section_hash_entry (*slot
);
1666 int len
= strlen (section
);
1667 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1668 x_section
->ref_count
= 1;
1669 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1670 memcpy (x_section
->name
, section
, len
+ 1);
1674 /* Set the section of node THIS to be the same as the section
1675 of node OTHER. Keep reference counts of the sections
1676 up-to-date as needed. */
1679 symtab_node::set_section_for_node (const symtab_node
&other
)
1681 if (x_section
== other
.x_section
)
1683 if (get_section () && other
.get_section ())
1684 gcc_checking_assert (strcmp (get_section (), other
.get_section ()) != 0);
1685 release_section_hash_entry (x_section
);
1686 if (other
.x_section
)
1687 x_section
= retain_section_hash_entry (other
.x_section
);
1691 implicit_section
= false;
1695 /* Workers for set_section. */
1698 symtab_node::set_section_from_string (symtab_node
*n
, void *s
)
1700 n
->set_section_for_node ((char *)s
);
1704 /* Set the section of node N to be the same as the section
1708 symtab_node::set_section_from_node (symtab_node
*n
, void *o
)
1710 const symtab_node
&other
= *static_cast<const symtab_node
*> (o
);
1711 n
->set_section_for_node (other
);
1715 /* Set section of symbol and its aliases. */
1718 symtab_node::set_section (const char *section
)
1720 gcc_assert (!this->alias
|| !this->analyzed
);
1721 call_for_symbol_and_aliases
1722 (symtab_node::set_section_from_string
, const_cast<char *>(section
), true);
1726 symtab_node::set_section (const symtab_node
&other
)
1728 call_for_symbol_and_aliases
1729 (symtab_node::set_section_from_node
, const_cast<symtab_node
*>(&other
), true);
1732 /* Return the initialization priority. */
1735 symtab_node::get_init_priority ()
1737 if (!this->in_init_priority_hash
)
1738 return DEFAULT_INIT_PRIORITY
;
1740 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1741 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1744 /* Return the finalization priority. */
1747 cgraph_node::get_fini_priority ()
1749 if (!this->in_init_priority_hash
)
1750 return DEFAULT_INIT_PRIORITY
;
1751 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1752 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1755 /* Return the initialization and finalization priority information for
1756 DECL. If there is no previous priority information, a freshly
1757 allocated structure is returned. */
1759 symbol_priority_map
*
1760 symtab_node::priority_info (void)
1762 if (!symtab
->init_priority_hash
)
1763 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1766 symbol_priority_map
*h
1767 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1770 h
->init
= DEFAULT_INIT_PRIORITY
;
1771 h
->fini
= DEFAULT_INIT_PRIORITY
;
1772 in_init_priority_hash
= true;
1778 /* Set initialization priority to PRIORITY. */
1781 symtab_node::set_init_priority (priority_type priority
)
1783 symbol_priority_map
*h
;
1785 if (is_a
<cgraph_node
*> (this))
1786 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1788 if (priority
== DEFAULT_INIT_PRIORITY
)
1790 gcc_assert (get_init_priority() == priority
);
1793 h
= priority_info ();
1797 /* Set finalization priority to PRIORITY. */
1800 cgraph_node::set_fini_priority (priority_type priority
)
1802 symbol_priority_map
*h
;
1804 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1806 if (priority
== DEFAULT_INIT_PRIORITY
)
1808 gcc_assert (get_fini_priority() == priority
);
1811 h
= priority_info ();
1815 /* Worker for symtab_resolve_alias. */
1818 symtab_node::set_implicit_section (symtab_node
*n
,
1819 void *data ATTRIBUTE_UNUSED
)
1821 n
->implicit_section
= true;
1825 /* Add reference recording that symtab node is alias of TARGET.
1826 The function can fail in the case of aliasing cycles; in this case
1827 it returns false. */
1830 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1834 gcc_assert (!analyzed
&& !ref_list
.references
.length ());
1836 /* Never let cycles to creep into the symbol table alias references;
1837 those will make alias walkers to be infinite. */
1838 for (n
= target
; n
&& n
->alias
;
1839 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1842 if (is_a
<cgraph_node
*> (this))
1843 error ("function %q+D part of alias cycle", decl
);
1844 else if (is_a
<varpool_node
*> (this))
1845 error ("variable %q+D part of alias cycle", decl
);
1852 /* "analyze" the node - i.e. mark the reference. */
1856 transparent
|= transparent_alias
;
1857 transparent_alias
= transparent
;
1859 while (target
->transparent_alias
&& target
->analyzed
)
1860 target
= target
->get_alias_target ();
1861 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1863 /* Add alias into the comdat group of its target unless it is already there. */
1864 if (same_comdat_group
)
1865 remove_from_same_comdat_group ();
1866 set_comdat_group (NULL
);
1867 if (target
->get_comdat_group ())
1868 add_to_same_comdat_group (target
);
1870 if ((get_section () != target
->get_section ()
1871 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1873 error ("section of alias %q+D must match section of its target", decl
);
1875 set_section (*target
);
1876 if (target
->implicit_section
)
1877 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1879 /* Alias targets become redundant after alias is resolved into an reference.
1880 We do not want to keep it around or we would have to mind updating them
1881 when renaming symbols. */
1882 alias_target
= NULL
;
1884 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1885 fixup_same_cpp_alias_visibility (target
);
1887 /* If alias has address taken, so does the target. */
1889 target
->ultimate_alias_target ()->address_taken
= true;
1891 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1892 If alias is transparent, also all transparent aliases of THIS are now
1894 Also merge same comdat group lists. */
1896 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1898 struct symtab_node
*alias_alias
= ref
->referring
;
1899 if (alias_alias
->get_comdat_group ())
1901 alias_alias
->remove_from_same_comdat_group ();
1902 alias_alias
->set_comdat_group (NULL
);
1903 if (target
->get_comdat_group ())
1904 alias_alias
->add_to_same_comdat_group (target
);
1906 if ((!alias_alias
->transparent_alias
1907 && !alias_alias
->symver
)
1910 alias_alias
->remove_all_references ();
1911 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1918 /* Worker searching noninterposable alias. */
1921 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1923 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1925 symtab_node
*fn
= node
->ultimate_alias_target ();
1927 /* Ensure that the alias is well formed this may not be the case
1928 of user defined aliases and currently it is not always the case
1929 of C++ same body aliases (that is a bug). */
1930 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1931 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1932 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1933 && flags_from_decl_or_type (node
->decl
)
1934 != flags_from_decl_or_type (fn
->decl
))
1935 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1937 *(symtab_node
**)data
= node
;
1943 /* If node cannot be overwriten by static or dynamic linker to point to
1944 different definition, return NODE. Otherwise look for alias with such
1945 property and if none exists, introduce new one. */
1948 symtab_node::noninterposable_alias (void)
1951 symtab_node
*new_node
= NULL
;
1953 /* First try to look up existing alias or base object
1954 (if that is already non-overwritable). */
1955 symtab_node
*node
= ultimate_alias_target ();
1956 gcc_assert (!node
->alias
&& !node
->weakref
);
1957 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1958 (void *)&new_node
, true);
1962 /* If aliases aren't supported by the assembler, fail. */
1963 if (!TARGET_SUPPORTS_ALIASES
)
1965 else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (node
->decl
)))
1968 /* Otherwise create a new one. */
1969 new_decl
= copy_node (node
->decl
);
1970 DECL_DLLIMPORT_P (new_decl
) = 0;
1971 tree name
= clone_function_name (node
->decl
, "localalias");
1974 unsigned long num
= 0;
1975 /* In the rare case we already have a localalias, but the above
1976 node->call_for_symbol_and_aliases call didn't find any suitable,
1977 iterate until we find one not used yet. */
1978 while (symtab_node::get_for_asmname (name
))
1979 name
= clone_function_name (node
->decl
, "localalias", num
++);
1981 DECL_NAME (new_decl
) = name
;
1982 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1983 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1984 DECL_INITIAL (new_decl
) = NULL
;
1985 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1986 SET_DECL_RTL (new_decl
, NULL
);
1988 /* Update the properties. */
1989 DECL_EXTERNAL (new_decl
) = 0;
1990 TREE_PUBLIC (new_decl
) = 0;
1991 DECL_COMDAT (new_decl
) = 0;
1992 DECL_WEAK (new_decl
) = 0;
1994 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1995 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1996 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1998 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1999 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
2000 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
2002 cgraph_node
*new_cnode
= dyn_cast
<cgraph_node
*> (new_node
),
2003 *cnode
= dyn_cast
<cgraph_node
*> (node
);
2005 new_cnode
->unit_id
= cnode
->unit_id
;
2006 new_cnode
->merged_comdat
= cnode
->merged_comdat
;
2007 new_cnode
->merged_extern_inline
= cnode
->merged_extern_inline
;
2011 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
2012 DECL_INITIAL (new_decl
) = error_mark_node
;
2013 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
2015 new_node
->resolve_alias (node
);
2016 gcc_assert (decl_binds_to_current_def_p (new_decl
)
2017 && targetm
.binds_local_p (new_decl
));
2021 /* Return true if symtab node and TARGET represents
2022 semantically equivalent symbols. */
2025 symtab_node::semantically_equivalent_p (symtab_node
*target
)
2027 enum availability avail
;
2031 /* Equivalent functions are equivalent. */
2032 if (decl
== target
->decl
)
2035 /* If symbol is not overwritable by different implementation,
2036 walk to the base object it defines. */
2037 ba
= ultimate_alias_target (&avail
);
2038 if (avail
>= AVAIL_AVAILABLE
)
2045 bb
= target
->ultimate_alias_target (&avail
);
2046 if (avail
>= AVAIL_AVAILABLE
)
2056 /* Classify symbol symtab node for partitioning. */
2058 enum symbol_partitioning_class
2059 symtab_node::get_partitioning_class (void)
2061 /* Inline clones are always duplicated.
2062 This include external declarations. */
2063 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2065 if (DECL_ABSTRACT_P (decl
))
2066 return SYMBOL_EXTERNAL
;
2068 if (cnode
&& (cnode
->inlined_to
|| cnode
->declare_variant_alt
))
2069 return SYMBOL_DUPLICATE
;
2071 /* Transparent aliases are always duplicated. */
2072 if (transparent_alias
)
2073 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
2075 /* External declarations are external. */
2076 if (DECL_EXTERNAL (decl
))
2077 return SYMBOL_EXTERNAL
;
2079 /* Even static aliases of external functions as external. Those can happen
2080 when COMDAT got resolved to non-IL implementation. */
2081 if (alias
&& DECL_EXTERNAL (ultimate_alias_target ()->decl
))
2082 return SYMBOL_EXTERNAL
;
2084 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
2086 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
2087 return SYMBOL_EXTERNAL
;
2088 /* Constant pool references use local symbol names that cannot
2089 be promoted global. We should never put into a constant pool
2090 objects that cannot be duplicated across partitions. */
2091 if (DECL_IN_CONSTANT_POOL (decl
))
2092 return SYMBOL_DUPLICATE
;
2093 if (DECL_HARD_REGISTER (decl
))
2094 return SYMBOL_DUPLICATE
;
2095 gcc_checking_assert (vnode
->definition
);
2097 /* Functions that are cloned may stay in callgraph even if they are unused.
2098 Handle them as external; compute_ltrans_boundary take care to make
2099 proper things to happen (i.e. to make them appear in the boundary but
2100 with body streamed, so clone can me materialized). */
2101 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
2102 return SYMBOL_EXTERNAL
;
2104 /* Linker discardable symbols are duplicated to every use unless they are
2106 if (DECL_ONE_ONLY (decl
)
2109 && !used_from_object_file_p ())
2110 return SYMBOL_DUPLICATE
;
2112 return SYMBOL_PARTITION
;
2115 /* Return true when symbol is known to be non-zero. */
2118 symtab_node::nonzero_address ()
2120 /* Weakrefs may be NULL when their target is not defined. */
2121 if (alias
&& weakref
)
2125 symtab_node
*target
= ultimate_alias_target ();
2127 if (target
->alias
&& target
->weakref
)
2129 /* We cannot recurse to target::nonzero. It is possible that the
2130 target is used only via the alias.
2131 We may walk references and look for strong use, but we do not know
2132 if this strong use will survive to final binary, so be
2134 ??? Maybe we could do the lookup during late optimization that
2135 could be useful to eliminate the NULL pointer checks in LTO
2137 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
2139 if (target
->resolution
!= LDPR_UNKNOWN
2140 && target
->resolution
!= LDPR_UNDEF
2141 && !target
->can_be_discarded_p ()
2142 && flag_delete_null_pointer_checks
)
2150 /* With !flag_delete_null_pointer_checks we assume that symbols may
2151 bind to NULL. This is on by default on embedded targets only.
2153 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2154 linking fails. Important case of WEAK we want to do well are comdats,
2155 which also must be defined somewhere.
2157 When parsing, beware the cases when WEAK attribute is added later. */
2158 if ((!DECL_WEAK (decl
) || DECL_COMDAT (decl
))
2159 && flag_delete_null_pointer_checks
)
2161 refuse_visibility_changes
= true;
2165 /* If target is defined and not extern, we know it will be
2166 output and thus it will bind to non-NULL.
2167 Play safe for flag_delete_null_pointer_checks where weak definition may
2168 be re-defined by NULL. */
2169 if (definition
&& !DECL_EXTERNAL (decl
)
2170 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
2172 if (!DECL_WEAK (decl
))
2173 refuse_visibility_changes
= true;
2177 /* As the last resort, check the resolution info. */
2178 if (resolution
!= LDPR_UNKNOWN
2179 && resolution
!= LDPR_UNDEF
2180 && !can_be_discarded_p ()
2181 && flag_delete_null_pointer_checks
)
2186 /* Return 0 if symbol is known to have different address than S2,
2187 Return 1 if symbol is known to have same address as S2,
2188 return -1 otherwise.
2190 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2191 and S2 is going to be accessed. This eliminates the situations when
2192 either THIS or S2 is NULL and is useful for comparing bases when deciding
2193 about memory aliasing. */
2195 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
2197 enum availability avail1
, avail2
;
2199 /* A Shortcut: equivalent symbols are always equivalent. */
2203 /* Unwind transparent aliases first; those are always equal to their
2205 if (this->transparent_alias
&& this->analyzed
)
2206 return this->get_alias_target ()->equal_address_to (s2
);
2207 while (s2
->transparent_alias
&& s2
->analyzed
)
2208 s2
= s2
->get_alias_target();
2213 /* For non-interposable aliases, lookup and compare their actual definitions.
2214 Also check if the symbol needs to bind to given definition. */
2215 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
2216 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
2217 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
2218 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
2219 bool really_binds_local1
= binds_local1
;
2220 bool really_binds_local2
= binds_local2
;
2222 /* Addresses of vtables and virtual functions cannot be used by user
2223 code and are used only within speculation. In this case we may make
2224 symbol equivalent to its alias even if interposition may break this
2225 rule. Doing so will allow us to turn speculative inlining into
2226 non-speculative more aggressively. */
2227 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
2228 binds_local1
= true;
2229 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
2230 binds_local2
= true;
2232 /* If both definitions are available we know that even if they are bound
2233 to other unit they must be defined same way and therefore we can use
2234 equivalence test. */
2235 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
2236 binds_local1
= binds_local2
= true;
2238 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2240 /* We made use of the fact that alias is not weak. */
2242 refuse_visibility_changes
= true;
2244 s2
->refuse_visibility_changes
= true;
2248 /* If both symbols may resolve to NULL, we cannot really prove them
2250 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2253 /* Except for NULL, functions and variables never overlap. */
2254 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2257 /* If one of the symbols is unresolved alias, punt. */
2258 if (rs1
->alias
|| rs2
->alias
)
2261 /* If we have a non-interposable definition of at least one of the symbols
2262 and the other symbol is different, we know other unit cannot interpose
2263 it to the first symbol; all aliases of the definition needs to be
2264 present in the current unit. */
2265 if (((really_binds_local1
|| really_binds_local2
)
2266 /* If we have both definitions and they are different, we know they
2267 will be different even in units they binds to. */
2268 || (binds_local1
&& binds_local2
))
2271 /* We make use of the fact that one symbol is not alias of the other
2272 and that the definition is non-interposable. */
2273 refuse_visibility_changes
= true;
2274 s2
->refuse_visibility_changes
= true;
2275 rs1
->refuse_visibility_changes
= true;
2276 rs2
->refuse_visibility_changes
= true;
2283 /* If the FE tells us at least one of the decls will never be aliased nor
2284 overlapping with other vars in some other way, return 0. */
2286 && (lookup_attribute ("non overlapping", DECL_ATTRIBUTES (decl
))
2287 || lookup_attribute ("non overlapping", DECL_ATTRIBUTES (s2
->decl
))))
2290 /* TODO: Alias oracle basically assume that addresses of global variables
2291 are different unless they are declared as alias of one to another while
2292 the code folding comparisons doesn't.
2293 We probably should be consistent and use this fact here, too, but for
2294 the moment return false only when we are called from the alias oracle.
2295 Return 0 in C constant initializers and C++ manifestly constant
2296 expressions, the likelyhood that different vars will be aliases is
2297 small and returning -1 lets us reject too many initializers. */
2298 if (memory_accessed
|| folding_initializer
)
2304 /* Worker for call_for_symbol_and_aliases. */
2307 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2310 bool include_overwritable
)
2313 FOR_EACH_ALIAS (this, ref
)
2315 symtab_node
*alias
= ref
->referring
;
2316 if (include_overwritable
2317 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2318 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2319 include_overwritable
))
2325 /* Return true if address of N is possibly compared. */
2328 address_matters_1 (symtab_node
*n
, void *)
2330 struct ipa_ref
*ref
;
2332 if (!n
->address_can_be_compared_p ())
2334 if (n
->externally_visible
|| n
->force_output
)
2337 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2338 if (ref
->address_matters_p ())
2343 /* Return true if symbol's address may possibly be compared to other
2344 symbol's address. */
2347 symtab_node::address_matters_p ()
2349 gcc_assert (!alias
);
2350 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2353 /* Return true if symbol's alignment may be increased. */
2356 symtab_node::can_increase_alignment_p (void)
2358 symtab_node
*target
= ultimate_alias_target ();
2360 /* For now support only variables. */
2364 /* With -fno-toplevel-reorder we may have already output the constant. */
2365 if (TREE_ASM_WRITTEN (target
->decl
))
2368 /* If target is already placed in an anchor, we cannot touch its
2370 if (DECL_RTL_SET_P (target
->decl
)
2371 && MEM_P (DECL_RTL (target
->decl
))
2372 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2375 /* Constant pool entries may be shared. */
2376 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2379 /* We cannot change alignment of symbols that may bind to symbols
2380 in other translation unit that may contain a definition with lower
2382 if (!decl_binds_to_current_def_p (decl
))
2385 /* When compiling partition, be sure the symbol is not output by other
2388 && (target
->in_other_partition
2389 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2392 /* Do not override the alignment as specified by the ABI when the used
2393 attribute is set. */
2394 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2397 /* Do not override explicit alignment set by the user when an explicit
2398 section name is also used. This is a common idiom used by many
2399 software projects. */
2400 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2406 /* Worker for symtab_node::increase_alignment. */
2409 increase_alignment_1 (symtab_node
*n
, void *v
)
2411 unsigned int align
= (size_t)v
;
2412 if (DECL_ALIGN (n
->decl
) < align
2413 && n
->can_increase_alignment_p ())
2415 SET_DECL_ALIGN (n
->decl
, align
);
2416 DECL_USER_ALIGN (n
->decl
) = 1;
2421 /* Increase alignment of THIS to ALIGN. */
2424 symtab_node::increase_alignment (unsigned int align
)
2426 gcc_assert (can_increase_alignment_p () && align
<= MAX_OFILE_ALIGNMENT
);
2427 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2428 (void *)(size_t) align
,
2430 gcc_assert (DECL_ALIGN (decl
) >= align
);
2433 /* Helper for symtab_node::definition_alignment. */
2436 get_alignment_1 (symtab_node
*n
, void *v
)
2438 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2442 /* Return desired alignment of the definition. This is NOT alignment useful
2443 to access THIS, because THIS may be interposable and DECL_ALIGN should
2444 be used instead. It however must be guaranteed when output definition
2448 symtab_node::definition_alignment ()
2450 unsigned int align
= 0;
2451 gcc_assert (!alias
);
2452 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2456 /* Return symbol used to separate symbol name from suffix. */
2459 symbol_table::symbol_suffix_separator ()
2461 #ifndef NO_DOT_IN_LABEL
2463 #elif !defined NO_DOLLAR_IN_LABEL
2470 /* Return true when references to this symbol from REF must bind to current
2471 definition in final executable. */
2474 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2476 if (!definition
&& !in_other_partition
)
2478 if (transparent_alias
)
2480 && get_alias_target()->binds_to_current_def_p (ref
);
2481 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2482 if (cnode
&& cnode
->ifunc_resolver
)
2484 if (decl_binds_to_current_def_p (decl
))
2487 /* Inline clones always binds locally. */
2488 if (cnode
&& cnode
->inlined_to
)
2491 if (DECL_EXTERNAL (decl
))
2494 gcc_assert (externally_visible
);
2498 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2500 ref
= cref
->inlined_to
;
2503 /* If this is a reference from symbol itself and there are no aliases, we
2504 may be sure that the symbol was not interposed by something else because
2505 the symbol itself would be unreachable otherwise. This is important
2506 to optimize recursive functions well.
2508 This assumption may be broken by inlining: if symbol is interposable
2509 but the body is available (i.e. declared inline), inliner may make
2510 the body reachable even with interposition. */
2511 if (this == ref
&& !has_aliases_p ()
2513 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2514 || get_availability () >= AVAIL_INTERPOSABLE
))
2518 /* References within one comdat group are always bound in a group. */
2520 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2521 && get_comdat_group ()
2522 && get_comdat_group () == ref
->get_comdat_group ())
2528 /* Return true if symbol should be output to the symbol table. */
2531 symtab_node::output_to_lto_symbol_table_p (void)
2533 /* Only externally visible symbols matter. */
2534 if (!TREE_PUBLIC (decl
))
2536 if (!real_symbol_p ())
2538 /* FIXME: variables probably should not be considered as real symbols at
2540 if (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
2542 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !definition
2543 && fndecl_built_in_p (decl
))
2545 /* Builtins like those for most math functions have actual implementations
2546 in libraries so make sure to output references into the symbol table to
2547 make those libraries referenced. Note this is incomplete handling for
2548 now and only covers math functions. */
2549 return builtin_with_linkage_p (decl
);
2552 /* We have real symbol that should be in symbol table. However try to trim
2553 down the references to libraries bit more because linker will otherwise
2554 bring unnecessary object files into the final link.
2555 FIXME: The following checks can easily be confused i.e. by self recursive
2556 function or self-referring variable. */
2558 /* We keep external functions in symtab for sake of inlining
2559 and devirtualization. We do not want to see them in symbol table as
2560 references unless they are really used. */
2561 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2562 if (cnode
&& (!definition
|| DECL_EXTERNAL (decl
))
2566 /* Ignore all references from external vars initializers - they are not really
2567 part of the compilation unit until they are used by folding. Some symbols,
2568 like references to external construction vtables cannot be referred to at
2569 all. We decide this at can_refer_decl_in_current_unit_p. */
2570 if (!definition
|| DECL_EXTERNAL (decl
))
2573 struct ipa_ref
*ref
;
2574 for (i
= 0; iterate_referring (i
, ref
); i
++)
2576 if (ref
->use
== IPA_REF_ALIAS
)
2578 if (is_a
<cgraph_node
*> (ref
->referring
))
2580 if (!DECL_EXTERNAL (ref
->referring
->decl
))