2 Copyright (C) 2012-2024 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 of USE_TYPE and
752 associated with statement STMT or LTO_STMT_UID. */
755 symtab_node::find_reference (symtab_node
*referred_node
,
756 gimple
*stmt
, unsigned int lto_stmt_uid
,
757 enum ipa_ref_use use_type
)
762 for (i
= 0; iterate_reference (i
, r
); i
++)
763 if (r
->referred
== referred_node
765 && r
->use
== use_type
766 && ((stmt
&& r
->stmt
== stmt
)
767 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
768 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
773 /* Remove all references that are associated with statement STMT. */
776 symtab_node::remove_stmt_references (gimple
*stmt
)
781 while (iterate_reference (i
, r
))
783 r
->remove_reference ();
788 /* Remove all stmt references in non-speculative references in THIS
790 Those are not maintained during inlining & cloning.
791 The exception are speculative references that are updated along
792 with callgraph edges associated with them. */
795 symtab_node::clear_stmts_in_references (void)
800 for (i
= 0; iterate_reference (i
, r
); i
++)
805 r
->speculative_id
= 0;
807 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
811 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
812 cnode
->clear_stmts_in_references ();
816 /* Remove all references in ref list. */
819 symtab_node::remove_all_references (void)
821 while (ref_list
.references
.length ())
822 ref_list
.references
.last ().remove_reference ();
823 ref_list
.references
.release ();
826 /* Remove all referring items in ref list. */
829 symtab_node::remove_all_referring (void)
831 while (ref_list
.referring
.length ())
832 ref_list
.referring
.last ()->remove_reference ();
833 ref_list
.referring
.release ();
836 /* Dump references in ref list to FILE. */
839 symtab_node::dump_references (FILE *file
)
843 for (i
= 0; iterate_reference (i
, ref
); i
++)
845 fprintf (file
, "%s (%s) ", ref
->referred
->dump_asm_name (),
846 ipa_ref_use_name
[ref
->use
]);
847 if (ref
->speculative
)
848 fprintf (file
, "(speculative) ");
850 fprintf (file
, "\n");
853 /* Dump referring in list to FILE. */
856 symtab_node::dump_referring (FILE *file
)
860 for (i
= 0; iterate_referring(i
, ref
); i
++)
862 fprintf (file
, "%s (%s) ", ref
->referring
->dump_asm_name (),
863 ipa_ref_use_name
[ref
->use
]);
864 if (ref
->speculative
)
865 fprintf (file
, "(speculative) ");
867 fprintf (file
, "\n");
870 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
872 /* Dump the visibility of the symbol. */
875 symtab_node::get_visibility_string () const
877 static const char * const visibility_types
[]
878 = { "default", "protected", "hidden", "internal" };
879 return visibility_types
[DECL_VISIBILITY (decl
)];
882 /* Dump the type_name of the symbol. */
884 symtab_node::get_symtab_type_string () const
886 return symtab_type_names
[type
];
889 /* Dump base fields of symtab nodes to F. Not to be used directly. */
892 symtab_node::dump_base (FILE *f
)
894 static const char * const visibility_types
[] = {
895 "default", "protected", "hidden", "internal"
898 fprintf (f
, "%s (%s)", dump_asm_name (), name ());
899 if (dump_flags
& TDF_ADDRESS
)
900 dump_addr (f
, " @", (void *)this);
901 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
904 fprintf (f
, " definition");
906 fprintf (f
, " analyzed");
908 fprintf (f
, " alias");
909 if (transparent_alias
)
910 fprintf (f
, " transparent_alias");
912 fprintf (f
, " weakref");
914 fprintf (f
, " symver");
915 if (cpp_implicit_alias
)
916 fprintf (f
, " cpp_implicit_alias");
918 fprintf (f
, " target:%s",
919 DECL_P (alias_target
)
920 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
922 : IDENTIFIER_POINTER (alias_target
));
924 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
925 fprintf (f
, "\n Visibility:");
926 if (in_other_partition
)
927 fprintf (f
, " in_other_partition");
928 if (used_from_other_partition
)
929 fprintf (f
, " used_from_other_partition");
931 fprintf (f
, " force_output");
933 fprintf (f
, " forced_by_abi");
934 if (externally_visible
)
935 fprintf (f
, " externally_visible");
936 if (semantic_interposition
)
937 fprintf (f
, " semantic_interposition");
939 fprintf (f
, " no_reorder");
940 if (resolution
!= LDPR_UNKNOWN
)
942 ld_plugin_symbol_resolution_names
[(int)resolution
]);
943 if (TREE_ASM_WRITTEN (decl
))
944 fprintf (f
, " asm_written");
945 if (DECL_EXTERNAL (decl
))
946 fprintf (f
, " external");
947 if (TREE_PUBLIC (decl
))
948 fprintf (f
, " public");
949 if (DECL_COMMON (decl
))
950 fprintf (f
, " common");
951 if (DECL_WEAK (decl
))
952 fprintf (f
, " weak");
953 if (DECL_DLLIMPORT_P (decl
))
954 fprintf (f
, " dll_import");
955 if (DECL_COMDAT (decl
))
956 fprintf (f
, " comdat");
957 if (get_comdat_group ())
958 fprintf (f
, " comdat_group:%s",
959 IDENTIFIER_POINTER (get_comdat_group_id ()));
960 if (DECL_ONE_ONLY (decl
))
961 fprintf (f
, " one_only");
963 fprintf (f
, " section:%s",
965 if (implicit_section
)
966 fprintf (f
," (implicit_section)");
967 if (DECL_VISIBILITY_SPECIFIED (decl
))
968 fprintf (f
, " visibility_specified");
969 if (DECL_VISIBILITY (decl
))
970 fprintf (f
, " visibility:%s",
971 visibility_types
[DECL_VISIBILITY (decl
)]);
972 if (DECL_VIRTUAL_P (decl
))
973 fprintf (f
, " virtual");
974 if (DECL_ARTIFICIAL (decl
))
975 fprintf (f
, " artificial");
976 if (TREE_CODE (decl
) == FUNCTION_DECL
)
978 if (DECL_STATIC_CONSTRUCTOR (decl
))
979 fprintf (f
, " constructor");
980 if (DECL_STATIC_DESTRUCTOR (decl
))
981 fprintf (f
, " destructor");
984 fprintf (f
, " ifunc_resolver");
987 if (same_comdat_group
)
988 fprintf (f
, " Same comdat group as: %s\n",
989 same_comdat_group
->dump_asm_name ());
990 if (next_sharing_asm_name
)
991 fprintf (f
, " next sharing asm name: %i\n",
992 next_sharing_asm_name
->order
);
993 if (previous_sharing_asm_name
)
994 fprintf (f
, " previous sharing asm name: %i\n",
995 previous_sharing_asm_name
->order
);
998 fprintf (f
, " Address is taken.\n");
1001 fprintf (f
, " Aux:");
1002 dump_addr (f
, " @", (void *)aux
);
1006 fprintf (f
, " References: ");
1007 dump_references (f
);
1008 fprintf (f
, " Referring: ");
1011 fprintf (f
, " Read from file: %s\n",
1012 lto_file_data
->file_name
);
1015 /* Dump symtab node to F. */
1018 symtab_node::dump (FILE *f
)
1020 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
1022 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1027 symtab_node::dump_graphviz (FILE *f
)
1029 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
1030 cnode
->dump_graphviz (f
);
1034 symbol_table::dump (FILE *f
)
1037 fprintf (f
, "Symbol table:\n\n");
1038 FOR_EACH_SYMBOL (node
)
1043 symbol_table::dump_graphviz (FILE *f
)
1046 fprintf (f
, "digraph symtab {\n");
1047 FOR_EACH_SYMBOL (node
)
1048 node
->dump_graphviz (f
);
1053 symbol_table::debug (void)
1058 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1059 Return NULL if there's no such node. */
1062 symtab_node::get_for_asmname (const_tree asmname
)
1066 symtab
->symtab_initialize_asm_name_hash ();
1067 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
1069 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
1080 /* Dump symtab node NODE to stderr. */
1083 symtab_node::debug (void)
1088 /* Verify common part of symtab nodes. */
1091 /* Disable warnings about missing quoting in GCC diagnostics for
1092 the verification errors. Their format strings don't follow GCC
1093 diagnostic conventions and the calls are ultimately followed by
1094 one to internal_error. */
1095 # pragma GCC diagnostic push
1096 # pragma GCC diagnostic ignored "-Wformat-diag"
1100 symtab_node::verify_base (void)
1102 bool error_found
= false;
1103 symtab_node
*hashed_node
;
1105 if (is_a
<cgraph_node
*> (this))
1107 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1109 error ("function symbol is not function");
1112 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
))
1114 != dyn_cast
<cgraph_node
*> (this)->ifunc_resolver
)
1116 error ("inconsistent %<ifunc%> attribute");
1120 else if (is_a
<varpool_node
*> (this))
1124 error ("variable symbol is not variable");
1130 error ("node has unknown type");
1133 if (order
< 0 || order
>= symtab
->order
)
1135 error ("node has invalid order %i", order
);
1139 if (symtab
->state
!= LTO_STREAMING
)
1141 hashed_node
= symtab_node::get (decl
);
1144 error ("node not found node->decl->decl_with_vis.symtab_node");
1147 if (hashed_node
!= this
1148 && (!is_a
<cgraph_node
*> (this)
1149 || !dyn_cast
<cgraph_node
*> (this)->clone_of
1150 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1152 error ("node differs from node->decl->decl_with_vis.symtab_node");
1156 if (symtab
->assembler_name_hash
)
1158 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1161 if (hashed_node
->previous_sharing_asm_name
)
1163 error ("assembler name hash list corrupted");
1166 else if (previous_sharing_asm_name
== NULL
)
1168 if (hashed_node
!= this)
1170 error ("assembler name hash list corrupted");
1174 else if (!(is_a
<varpool_node
*> (this) && DECL_HARD_REGISTER (decl
)))
1176 if (!asmname_hasher::equal (previous_sharing_asm_name
,
1177 DECL_ASSEMBLER_NAME (decl
)))
1179 error ("node not found in symtab assembler name hash");
1185 if (previous_sharing_asm_name
1186 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1188 error ("double linked list of assembler names corrupted");
1191 if (body_removed
&& definition
)
1193 error ("node has body_removed but is definition");
1196 if (analyzed
&& !definition
)
1198 error ("node is analyzed but it is not a definition");
1201 if (cpp_implicit_alias
&& !alias
)
1203 error ("node is alias but not implicit alias");
1206 if (alias
&& !definition
&& !weakref
)
1208 error ("node is alias but not definition");
1211 if (weakref
&& !transparent_alias
)
1213 error ("node is weakref but not an transparent_alias");
1216 if (transparent_alias
&& !alias
)
1218 error ("node is transparent_alias but not an alias");
1221 if (symver
&& !alias
)
1223 error ("node is symver but not alias");
1226 /* Limitation of gas requires us to output targets of symver aliases as
1227 global symbols. This is binutils PR 25295. */
1229 && (!TREE_PUBLIC (get_alias_target ()->decl
)
1230 || DECL_VISIBILITY (get_alias_target ()->decl
) != VISIBILITY_DEFAULT
))
1232 error ("symver target is not exported with default visibility");
1236 && (!TREE_PUBLIC (decl
)
1237 || DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
))
1239 error ("symver is not exported with default visibility");
1242 if (same_comdat_group
)
1244 symtab_node
*n
= same_comdat_group
;
1246 if (!n
->get_comdat_group ())
1248 error ("node is in same_comdat_group list but has no comdat_group");
1251 if (n
->get_comdat_group () != get_comdat_group ())
1253 error ("same_comdat_group list across different groups");
1256 if (n
->type
!= type
)
1258 error ("mixing different types of symbol in same comdat groups is not supported");
1263 error ("node is alone in a comdat group");
1268 if (!n
->same_comdat_group
)
1270 error ("same_comdat_group is not a circular list");
1274 n
= n
->same_comdat_group
;
1277 if (comdat_local_p ())
1279 ipa_ref
*ref
= NULL
;
1281 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1283 if (!in_same_comdat_group_p (ref
->referring
))
1285 error ("comdat-local symbol referred to by %s outside its "
1287 identifier_to_locale (ref
->referring
->name()));
1293 if (implicit_section
&& !get_section ())
1295 error ("implicit_section flag is set but section isn%'t");
1298 if (get_section () && get_comdat_group ()
1299 && !implicit_section
1300 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1302 error ("Both section and comdat group is set");
1305 /* TODO: Add string table for sections, so we do not keep holding duplicated
1307 if (alias
&& definition
1308 && get_section () != get_alias_target ()->get_section ()
1310 || !get_alias_target ()->get_section ()
1311 || strcmp (get_section(),
1312 get_alias_target ()->get_section ())))
1314 error ("Alias and target%'s section differs");
1315 get_alias_target ()->dump (stderr
);
1318 if (alias
&& definition
1319 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1321 error ("Alias and target%'s comdat groups differs");
1322 get_alias_target ()->dump (stderr
);
1325 if (transparent_alias
&& definition
&& !weakref
)
1327 symtab_node
*to
= get_alias_target ();
1329 = IDENTIFIER_POINTER (
1330 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1332 = IDENTIFIER_POINTER (
1333 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1334 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1336 error ("Transparent alias and target%'s assembler names differs");
1337 get_alias_target ()->dump (stderr
);
1341 if (transparent_alias
&& definition
1342 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1344 error ("Chained transparent aliases");
1345 get_alias_target ()->dump (stderr
);
1352 /* Verify consistency of NODE. */
1355 symtab_node::verify (void)
1360 timevar_push (TV_CGRAPH_VERIFY
);
1361 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1362 node
->verify_node ();
1367 internal_error ("symtab_node::verify failed");
1369 timevar_pop (TV_CGRAPH_VERIFY
);
1372 /* Return true and set *DATA to true if NODE is an ifunc resolver. */
1375 check_ifunc_resolver (cgraph_node
*node
, void *data
)
1377 if (node
->ifunc_resolver
)
1379 bool *is_ifunc_resolver
= (bool *) data
;
1380 *is_ifunc_resolver
= true;
1386 static bitmap ifunc_ref_map
;
1388 /* Return true if any caller of NODE is an ifunc resolver. */
1391 is_caller_ifunc_resolver (cgraph_node
*node
)
1393 bool is_ifunc_resolver
= false;
1395 for (cgraph_edge
*e
= node
->callers
; e
; e
= e
->next_caller
)
1397 /* Return true if caller is known to be an IFUNC resolver. */
1398 if (e
->caller
->called_by_ifunc_resolver
)
1401 /* Check for recursive call. */
1402 if (e
->caller
== node
)
1405 /* Skip if it has been visited. */
1406 unsigned int uid
= e
->caller
->get_uid ();
1407 if (!bitmap_set_bit (ifunc_ref_map
, uid
))
1410 if (is_caller_ifunc_resolver (e
->caller
))
1412 /* Return true if caller is an IFUNC resolver. */
1413 e
->caller
->called_by_ifunc_resolver
= true;
1417 /* Check if caller's alias is an IFUNC resolver. */
1418 e
->caller
->call_for_symbol_and_aliases (check_ifunc_resolver
,
1421 if (is_ifunc_resolver
)
1423 /* Return true if caller's alias is an IFUNC resolver. */
1424 e
->caller
->called_by_ifunc_resolver
= true;
1432 /* Check symbol table for callees of IFUNC resolvers. */
1435 symtab_node::check_ifunc_callee_symtab_nodes (void)
1439 bitmap_obstack_initialize (NULL
);
1440 ifunc_ref_map
= BITMAP_ALLOC (NULL
);
1442 FOR_EACH_SYMBOL (node
)
1444 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
1448 unsigned int uid
= cnode
->get_uid ();
1449 if (bitmap_bit_p (ifunc_ref_map
, uid
))
1451 bitmap_set_bit (ifunc_ref_map
, uid
);
1453 bool is_ifunc_resolver
= false;
1454 cnode
->call_for_symbol_and_aliases (check_ifunc_resolver
,
1455 &is_ifunc_resolver
, true);
1456 if (is_ifunc_resolver
|| is_caller_ifunc_resolver (cnode
))
1457 cnode
->called_by_ifunc_resolver
= true;
1460 BITMAP_FREE (ifunc_ref_map
);
1461 bitmap_obstack_release (NULL
);
1464 /* Verify symbol table for internal consistency. */
1467 symtab_node::verify_symtab_nodes (void)
1470 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1473 for (anode
= symtab
->first_asm_symbol (); anode
; anode
= anode
->next
)
1474 if (anode
->order
< 0 || anode
->order
>= symtab
->order
)
1476 error ("invalid order in asm node %i", anode
->order
);
1477 internal_error ("symtab_node::verify failed");
1480 FOR_EACH_SYMBOL (node
)
1483 if (node
->get_comdat_group ())
1485 symtab_node
**entry
, *s
;
1488 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1492 else if (!DECL_EXTERNAL (node
->decl
))
1494 for (s
= (*entry
)->same_comdat_group
;
1495 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1496 s
= s
->same_comdat_group
)
1498 if (!s
|| s
== *entry
)
1500 error ("Two symbols with same comdat_group are not linked by "
1501 "the same_comdat_group list.");
1504 internal_error ("symtab_node::verify failed");
1512 # pragma GCC diagnostic pop
1515 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1516 but other code such as notice_global_symbol generates rtl. */
1519 symtab_node::make_decl_local (void)
1526 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1527 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1528 symtab
->change_decl_assembler_name
1529 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1530 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1531 DECL_ATTRIBUTES (decl
));
1533 /* Avoid clearing comdat_groups on comdat-local decls. */
1534 else if (TREE_PUBLIC (decl
) == 0)
1537 /* Localizing a symbol also make all its transparent aliases local. */
1539 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1541 struct symtab_node
*alias
= ref
->referring
;
1542 if (alias
->transparent_alias
)
1543 alias
->make_decl_local ();
1548 DECL_COMMON (decl
) = 0;
1549 /* ADDRESSABLE flag is not defined for public symbols. */
1550 TREE_ADDRESSABLE (decl
) = 1;
1551 TREE_STATIC (decl
) = 1;
1554 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1556 DECL_COMDAT (decl
) = 0;
1557 DECL_WEAK (decl
) = 0;
1558 DECL_EXTERNAL (decl
) = 0;
1559 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1560 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1561 TREE_PUBLIC (decl
) = 0;
1562 DECL_DLLIMPORT_P (decl
) = 0;
1563 if (!DECL_RTL_SET_P (decl
))
1566 /* Update rtl flags. */
1567 make_decl_rtl (decl
);
1569 rtl
= DECL_RTL (decl
);
1573 symbol
= XEXP (rtl
, 0);
1574 if (GET_CODE (symbol
) != SYMBOL_REF
)
1577 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1580 /* Copy visibility from N.
1581 This is useful when THIS becomes a transparent alias of N. */
1584 symtab_node::copy_visibility_from (symtab_node
*n
)
1586 gcc_checking_assert (n
->weakref
== weakref
);
1589 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1591 struct symtab_node
*alias
= ref
->referring
;
1592 if (alias
->transparent_alias
)
1593 alias
->copy_visibility_from (n
);
1598 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1599 /* ADDRESSABLE flag is not defined for public symbols. */
1600 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1601 TREE_ADDRESSABLE (decl
) = 1;
1602 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1604 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1606 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1607 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1608 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1609 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1610 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1611 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1612 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1613 resolution
= n
->resolution
;
1614 set_comdat_group (n
->get_comdat_group ());
1616 externally_visible
= n
->externally_visible
;
1617 if (!DECL_RTL_SET_P (decl
))
1620 /* Update rtl flags. */
1621 make_decl_rtl (decl
);
1623 rtx rtl
= DECL_RTL (decl
);
1627 rtx symbol
= XEXP (rtl
, 0);
1628 if (GET_CODE (symbol
) != SYMBOL_REF
)
1631 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1634 /* Walk the alias chain to return the symbol NODE is alias of.
1635 If NODE is not an alias, return NODE.
1636 Assumes NODE is known to be alias. */
1639 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1642 bool transparent_p
= false;
1644 /* To determine visibility of the target, we follow ELF semantic of aliases.
1645 Here alias is an alternative assembler name of a given definition. Its
1646 availability prevails the availability of its target (i.e. static alias of
1647 weak definition is available.
1649 Transparent alias is just alternative name of a given symbol used within
1650 one compilation unit and is translated prior hitting the object file. It
1651 inherits the visibility of its target.
1652 Weakref is a different animal (and noweak definition is weak).
1654 If we ever get into supporting targets with different semantics, a target
1655 hook will be needed here. */
1659 transparent_p
= transparent_alias
;
1661 *availability
= get_availability (ref
);
1663 *availability
= AVAIL_NOT_AVAILABLE
;
1666 symtab_node
*node
= this;
1669 if (node
->alias
&& node
->analyzed
)
1670 node
= node
->get_alias_target ();
1673 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1675 else if (node
->analyzed
&& !node
->transparent_alias
)
1676 *availability
= node
->get_availability (ref
);
1678 *availability
= AVAIL_NOT_AVAILABLE
;
1681 if (node
&& availability
&& transparent_p
1682 && node
->transparent_alias
)
1684 *availability
= node
->get_availability (ref
);
1685 transparent_p
= false;
1689 *availability
= AVAIL_NOT_AVAILABLE
;
1693 /* C++ FE sometimes change linkage flags after producing same body aliases.
1695 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1696 are obviously equivalent. The way it is doing so is however somewhat
1697 kludgy and interferes with the visibility code. As a result we need to
1698 copy the visibility from the target to get things right. */
1701 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1703 if (is_a
<cgraph_node
*> (this))
1705 DECL_DECLARED_INLINE_P (decl
)
1706 = DECL_DECLARED_INLINE_P (target
->decl
);
1707 DECL_DISREGARD_INLINE_LIMITS (decl
)
1708 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1710 /* FIXME: It is not really clear why those flags should not be copied for
1714 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1715 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1716 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1718 if (TREE_PUBLIC (decl
))
1722 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1723 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1724 group
= target
->get_comdat_group ();
1725 set_comdat_group (group
);
1726 if (group
&& !same_comdat_group
)
1727 add_to_same_comdat_group (target
);
1729 externally_visible
= target
->externally_visible
;
1732 /* Set section, do not recurse into aliases.
1733 When one wants to change section of a symbol and its aliases,
1737 symtab_node::set_section_for_node (const char *section
)
1739 const char *current
= get_section ();
1741 if (current
== section
1742 || (current
&& section
1743 && !strcmp (current
, section
)))
1746 release_section_hash_entry (x_section
);
1750 implicit_section
= false;
1753 if (!symtab
->section_hash
)
1754 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1755 section_hash_entry
**slot
= symtab
->section_hash
->find_slot_with_hash
1756 (section
, htab_hash_string (section
), INSERT
);
1758 x_section
= retain_section_hash_entry (*slot
);
1761 int len
= strlen (section
);
1762 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1763 x_section
->ref_count
= 1;
1764 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1765 memcpy (x_section
->name
, section
, len
+ 1);
1769 /* Set the section of node THIS to be the same as the section
1770 of node OTHER. Keep reference counts of the sections
1771 up-to-date as needed. */
1774 symtab_node::set_section_for_node (const symtab_node
&other
)
1776 if (x_section
== other
.x_section
)
1778 if (get_section () && other
.get_section ())
1779 gcc_checking_assert (strcmp (get_section (), other
.get_section ()) != 0);
1780 release_section_hash_entry (x_section
);
1781 if (other
.x_section
)
1782 x_section
= retain_section_hash_entry (other
.x_section
);
1786 implicit_section
= false;
1790 /* Workers for set_section. */
1793 symtab_node::set_section_from_string (symtab_node
*n
, void *s
)
1795 n
->set_section_for_node ((char *)s
);
1799 /* Set the section of node N to be the same as the section
1803 symtab_node::set_section_from_node (symtab_node
*n
, void *o
)
1805 const symtab_node
&other
= *static_cast<const symtab_node
*> (o
);
1806 n
->set_section_for_node (other
);
1810 /* Set section of symbol and its aliases. */
1813 symtab_node::set_section (const char *section
)
1815 gcc_assert (!this->alias
|| !this->analyzed
);
1816 call_for_symbol_and_aliases
1817 (symtab_node::set_section_from_string
, const_cast<char *>(section
), true);
1821 symtab_node::set_section (const symtab_node
&other
)
1823 call_for_symbol_and_aliases
1824 (symtab_node::set_section_from_node
, const_cast<symtab_node
*>(&other
), true);
1827 /* Return the initialization priority. */
1830 symtab_node::get_init_priority ()
1832 if (!this->in_init_priority_hash
)
1833 return DEFAULT_INIT_PRIORITY
;
1835 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1836 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1839 /* Return the finalization priority. */
1842 cgraph_node::get_fini_priority ()
1844 if (!this->in_init_priority_hash
)
1845 return DEFAULT_INIT_PRIORITY
;
1846 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1847 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1850 /* Return the initialization and finalization priority information for
1851 DECL. If there is no previous priority information, a freshly
1852 allocated structure is returned. */
1854 symbol_priority_map
*
1855 symtab_node::priority_info (void)
1857 if (!symtab
->init_priority_hash
)
1858 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1861 symbol_priority_map
*h
1862 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1865 h
->init
= DEFAULT_INIT_PRIORITY
;
1866 h
->fini
= DEFAULT_INIT_PRIORITY
;
1867 in_init_priority_hash
= true;
1873 /* Set initialization priority to PRIORITY. */
1876 symtab_node::set_init_priority (priority_type priority
)
1878 symbol_priority_map
*h
;
1880 if (is_a
<cgraph_node
*> (this))
1881 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1883 if (priority
== DEFAULT_INIT_PRIORITY
)
1885 gcc_assert (get_init_priority() == priority
);
1888 h
= priority_info ();
1892 /* Set finalization priority to PRIORITY. */
1895 cgraph_node::set_fini_priority (priority_type priority
)
1897 symbol_priority_map
*h
;
1899 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1901 if (priority
== DEFAULT_INIT_PRIORITY
)
1903 gcc_assert (get_fini_priority() == priority
);
1906 h
= priority_info ();
1910 /* Worker for symtab_resolve_alias. */
1913 symtab_node::set_implicit_section (symtab_node
*n
,
1914 void *data ATTRIBUTE_UNUSED
)
1916 n
->implicit_section
= true;
1920 /* Add reference recording that symtab node is alias of TARGET.
1921 The function can fail in the case of aliasing cycles; in this case
1922 it returns false. */
1925 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1929 gcc_assert (!analyzed
&& !ref_list
.references
.length ());
1931 /* Never let cycles to creep into the symbol table alias references;
1932 those will make alias walkers to be infinite. */
1933 for (n
= target
; n
&& n
->alias
;
1934 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1937 if (is_a
<cgraph_node
*> (this))
1938 error ("function %q+D part of alias cycle", decl
);
1939 else if (is_a
<varpool_node
*> (this))
1940 error ("variable %q+D part of alias cycle", decl
);
1947 /* "analyze" the node - i.e. mark the reference. */
1951 transparent
|= transparent_alias
;
1952 transparent_alias
= transparent
;
1954 while (target
->transparent_alias
&& target
->analyzed
)
1955 target
= target
->get_alias_target ();
1956 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1958 /* Add alias into the comdat group of its target unless it is already there. */
1959 if (same_comdat_group
)
1960 remove_from_same_comdat_group ();
1961 set_comdat_group (NULL
);
1962 if (target
->get_comdat_group ())
1963 add_to_same_comdat_group (target
);
1965 if ((get_section () != target
->get_section ()
1966 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1968 error ("section of alias %q+D must match section of its target", decl
);
1970 set_section (*target
);
1971 if (target
->implicit_section
)
1972 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1974 /* Alias targets become redundant after alias is resolved into an reference.
1975 We do not want to keep it around or we would have to mind updating them
1976 when renaming symbols. */
1977 alias_target
= NULL
;
1979 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1980 fixup_same_cpp_alias_visibility (target
);
1982 /* If alias has address taken, so does the target. */
1984 target
->ultimate_alias_target ()->address_taken
= true;
1986 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1987 If alias is transparent, also all transparent aliases of THIS are now
1989 Also merge same comdat group lists. */
1991 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1993 struct symtab_node
*alias_alias
= ref
->referring
;
1994 if (alias_alias
->get_comdat_group ())
1996 alias_alias
->remove_from_same_comdat_group ();
1997 alias_alias
->set_comdat_group (NULL
);
1998 if (target
->get_comdat_group ())
1999 alias_alias
->add_to_same_comdat_group (target
);
2001 if ((!alias_alias
->transparent_alias
2002 && !alias_alias
->symver
)
2005 alias_alias
->remove_all_references ();
2006 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
2013 /* Worker searching noninterposable alias. */
2016 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
2018 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
2020 symtab_node
*fn
= node
->ultimate_alias_target ();
2022 /* Ensure that the alias is well formed this may not be the case
2023 of user defined aliases and currently it is not always the case
2024 of C++ same body aliases (that is a bug). */
2025 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
2026 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
2027 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
2028 && flags_from_decl_or_type (node
->decl
)
2029 != flags_from_decl_or_type (fn
->decl
))
2030 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
2032 *(symtab_node
**)data
= node
;
2038 /* If node cannot be overwriten by static or dynamic linker to point to
2039 different definition, return NODE. Otherwise look for alias with such
2040 property and if none exists, introduce new one. */
2043 symtab_node::noninterposable_alias (void)
2046 symtab_node
*new_node
= NULL
;
2048 /* First try to look up existing alias or base object
2049 (if that is already non-overwritable). */
2050 symtab_node
*node
= ultimate_alias_target ();
2051 gcc_assert (!node
->alias
&& !node
->weakref
);
2052 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
2053 (void *)&new_node
, true);
2057 /* If aliases aren't supported by the assembler, fail. */
2058 if (!TARGET_SUPPORTS_ALIASES
)
2060 else if (lookup_attribute ("target_clones", DECL_ATTRIBUTES (node
->decl
)))
2063 /* Otherwise create a new one. */
2064 new_decl
= copy_node (node
->decl
);
2065 DECL_DLLIMPORT_P (new_decl
) = 0;
2066 tree name
= clone_function_name (node
->decl
, "localalias");
2069 unsigned long num
= 0;
2070 /* In the rare case we already have a localalias, but the above
2071 node->call_for_symbol_and_aliases call didn't find any suitable,
2072 iterate until we find one not used yet. */
2073 while (symtab_node::get_for_asmname (name
))
2074 name
= clone_function_name (node
->decl
, "localalias", num
++);
2076 DECL_NAME (new_decl
) = name
;
2077 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
2078 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
2079 DECL_INITIAL (new_decl
) = NULL
;
2080 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
2081 SET_DECL_RTL (new_decl
, NULL
);
2083 /* Update the properties. */
2084 DECL_EXTERNAL (new_decl
) = 0;
2085 TREE_PUBLIC (new_decl
) = 0;
2086 DECL_COMDAT (new_decl
) = 0;
2087 DECL_WEAK (new_decl
) = 0;
2089 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
2090 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
2091 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
2093 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
2094 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
2095 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
2097 cgraph_node
*new_cnode
= dyn_cast
<cgraph_node
*> (new_node
),
2098 *cnode
= dyn_cast
<cgraph_node
*> (node
);
2100 new_cnode
->unit_id
= cnode
->unit_id
;
2101 new_cnode
->merged_comdat
= cnode
->merged_comdat
;
2102 new_cnode
->merged_extern_inline
= cnode
->merged_extern_inline
;
2106 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
2107 DECL_INITIAL (new_decl
) = error_mark_node
;
2108 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
2110 new_node
->resolve_alias (node
);
2111 gcc_assert (decl_binds_to_current_def_p (new_decl
)
2112 && targetm
.binds_local_p (new_decl
));
2116 /* Return true if symtab node and TARGET represents
2117 semantically equivalent symbols. */
2120 symtab_node::semantically_equivalent_p (symtab_node
*target
)
2122 enum availability avail
;
2126 /* Equivalent functions are equivalent. */
2127 if (decl
== target
->decl
)
2130 /* If symbol is not overwritable by different implementation,
2131 walk to the base object it defines. */
2132 ba
= ultimate_alias_target (&avail
);
2133 if (avail
>= AVAIL_AVAILABLE
)
2140 bb
= target
->ultimate_alias_target (&avail
);
2141 if (avail
>= AVAIL_AVAILABLE
)
2151 /* Classify symbol symtab node for partitioning. */
2153 enum symbol_partitioning_class
2154 symtab_node::get_partitioning_class (void)
2156 /* Inline clones are always duplicated.
2157 This include external declarations. */
2158 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2160 if (DECL_ABSTRACT_P (decl
))
2161 return SYMBOL_EXTERNAL
;
2163 if (cnode
&& (cnode
->inlined_to
|| cnode
->declare_variant_alt
))
2164 return SYMBOL_DUPLICATE
;
2166 /* Transparent aliases are always duplicated. */
2167 if (transparent_alias
)
2168 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
2170 /* External declarations are external. */
2171 if (DECL_EXTERNAL (decl
))
2172 return SYMBOL_EXTERNAL
;
2174 /* Even static aliases of external functions as external. Those can happen
2175 when COMDAT got resolved to non-IL implementation. */
2176 if (alias
&& DECL_EXTERNAL (ultimate_alias_target ()->decl
))
2177 return SYMBOL_EXTERNAL
;
2179 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
2181 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
2182 return SYMBOL_EXTERNAL
;
2183 /* Constant pool references use local symbol names that cannot
2184 be promoted global. We should never put into a constant pool
2185 objects that cannot be duplicated across partitions. */
2186 if (DECL_IN_CONSTANT_POOL (decl
))
2187 return SYMBOL_DUPLICATE
;
2188 if (DECL_HARD_REGISTER (decl
))
2189 return SYMBOL_DUPLICATE
;
2190 gcc_checking_assert (vnode
->definition
);
2192 /* Functions that are cloned may stay in callgraph even if they are unused.
2193 Handle them as external; compute_ltrans_boundary take care to make
2194 proper things to happen (i.e. to make them appear in the boundary but
2195 with body streamed, so clone can me materialized). */
2196 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
2197 return SYMBOL_EXTERNAL
;
2199 /* Linker discardable symbols are duplicated to every use unless they are
2201 if (DECL_ONE_ONLY (decl
)
2204 && !used_from_object_file_p ())
2205 return SYMBOL_DUPLICATE
;
2207 return SYMBOL_PARTITION
;
2210 /* Return true when symbol is known to be non-zero. */
2213 symtab_node::nonzero_address ()
2215 /* Weakrefs may be NULL when their target is not defined. */
2216 if (alias
&& weakref
)
2220 symtab_node
*target
= ultimate_alias_target ();
2222 if (target
->alias
&& target
->weakref
)
2224 /* We cannot recurse to target::nonzero. It is possible that the
2225 target is used only via the alias.
2226 We may walk references and look for strong use, but we do not know
2227 if this strong use will survive to final binary, so be
2229 ??? Maybe we could do the lookup during late optimization that
2230 could be useful to eliminate the NULL pointer checks in LTO
2232 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
2234 if (target
->resolution
!= LDPR_UNKNOWN
2235 && target
->resolution
!= LDPR_UNDEF
2236 && !target
->can_be_discarded_p ()
2237 && flag_delete_null_pointer_checks
)
2245 /* With !flag_delete_null_pointer_checks we assume that symbols may
2246 bind to NULL. This is on by default on embedded targets only.
2248 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2249 linking fails. Important case of WEAK we want to do well are comdats,
2250 which also must be defined somewhere.
2252 When parsing, beware the cases when WEAK attribute is added later. */
2253 if ((!DECL_WEAK (decl
) || DECL_COMDAT (decl
))
2254 && flag_delete_null_pointer_checks
)
2256 refuse_visibility_changes
= true;
2260 /* If target is defined and not extern, we know it will be
2261 output and thus it will bind to non-NULL.
2262 Play safe for flag_delete_null_pointer_checks where weak definition may
2263 be re-defined by NULL. */
2264 if (definition
&& !DECL_EXTERNAL (decl
)
2265 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
2267 if (!DECL_WEAK (decl
))
2268 refuse_visibility_changes
= true;
2272 /* As the last resort, check the resolution info. */
2273 if (resolution
!= LDPR_UNKNOWN
2274 && resolution
!= LDPR_UNDEF
2275 && !can_be_discarded_p ()
2276 && flag_delete_null_pointer_checks
)
2281 /* Return 0 if symbol is known to have different address than S2,
2282 Return 1 if symbol is known to have same address as S2,
2283 return -1 otherwise.
2285 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2286 and S2 is going to be accessed. This eliminates the situations when
2287 either THIS or S2 is NULL and is useful for comparing bases when deciding
2288 about memory aliasing. */
2290 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
2292 enum availability avail1
, avail2
;
2294 /* A Shortcut: equivalent symbols are always equivalent. */
2298 /* Unwind transparent aliases first; those are always equal to their
2300 if (this->transparent_alias
&& this->analyzed
)
2301 return this->get_alias_target ()->equal_address_to (s2
);
2302 while (s2
->transparent_alias
&& s2
->analyzed
)
2303 s2
= s2
->get_alias_target();
2308 /* For non-interposable aliases, lookup and compare their actual definitions.
2309 Also check if the symbol needs to bind to given definition. */
2310 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
2311 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
2312 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
2313 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
2314 bool really_binds_local1
= binds_local1
;
2315 bool really_binds_local2
= binds_local2
;
2317 /* Addresses of vtables and virtual functions cannot be used by user
2318 code and are used only within speculation. In this case we may make
2319 symbol equivalent to its alias even if interposition may break this
2320 rule. Doing so will allow us to turn speculative inlining into
2321 non-speculative more aggressively. */
2322 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
2323 binds_local1
= true;
2324 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
2325 binds_local2
= true;
2327 /* If both definitions are available we know that even if they are bound
2328 to other unit they must be defined same way and therefore we can use
2329 equivalence test. */
2330 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
2331 binds_local1
= binds_local2
= true;
2333 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2335 /* We made use of the fact that alias is not weak. */
2337 refuse_visibility_changes
= true;
2339 s2
->refuse_visibility_changes
= true;
2343 /* If both symbols may resolve to NULL, we cannot really prove them
2345 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2348 /* Except for NULL, functions and variables never overlap. */
2349 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2352 /* If one of the symbols is unresolved alias, punt. */
2353 if (rs1
->alias
|| rs2
->alias
)
2356 /* If we have a non-interposable definition of at least one of the symbols
2357 and the other symbol is different, we know other unit cannot interpose
2358 it to the first symbol; all aliases of the definition needs to be
2359 present in the current unit. */
2360 if (((really_binds_local1
|| really_binds_local2
)
2361 /* If we have both definitions and they are different, we know they
2362 will be different even in units they binds to. */
2363 || (binds_local1
&& binds_local2
))
2366 /* We make use of the fact that one symbol is not alias of the other
2367 and that the definition is non-interposable. */
2368 refuse_visibility_changes
= true;
2369 s2
->refuse_visibility_changes
= true;
2370 rs1
->refuse_visibility_changes
= true;
2371 rs2
->refuse_visibility_changes
= true;
2378 /* If the FE tells us at least one of the decls will never be aliased nor
2379 overlapping with other vars in some other way, return 0. */
2381 && (lookup_attribute ("non overlapping", DECL_ATTRIBUTES (decl
))
2382 || lookup_attribute ("non overlapping", DECL_ATTRIBUTES (s2
->decl
))))
2385 /* TODO: Alias oracle basically assume that addresses of global variables
2386 are different unless they are declared as alias of one to another while
2387 the code folding comparisons doesn't.
2388 We probably should be consistent and use this fact here, too, but for
2389 the moment return false only when we are called from the alias oracle.
2390 Return 0 in C constant initializers and C++ manifestly constant
2391 expressions, the likelyhood that different vars will be aliases is
2392 small and returning -1 lets us reject too many initializers. */
2393 if (memory_accessed
|| folding_initializer
)
2399 /* Worker for call_for_symbol_and_aliases. */
2402 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2405 bool include_overwritable
)
2408 FOR_EACH_ALIAS (this, ref
)
2410 symtab_node
*alias
= ref
->referring
;
2411 if (include_overwritable
2412 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2413 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2414 include_overwritable
))
2420 /* Return true if address of N is possibly compared. */
2423 address_matters_1 (symtab_node
*n
, void *)
2425 struct ipa_ref
*ref
;
2427 if (!n
->address_can_be_compared_p ())
2429 if (n
->externally_visible
|| n
->force_output
)
2432 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2433 if (ref
->address_matters_p ())
2438 /* Return true if symbol's address may possibly be compared to other
2439 symbol's address. */
2442 symtab_node::address_matters_p ()
2444 gcc_assert (!alias
);
2445 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2448 /* Return true if symbol's alignment may be increased. */
2451 symtab_node::can_increase_alignment_p (void)
2453 symtab_node
*target
= ultimate_alias_target ();
2455 /* For now support only variables. */
2459 /* With -fno-toplevel-reorder we may have already output the constant. */
2460 if (TREE_ASM_WRITTEN (target
->decl
))
2463 /* If target is already placed in an anchor, we cannot touch its
2465 if (DECL_RTL_SET_P (target
->decl
)
2466 && MEM_P (DECL_RTL (target
->decl
))
2467 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2470 /* Constant pool entries may be shared. */
2471 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2474 /* We cannot change alignment of symbols that may bind to symbols
2475 in other translation unit that may contain a definition with lower
2477 if (!decl_binds_to_current_def_p (decl
))
2480 /* When compiling partition, be sure the symbol is not output by other
2483 && (target
->in_other_partition
2484 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2487 /* Do not override the alignment as specified by the ABI when the used
2488 attribute is set. */
2489 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2492 /* Do not override explicit alignment set by the user when an explicit
2493 section name is also used. This is a common idiom used by many
2494 software projects. */
2495 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2501 /* Worker for symtab_node::increase_alignment. */
2504 increase_alignment_1 (symtab_node
*n
, void *v
)
2506 unsigned int align
= (size_t)v
;
2507 if (DECL_ALIGN (n
->decl
) < align
2508 && n
->can_increase_alignment_p ())
2510 SET_DECL_ALIGN (n
->decl
, align
);
2511 DECL_USER_ALIGN (n
->decl
) = 1;
2516 /* Increase alignment of THIS to ALIGN. */
2519 symtab_node::increase_alignment (unsigned int align
)
2521 gcc_assert (can_increase_alignment_p () && align
<= MAX_OFILE_ALIGNMENT
);
2522 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2523 (void *)(size_t) align
,
2525 gcc_assert (DECL_ALIGN (decl
) >= align
);
2528 /* Helper for symtab_node::definition_alignment. */
2531 get_alignment_1 (symtab_node
*n
, void *v
)
2533 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2537 /* Return desired alignment of the definition. This is NOT alignment useful
2538 to access THIS, because THIS may be interposable and DECL_ALIGN should
2539 be used instead. It however must be guaranteed when output definition
2543 symtab_node::definition_alignment ()
2545 unsigned int align
= 0;
2546 gcc_assert (!alias
);
2547 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2551 /* Return symbol used to separate symbol name from suffix. */
2554 symbol_table::symbol_suffix_separator ()
2556 #ifndef NO_DOT_IN_LABEL
2558 #elif !defined NO_DOLLAR_IN_LABEL
2565 /* Return true when references to this symbol from REF must bind to current
2566 definition in final executable. */
2569 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2571 if (!definition
&& !in_other_partition
)
2573 if (transparent_alias
)
2575 && get_alias_target()->binds_to_current_def_p (ref
);
2576 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2577 if (cnode
&& cnode
->ifunc_resolver
)
2579 if (decl_binds_to_current_def_p (decl
))
2582 /* Inline clones always binds locally. */
2583 if (cnode
&& cnode
->inlined_to
)
2586 if (DECL_EXTERNAL (decl
))
2589 gcc_assert (externally_visible
);
2593 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2595 ref
= cref
->inlined_to
;
2598 /* If this is a reference from symbol itself and there are no aliases, we
2599 may be sure that the symbol was not interposed by something else because
2600 the symbol itself would be unreachable otherwise. This is important
2601 to optimize recursive functions well.
2603 This assumption may be broken by inlining: if symbol is interposable
2604 but the body is available (i.e. declared inline), inliner may make
2605 the body reachable even with interposition. */
2606 if (this == ref
&& !has_aliases_p ()
2608 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2609 || get_availability () >= AVAIL_INTERPOSABLE
))
2613 /* References within one comdat group are always bound in a group. */
2615 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2616 && get_comdat_group ()
2617 && get_comdat_group () == ref
->get_comdat_group ())
2623 /* Return true if symbol should be output to the symbol table. */
2626 symtab_node::output_to_lto_symbol_table_p (void)
2628 /* Only externally visible symbols matter. */
2629 if (!TREE_PUBLIC (decl
))
2631 if (!real_symbol_p ())
2633 /* FIXME: variables probably should not be considered as real symbols at
2635 if (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
2637 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !definition
2638 && fndecl_built_in_p (decl
))
2640 /* Builtins like those for most math functions have actual implementations
2641 in libraries so make sure to output references into the symbol table to
2642 make those libraries referenced. Note this is incomplete handling for
2643 now and only covers math functions. */
2644 return builtin_with_linkage_p (decl
);
2647 /* We have real symbol that should be in symbol table. However try to trim
2648 down the references to libraries bit more because linker will otherwise
2649 bring unnecessary object files into the final link.
2650 FIXME: The following checks can easily be confused i.e. by self recursive
2651 function or self-referring variable. */
2653 /* We keep external functions in symtab for sake of inlining
2654 and devirtualization. We do not want to see them in symbol table as
2655 references unless they are really used. */
2656 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2657 if (cnode
&& (!definition
|| DECL_EXTERNAL (decl
))
2661 /* Ignore all references from external vars initializers - they are not really
2662 part of the compilation unit until they are used by folding. Some symbols,
2663 like references to external construction vtables cannot be referred to at
2664 all. We decide this at can_refer_decl_in_current_unit_p. */
2665 if (!definition
|| DECL_EXTERNAL (decl
))
2668 struct ipa_ref
*ref
;
2669 for (i
= 0; iterate_referring (i
, ref
); i
++)
2671 if (ref
->use
== IPA_REF_ALIAS
)
2673 if (is_a
<cgraph_node
*> (ref
->referring
))
2675 if (!DECL_EXTERNAL (ref
->referring
->decl
))