2 Copyright (C) 2012-2020 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"
42 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias"};
44 const char * const ld_plugin_symbol_resolution_names
[]=
49 "prevailing_def_ironly",
55 "prevailing_def_ironly_exp"
58 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
59 until we find an identifier that is not itself a transparent alias. */
62 ultimate_transparent_alias_target (tree alias
)
66 while (IDENTIFIER_TRANSPARENT_ALIAS (target
))
68 gcc_checking_assert (TREE_CHAIN (target
));
69 target
= TREE_CHAIN (target
);
71 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
72 && ! TREE_CHAIN (target
));
78 /* Hash asmnames ignoring the user specified marks. */
81 symbol_table::decl_assembler_name_hash (const_tree asmname
)
83 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
85 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
86 size_t ulp_len
= strlen (user_label_prefix
);
90 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
93 return htab_hash_string (decl_str
);
96 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
99 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
103 symbol_table::assembler_names_equal_p (const char *name1
, const char *name2
)
109 size_t ulp_len
= strlen (user_label_prefix
);
115 else if (strncmp (name1
, user_label_prefix
, ulp_len
) == 0)
122 size_t ulp_len
= strlen (user_label_prefix
);
128 else if (strncmp (name2
, user_label_prefix
, ulp_len
) == 0)
133 return !strcmp (name1
, name2
);
138 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
141 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
143 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
144 const char *decl_str
;
145 const char *asmname_str
;
147 if (decl_asmname
== asmname
)
150 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
151 asmname_str
= IDENTIFIER_POINTER (asmname
);
152 return assembler_names_equal_p (decl_str
, asmname_str
);
156 /* Returns nonzero if P1 and P2 are equal. */
158 /* Insert NODE to assembler name hash. */
161 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
164 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
166 gcc_checking_assert (!node
->previous_sharing_asm_name
167 && !node
->next_sharing_asm_name
);
168 if (assembler_name_hash
)
172 tree decl
= node
->decl
;
174 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
176 /* C++ FE can produce decls without associated assembler name and insert
177 them to symtab to hold section or TLS information. */
181 hashval_t hash
= decl_assembler_name_hash (name
);
182 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
183 gcc_assert (*aslot
!= node
);
184 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
186 (*aslot
)->previous_sharing_asm_name
= node
;
189 /* Update also possible inline clones sharing a decl. */
190 cnode
= dyn_cast
<cgraph_node
*> (node
);
191 if (cnode
&& cnode
->clones
&& with_clones
)
192 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
193 if (cnode
->decl
== decl
)
194 insert_to_assembler_name_hash (cnode
, true);
199 /* Remove NODE from assembler name hash. */
202 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
205 if (assembler_name_hash
)
208 tree decl
= node
->decl
;
210 if (node
->next_sharing_asm_name
)
211 node
->next_sharing_asm_name
->previous_sharing_asm_name
212 = node
->previous_sharing_asm_name
;
213 if (node
->previous_sharing_asm_name
)
215 node
->previous_sharing_asm_name
->next_sharing_asm_name
216 = node
->next_sharing_asm_name
;
220 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
226 hashval_t hash
= decl_assembler_name_hash (name
);
227 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
229 gcc_assert (*slot
== node
);
230 if (!node
->next_sharing_asm_name
)
231 assembler_name_hash
->clear_slot (slot
);
233 *slot
= node
->next_sharing_asm_name
;
235 node
->next_sharing_asm_name
= NULL
;
236 node
->previous_sharing_asm_name
= NULL
;
238 /* Update also possible inline clones sharing a decl. */
239 cnode
= dyn_cast
<cgraph_node
*> (node
);
240 if (cnode
&& cnode
->clones
&& with_clones
)
241 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
242 if (cnode
->decl
== decl
)
243 unlink_from_assembler_name_hash (cnode
, true);
247 /* Arrange node to be first in its entry of assembler_name_hash. */
250 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
252 unlink_from_assembler_name_hash (node
, false);
253 insert_to_assembler_name_hash (node
, false);
256 /* Initialize asm name hash unless. */
259 symbol_table::symtab_initialize_asm_name_hash (void)
262 if (!assembler_name_hash
)
264 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
265 FOR_EACH_SYMBOL (node
)
266 insert_to_assembler_name_hash (node
, false);
270 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
273 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
275 symtab_node
*node
= NULL
;
277 /* We can have user ASM names on things, like global register variables, that
278 are not in the symbol table. */
279 if ((VAR_P (decl
) && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
280 || TREE_CODE (decl
) == FUNCTION_DECL
)
281 node
= symtab_node::get (decl
);
282 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
284 SET_DECL_ASSEMBLER_NAME (decl
, name
);
286 insert_to_assembler_name_hash (node
, true);
290 if (name
== DECL_ASSEMBLER_NAME (decl
))
293 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
297 unlink_from_assembler_name_hash (node
, true);
299 const char *old_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
300 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
301 && DECL_RTL_SET_P (decl
))
302 warning (0, "%qD renamed after being referenced in assembly", decl
);
304 SET_DECL_ASSEMBLER_NAME (decl
, name
);
307 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
308 TREE_CHAIN (name
) = alias
;
310 /* If we change assembler name, also all transparent aliases must
311 be updated. There are three kinds - those having same assembler name,
312 those being renamed in varasm.c and weakref being renamed by the
316 insert_to_assembler_name_hash (node
, true);
318 for (unsigned i
= 0; node
->iterate_direct_aliases (i
, ref
); i
++)
320 struct symtab_node
*alias
= ref
->referring
;
321 if (alias
->transparent_alias
&& !alias
->weakref
322 && symbol_table::assembler_names_equal_p
323 (old_name
, IDENTIFIER_POINTER (
324 DECL_ASSEMBLER_NAME (alias
->decl
))))
325 change_decl_assembler_name (alias
->decl
, name
);
326 else if (alias
->transparent_alias
327 && IDENTIFIER_TRANSPARENT_ALIAS (alias
->decl
))
329 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
))
330 && IDENTIFIER_TRANSPARENT_ALIAS
331 (DECL_ASSEMBLER_NAME (alias
->decl
)));
333 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
)) =
334 ultimate_transparent_alias_target
335 (DECL_ASSEMBLER_NAME (node
->decl
));
337 #ifdef ASM_OUTPUT_WEAKREF
338 else gcc_assert (!alias
->transparent_alias
|| alias
->weakref
);
340 else gcc_assert (!alias
->transparent_alias
);
343 gcc_assert (!node
->transparent_alias
|| !node
->definition
345 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
346 || symbol_table::assembler_names_equal_p
347 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
350 (node
->get_alias_target ()->decl
))));
355 /* Hash sections by their names. */
358 section_name_hasher::hash (section_hash_entry
*n
)
360 return htab_hash_string (n
->name
);
363 /* Return true if section P1 name equals to P2. */
366 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
368 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
371 /* Add node into symbol table. This function is not used directly, but via
372 cgraph/varpool node creation routines. */
375 symtab_node::register_symbol (void)
377 symtab
->register_symbol (this);
379 if (!decl
->decl_with_vis
.symtab_node
)
380 decl
->decl_with_vis
.symtab_node
= this;
384 /* Be sure to do this last; C++ FE might create new nodes via
385 DECL_ASSEMBLER_NAME langhook! */
386 symtab
->insert_to_assembler_name_hash (this, false);
389 /* Remove NODE from same comdat group. */
392 symtab_node::remove_from_same_comdat_group (void)
394 if (same_comdat_group
)
397 for (prev
= same_comdat_group
;
398 prev
->same_comdat_group
!= this;
399 prev
= prev
->same_comdat_group
)
401 if (same_comdat_group
== prev
)
402 prev
->same_comdat_group
= NULL
;
404 prev
->same_comdat_group
= same_comdat_group
;
405 same_comdat_group
= NULL
;
406 set_comdat_group (NULL
);
410 /* Remove node from symbol table. This function is not used directly, but via
411 cgraph/varpool node removal routines. */
414 symtab_node::unregister (void)
416 remove_all_references ();
417 remove_all_referring ();
419 /* Remove reference to section. */
420 set_section_for_node (NULL
);
422 remove_from_same_comdat_group ();
424 symtab
->unregister (this);
426 /* During LTO symtab merging we temporarily corrupt decl to symtab node
428 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
429 if (decl
->decl_with_vis
.symtab_node
== this)
431 symtab_node
*replacement_node
= NULL
;
432 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
433 replacement_node
= cnode
->find_replacement ();
434 decl
->decl_with_vis
.symtab_node
= replacement_node
;
436 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
437 symtab
->unlink_from_assembler_name_hash (this, false);
438 if (in_init_priority_hash
)
439 symtab
->init_priority_hash
->remove (this);
443 /* Remove symbol from symbol table. */
446 symtab_node::remove (void)
448 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
450 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
454 /* Add NEW_ to the same comdat group that OLD is in. */
457 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
459 gcc_assert (old_node
->get_comdat_group ());
460 gcc_assert (!same_comdat_group
);
461 gcc_assert (this != old_node
);
463 set_comdat_group (old_node
->get_comdat_group ());
464 same_comdat_group
= old_node
;
465 if (!old_node
->same_comdat_group
)
466 old_node
->same_comdat_group
= this;
470 for (n
= old_node
->same_comdat_group
;
471 n
->same_comdat_group
!= old_node
;
472 n
= n
->same_comdat_group
)
474 n
->same_comdat_group
= this;
478 /* Dissolve the same_comdat_group list in which NODE resides. */
481 symtab_node::dissolve_same_comdat_group_list (void)
483 symtab_node
*n
= this;
486 if (!same_comdat_group
)
490 next
= n
->same_comdat_group
;
491 n
->same_comdat_group
= NULL
;
492 if (dyn_cast
<cgraph_node
*> (n
))
493 dyn_cast
<cgraph_node
*> (n
)->calls_comdat_local
= false;
494 /* Clear comdat_group for comdat locals, since
495 make_decl_local doesn't. */
496 if (!TREE_PUBLIC (n
->decl
))
497 n
->set_comdat_group (NULL
);
503 /* Return printable assembler name of NODE.
504 This function is used only for debugging. When assembler name
505 is unknown go with identifier name. */
508 symtab_node::asm_name () const
510 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
512 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
515 /* Return printable identifier name. */
518 symtab_node::name () const
520 if (!DECL_NAME (decl
))
522 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
527 return lang_hooks
.decl_printable_name (decl
, 2);
531 symtab_node::get_dump_name (bool asm_name_p
) const
534 const char *fname
= asm_name_p
? asm_name () : name ();
535 unsigned l
= strlen (fname
);
537 char *s
= (char *)ggc_internal_cleared_alloc (l
+ EXTRA
);
538 snprintf (s
, l
+ EXTRA
, "%s/%d", fname
, order
);
544 symtab_node::dump_name () const
546 return get_dump_name (false);
550 symtab_node::dump_asm_name () const
552 return get_dump_name (true);
555 /* Return ipa reference from this symtab_node to
556 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
560 symtab_node::create_reference (symtab_node
*referred_node
,
561 enum ipa_ref_use use_type
)
563 return create_reference (referred_node
, use_type
, NULL
);
567 /* Return ipa reference from this symtab_node to
568 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
569 of the use and STMT the statement (if it exists). */
572 symtab_node::create_reference (symtab_node
*referred_node
,
573 enum ipa_ref_use use_type
, gimple
*stmt
)
575 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
576 ipa_ref_list
*list
, *list2
;
577 ipa_ref_t
*old_references
;
579 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
580 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
583 old_references
= vec_safe_address (list
->references
);
584 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1);
585 ref
= &list
->references
->last ();
587 list2
= &referred_node
->ref_list
;
589 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
590 if(use_type
== IPA_REF_ALIAS
)
592 list2
->referring
.safe_insert (0, ref
);
593 ref
->referred_index
= 0;
595 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
596 list2
->referring
[i
]->referred_index
= i
;
600 list2
->referring
.safe_push (ref
);
601 ref
->referred_index
= list2
->referring
.length () - 1;
604 ref
->referring
= this;
605 ref
->referred
= referred_node
;
607 ref
->lto_stmt_uid
= 0;
608 ref
->speculative_id
= 0;
610 ref
->speculative
= 0;
612 /* If vector was moved in memory, update pointers. */
613 if (old_references
!= list
->references
->address ())
616 for (i
= 0; iterate_reference(i
, ref2
); i
++)
617 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
623 symtab_node::maybe_create_reference (tree val
, gimple
*stmt
)
626 ipa_ref_use use_type
;
628 switch (TREE_CODE (val
))
631 use_type
= IPA_REF_LOAD
;
634 use_type
= IPA_REF_ADDR
;
637 gcc_assert (!handled_component_p (val
));
641 val
= get_base_var (val
);
642 if (val
&& VAR_OR_FUNCTION_DECL_P (val
))
644 symtab_node
*referred
= symtab_node::get (val
);
645 gcc_checking_assert (referred
);
646 return create_reference (referred
, use_type
, stmt
);
651 /* Clone all references from symtab NODE to this symtab_node. */
654 symtab_node::clone_references (symtab_node
*node
)
656 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
658 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
660 bool speculative
= ref
->speculative
;
661 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
663 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
664 ref2
->speculative
= speculative
;
665 ref2
->lto_stmt_uid
= stmt_uid
;
666 ref2
->speculative_id
= ref
->speculative_id
;
670 /* Clone all referring from symtab NODE to this symtab_node. */
673 symtab_node::clone_referring (symtab_node
*node
)
675 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
677 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
679 bool speculative
= ref
->speculative
;
680 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
682 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
683 ref2
->speculative
= speculative
;
684 ref2
->lto_stmt_uid
= stmt_uid
;
685 ref2
->speculative_id
= ref
->speculative_id
;
689 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
692 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
694 bool speculative
= ref
->speculative
;
695 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
698 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
699 ref2
->speculative
= speculative
;
700 ref2
->lto_stmt_uid
= stmt_uid
;
701 ref2
->speculative_id
= ref
->speculative_id
;
705 /* Find the structure describing a reference to REFERRED_NODE
706 and associated with statement STMT. */
709 symtab_node::find_reference (symtab_node
*referred_node
,
710 gimple
*stmt
, unsigned int lto_stmt_uid
)
715 for (i
= 0; iterate_reference (i
, r
); i
++)
716 if (r
->referred
== referred_node
718 && ((stmt
&& r
->stmt
== stmt
)
719 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
720 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
725 /* Remove all references that are associated with statement STMT. */
728 symtab_node::remove_stmt_references (gimple
*stmt
)
733 while (iterate_reference (i
, r
))
735 r
->remove_reference ();
740 /* Remove all stmt references in non-speculative references.
741 Those are not maintained during inlining & cloning.
742 The exception are speculative references that are updated along
743 with callgraph edges associated with them. */
746 symtab_node::clear_stmts_in_references (void)
751 for (i
= 0; iterate_reference (i
, r
); i
++)
756 r
->speculative_id
= 0;
760 /* Remove all references in ref list. */
763 symtab_node::remove_all_references (void)
765 while (vec_safe_length (ref_list
.references
))
766 ref_list
.references
->last ().remove_reference ();
767 vec_free (ref_list
.references
);
770 /* Remove all referring items in ref list. */
773 symtab_node::remove_all_referring (void)
775 while (ref_list
.referring
.length ())
776 ref_list
.referring
.last ()->remove_reference ();
777 ref_list
.referring
.release ();
780 /* Dump references in ref list to FILE. */
783 symtab_node::dump_references (FILE *file
)
787 for (i
= 0; iterate_reference (i
, ref
); i
++)
789 fprintf (file
, "%s (%s)",
790 ref
->referred
->dump_asm_name (),
791 ipa_ref_use_name
[ref
->use
]);
792 if (ref
->speculative
)
793 fprintf (file
, " (speculative)");
795 fprintf (file
, "\n");
798 /* Dump referring in list to FILE. */
801 symtab_node::dump_referring (FILE *file
)
805 for (i
= 0; iterate_referring(i
, ref
); i
++)
807 fprintf (file
, "%s (%s)",
808 ref
->referring
->dump_asm_name (),
809 ipa_ref_use_name
[ref
->use
]);
810 if (ref
->speculative
)
811 fprintf (file
, " (speculative)");
813 fprintf (file
, "\n");
816 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
818 /* Dump the visibility of the symbol. */
821 symtab_node::get_visibility_string () const
823 static const char * const visibility_types
[]
824 = { "default", "protected", "hidden", "internal" };
825 return visibility_types
[DECL_VISIBILITY (decl
)];
828 /* Dump the type_name of the symbol. */
830 symtab_node::get_symtab_type_string () const
832 return symtab_type_names
[type
];
835 /* Dump base fields of symtab nodes to F. Not to be used directly. */
838 symtab_node::dump_base (FILE *f
)
840 static const char * const visibility_types
[] = {
841 "default", "protected", "hidden", "internal"
844 fprintf (f
, "%s (%s)", dump_asm_name (), name ());
845 dump_addr (f
, " @", (void *)this);
846 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
849 fprintf (f
, " definition");
851 fprintf (f
, " analyzed");
853 fprintf (f
, " alias");
854 if (transparent_alias
)
855 fprintf (f
, " transparent_alias");
857 fprintf (f
, " weakref");
859 fprintf (f
, " symver");
860 if (cpp_implicit_alias
)
861 fprintf (f
, " cpp_implicit_alias");
863 fprintf (f
, " target:%s",
864 DECL_P (alias_target
)
865 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
867 : IDENTIFIER_POINTER (alias_target
));
869 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
870 fprintf (f
, "\n Visibility:");
871 if (in_other_partition
)
872 fprintf (f
, " in_other_partition");
873 if (used_from_other_partition
)
874 fprintf (f
, " used_from_other_partition");
876 fprintf (f
, " force_output");
878 fprintf (f
, " forced_by_abi");
879 if (externally_visible
)
880 fprintf (f
, " externally_visible");
882 fprintf (f
, " no_reorder");
883 if (resolution
!= LDPR_UNKNOWN
)
885 ld_plugin_symbol_resolution_names
[(int)resolution
]);
886 if (TREE_ASM_WRITTEN (decl
))
887 fprintf (f
, " asm_written");
888 if (DECL_EXTERNAL (decl
))
889 fprintf (f
, " external");
890 if (TREE_PUBLIC (decl
))
891 fprintf (f
, " public");
892 if (DECL_COMMON (decl
))
893 fprintf (f
, " common");
894 if (DECL_WEAK (decl
))
895 fprintf (f
, " weak");
896 if (DECL_DLLIMPORT_P (decl
))
897 fprintf (f
, " dll_import");
898 if (DECL_COMDAT (decl
))
899 fprintf (f
, " comdat");
900 if (get_comdat_group ())
901 fprintf (f
, " comdat_group:%s",
902 IDENTIFIER_POINTER (get_comdat_group_id ()));
903 if (DECL_ONE_ONLY (decl
))
904 fprintf (f
, " one_only");
906 fprintf (f
, " section:%s",
908 if (implicit_section
)
909 fprintf (f
," (implicit_section)");
910 if (DECL_VISIBILITY_SPECIFIED (decl
))
911 fprintf (f
, " visibility_specified");
912 if (DECL_VISIBILITY (decl
))
913 fprintf (f
, " visibility:%s",
914 visibility_types
[DECL_VISIBILITY (decl
)]);
915 if (DECL_VIRTUAL_P (decl
))
916 fprintf (f
, " virtual");
917 if (DECL_ARTIFICIAL (decl
))
918 fprintf (f
, " artificial");
919 if (TREE_CODE (decl
) == FUNCTION_DECL
)
921 if (DECL_STATIC_CONSTRUCTOR (decl
))
922 fprintf (f
, " constructor");
923 if (DECL_STATIC_DESTRUCTOR (decl
))
924 fprintf (f
, " destructor");
927 fprintf (f
, " ifunc_resolver");
930 if (same_comdat_group
)
931 fprintf (f
, " Same comdat group as: %s\n",
932 same_comdat_group
->dump_asm_name ());
933 if (next_sharing_asm_name
)
934 fprintf (f
, " next sharing asm name: %i\n",
935 next_sharing_asm_name
->order
);
936 if (previous_sharing_asm_name
)
937 fprintf (f
, " previous sharing asm name: %i\n",
938 previous_sharing_asm_name
->order
);
941 fprintf (f
, " Address is taken.\n");
944 fprintf (f
, " Aux:");
945 dump_addr (f
, " @", (void *)aux
);
949 fprintf (f
, " References: ");
951 fprintf (f
, " Referring: ");
954 fprintf (f
, " Read from file: %s\n",
955 lto_file_data
->file_name
);
958 /* Dump symtab node to F. */
961 symtab_node::dump (FILE *f
)
963 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
965 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
970 symtab_node::dump_graphviz (FILE *f
)
972 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
973 cnode
->dump_graphviz (f
);
977 symbol_table::dump (FILE *f
)
980 fprintf (f
, "Symbol table:\n\n");
981 FOR_EACH_SYMBOL (node
)
986 symbol_table::dump_graphviz (FILE *f
)
989 fprintf (f
, "digraph symtab {\n");
990 FOR_EACH_SYMBOL (node
)
991 node
->dump_graphviz (f
);
996 symbol_table::debug (void)
1001 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1002 Return NULL if there's no such node. */
1005 symtab_node::get_for_asmname (const_tree asmname
)
1009 symtab
->symtab_initialize_asm_name_hash ();
1010 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
1012 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
1023 /* Dump symtab node NODE to stderr. */
1026 symtab_node::debug (void)
1031 /* Verify common part of symtab nodes. */
1034 /* Disable warnings about missing quoting in GCC diagnostics for
1035 the verification errors. Their format strings don't follow GCC
1036 diagnostic conventions and the calls are ultimately followed by
1037 one to internal_error. */
1038 # pragma GCC diagnostic push
1039 # pragma GCC diagnostic ignored "-Wformat-diag"
1043 symtab_node::verify_base (void)
1045 bool error_found
= false;
1046 symtab_node
*hashed_node
;
1048 if (is_a
<cgraph_node
*> (this))
1050 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1052 error ("function symbol is not function");
1055 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
))
1057 != dyn_cast
<cgraph_node
*> (this)->ifunc_resolver
)
1059 error ("inconsistent %<ifunc%> attribute");
1063 else if (is_a
<varpool_node
*> (this))
1067 error ("variable symbol is not variable");
1073 error ("node has unknown type");
1077 if (symtab
->state
!= LTO_STREAMING
)
1079 hashed_node
= symtab_node::get (decl
);
1082 error ("node not found node->decl->decl_with_vis.symtab_node");
1085 if (hashed_node
!= this
1086 && (!is_a
<cgraph_node
*> (this)
1087 || !dyn_cast
<cgraph_node
*> (this)->clone_of
1088 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1090 error ("node differs from node->decl->decl_with_vis.symtab_node");
1094 if (symtab
->assembler_name_hash
)
1096 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1099 if (hashed_node
->previous_sharing_asm_name
)
1101 error ("assembler name hash list corrupted");
1104 else if (previous_sharing_asm_name
== NULL
)
1106 if (hashed_node
!= this)
1108 error ("assembler name hash list corrupted");
1112 else if (!(is_a
<varpool_node
*> (this) && DECL_HARD_REGISTER (decl
)))
1114 if (!asmname_hasher::equal (previous_sharing_asm_name
,
1115 DECL_ASSEMBLER_NAME (decl
)))
1117 error ("node not found in symtab assembler name hash");
1123 if (previous_sharing_asm_name
1124 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1126 error ("double linked list of assembler names corrupted");
1129 if (body_removed
&& definition
)
1131 error ("node has body_removed but is definition");
1134 if (analyzed
&& !definition
)
1136 error ("node is analyzed but it is not a definition");
1139 if (cpp_implicit_alias
&& !alias
)
1141 error ("node is alias but not implicit alias");
1144 if (alias
&& !definition
&& !weakref
)
1146 error ("node is alias but not definition");
1149 if (weakref
&& !transparent_alias
)
1151 error ("node is weakref but not an transparent_alias");
1154 if (transparent_alias
&& !alias
)
1156 error ("node is transparent_alias but not an alias");
1159 if (symver
&& !alias
)
1161 error ("node is symver but not alias");
1164 /* Limitation of gas requires us to output targets of symver aliases as
1165 global symbols. This is binutils PR 25295. */
1167 && (!TREE_PUBLIC (get_alias_target ()->decl
)
1168 || DECL_VISIBILITY (get_alias_target ()->decl
) != VISIBILITY_DEFAULT
))
1170 error ("symver target is not exported with default visibility");
1174 && (!TREE_PUBLIC (decl
)
1175 || DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
))
1177 error ("symver is not exported with default visibility");
1180 if (same_comdat_group
)
1182 symtab_node
*n
= same_comdat_group
;
1184 if (!n
->get_comdat_group ())
1186 error ("node is in same_comdat_group list but has no comdat_group");
1189 if (n
->get_comdat_group () != get_comdat_group ())
1191 error ("same_comdat_group list across different groups");
1194 if (n
->type
!= type
)
1196 error ("mixing different types of symbol in same comdat groups is not supported");
1201 error ("node is alone in a comdat group");
1206 if (!n
->same_comdat_group
)
1208 error ("same_comdat_group is not a circular list");
1212 n
= n
->same_comdat_group
;
1215 if (comdat_local_p ())
1217 ipa_ref
*ref
= NULL
;
1219 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1221 if (!in_same_comdat_group_p (ref
->referring
))
1223 error ("comdat-local symbol referred to by %s outside its "
1225 identifier_to_locale (ref
->referring
->name()));
1231 if (implicit_section
&& !get_section ())
1233 error ("implicit_section flag is set but section isn%'t");
1236 if (get_section () && get_comdat_group ()
1237 && !implicit_section
1238 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1240 error ("Both section and comdat group is set");
1243 /* TODO: Add string table for sections, so we do not keep holding duplicated
1245 if (alias
&& definition
1246 && get_section () != get_alias_target ()->get_section ()
1248 || !get_alias_target ()->get_section ()
1249 || strcmp (get_section(),
1250 get_alias_target ()->get_section ())))
1252 error ("Alias and target%'s section differs");
1253 get_alias_target ()->dump (stderr
);
1256 if (alias
&& definition
1257 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1259 error ("Alias and target%'s comdat groups differs");
1260 get_alias_target ()->dump (stderr
);
1263 if (transparent_alias
&& definition
&& !weakref
)
1265 symtab_node
*to
= get_alias_target ();
1267 = IDENTIFIER_POINTER (
1268 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1270 = IDENTIFIER_POINTER (
1271 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1272 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1274 error ("Transparent alias and target%'s assembler names differs");
1275 get_alias_target ()->dump (stderr
);
1279 if (transparent_alias
&& definition
1280 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1282 error ("Chained transparent aliases");
1283 get_alias_target ()->dump (stderr
);
1290 /* Verify consistency of NODE. */
1293 symtab_node::verify (void)
1298 timevar_push (TV_CGRAPH_VERIFY
);
1299 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1300 node
->verify_node ();
1305 internal_error ("symtab_node::verify failed");
1307 timevar_pop (TV_CGRAPH_VERIFY
);
1310 /* Verify symbol table for internal consistency. */
1313 symtab_node::verify_symtab_nodes (void)
1316 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1318 FOR_EACH_SYMBOL (node
)
1321 if (node
->get_comdat_group ())
1323 symtab_node
**entry
, *s
;
1326 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1330 else if (!DECL_EXTERNAL (node
->decl
))
1332 for (s
= (*entry
)->same_comdat_group
;
1333 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1334 s
= s
->same_comdat_group
)
1336 if (!s
|| s
== *entry
)
1338 error ("Two symbols with same comdat_group are not linked by "
1339 "the same_comdat_group list.");
1342 internal_error ("symtab_node::verify failed");
1350 # pragma GCC diagnostic pop
1353 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1354 but other code such as notice_global_symbol generates rtl. */
1357 symtab_node::make_decl_local (void)
1364 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1365 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1366 symtab
->change_decl_assembler_name
1367 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1368 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1369 DECL_ATTRIBUTES (decl
));
1371 /* Avoid clearing comdat_groups on comdat-local decls. */
1372 else if (TREE_PUBLIC (decl
) == 0)
1375 /* Localizing a symbol also make all its transparent aliases local. */
1377 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1379 struct symtab_node
*alias
= ref
->referring
;
1380 if (alias
->transparent_alias
)
1381 alias
->make_decl_local ();
1386 DECL_COMMON (decl
) = 0;
1387 /* ADDRESSABLE flag is not defined for public symbols. */
1388 TREE_ADDRESSABLE (decl
) = 1;
1389 TREE_STATIC (decl
) = 1;
1392 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1394 DECL_COMDAT (decl
) = 0;
1395 DECL_WEAK (decl
) = 0;
1396 DECL_EXTERNAL (decl
) = 0;
1397 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1398 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1399 TREE_PUBLIC (decl
) = 0;
1400 DECL_DLLIMPORT_P (decl
) = 0;
1401 if (!DECL_RTL_SET_P (decl
))
1404 /* Update rtl flags. */
1405 make_decl_rtl (decl
);
1407 rtl
= DECL_RTL (decl
);
1411 symbol
= XEXP (rtl
, 0);
1412 if (GET_CODE (symbol
) != SYMBOL_REF
)
1415 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1418 /* Copy visibility from N.
1419 This is useful when THIS becomes a transparent alias of N. */
1422 symtab_node::copy_visibility_from (symtab_node
*n
)
1424 gcc_checking_assert (n
->weakref
== weakref
);
1427 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1429 struct symtab_node
*alias
= ref
->referring
;
1430 if (alias
->transparent_alias
)
1431 alias
->copy_visibility_from (n
);
1436 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1437 /* ADDRESSABLE flag is not defined for public symbols. */
1438 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1439 TREE_ADDRESSABLE (decl
) = 1;
1440 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1442 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1444 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1445 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1446 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1447 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1448 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1449 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1450 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1451 resolution
= n
->resolution
;
1452 set_comdat_group (n
->get_comdat_group ());
1453 call_for_symbol_and_aliases (symtab_node::set_section
,
1454 const_cast<char *>(n
->get_section ()), true);
1455 externally_visible
= n
->externally_visible
;
1456 if (!DECL_RTL_SET_P (decl
))
1459 /* Update rtl flags. */
1460 make_decl_rtl (decl
);
1462 rtx rtl
= DECL_RTL (decl
);
1466 rtx symbol
= XEXP (rtl
, 0);
1467 if (GET_CODE (symbol
) != SYMBOL_REF
)
1470 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1473 /* Walk the alias chain to return the symbol NODE is alias of.
1474 If NODE is not an alias, return NODE.
1475 Assumes NODE is known to be alias. */
1478 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1481 bool transparent_p
= false;
1483 /* To determine visibility of the target, we follow ELF semantic of aliases.
1484 Here alias is an alternative assembler name of a given definition. Its
1485 availability prevails the availability of its target (i.e. static alias of
1486 weak definition is available.
1488 Transparent alias is just alternative name of a given symbol used within
1489 one compilation unit and is translated prior hitting the object file. It
1490 inherits the visibility of its target.
1491 Weakref is a different animal (and noweak definition is weak).
1493 If we ever get into supporting targets with different semantics, a target
1494 hook will be needed here. */
1498 transparent_p
= transparent_alias
;
1500 *availability
= get_availability (ref
);
1502 *availability
= AVAIL_NOT_AVAILABLE
;
1505 symtab_node
*node
= this;
1508 if (node
->alias
&& node
->analyzed
)
1509 node
= node
->get_alias_target ();
1512 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1514 else if (node
->analyzed
&& !node
->transparent_alias
)
1515 *availability
= node
->get_availability (ref
);
1517 *availability
= AVAIL_NOT_AVAILABLE
;
1520 if (node
&& availability
&& transparent_p
1521 && node
->transparent_alias
)
1523 *availability
= node
->get_availability (ref
);
1524 transparent_p
= false;
1528 *availability
= AVAIL_NOT_AVAILABLE
;
1532 /* C++ FE sometimes change linkage flags after producing same body aliases.
1534 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1535 are obviously equivalent. The way it is doing so is however somewhat
1536 kludgy and interferes with the visibility code. As a result we need to
1537 copy the visibility from the target to get things right. */
1540 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1542 if (is_a
<cgraph_node
*> (this))
1544 DECL_DECLARED_INLINE_P (decl
)
1545 = DECL_DECLARED_INLINE_P (target
->decl
);
1546 DECL_DISREGARD_INLINE_LIMITS (decl
)
1547 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1549 /* FIXME: It is not really clear why those flags should not be copied for
1553 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1554 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1555 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1557 if (TREE_PUBLIC (decl
))
1561 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1562 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1563 group
= target
->get_comdat_group ();
1564 set_comdat_group (group
);
1565 if (group
&& !same_comdat_group
)
1566 add_to_same_comdat_group (target
);
1568 externally_visible
= target
->externally_visible
;
1571 /* Set section, do not recurse into aliases.
1572 When one wants to change section of a symbol and its aliases,
1576 symtab_node::set_section_for_node (const char *section
)
1578 const char *current
= get_section ();
1579 section_hash_entry
**slot
;
1581 if (current
== section
1582 || (current
&& section
1583 && !strcmp (current
, section
)))
1588 x_section
->ref_count
--;
1589 if (!x_section
->ref_count
)
1591 hashval_t hash
= htab_hash_string (x_section
->name
);
1592 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1594 ggc_free (x_section
);
1595 symtab
->section_hash
->clear_slot (slot
);
1601 implicit_section
= false;
1604 if (!symtab
->section_hash
)
1605 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1606 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1607 htab_hash_string (section
),
1610 x_section
= (section_hash_entry
*)*slot
;
1613 int len
= strlen (section
);
1614 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1615 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1616 memcpy (x_section
->name
, section
, len
+ 1);
1618 x_section
->ref_count
++;
1621 /* Worker for set_section. */
1624 symtab_node::set_section (symtab_node
*n
, void *s
)
1626 n
->set_section_for_node ((char *)s
);
1630 /* Set section of symbol and its aliases. */
1633 symtab_node::set_section (const char *section
)
1635 gcc_assert (!this->alias
|| !this->analyzed
);
1636 call_for_symbol_and_aliases
1637 (symtab_node::set_section
, const_cast<char *>(section
), true);
1640 /* Return the initialization priority. */
1643 symtab_node::get_init_priority ()
1645 if (!this->in_init_priority_hash
)
1646 return DEFAULT_INIT_PRIORITY
;
1648 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1649 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1652 /* Return the finalization priority. */
1655 cgraph_node::get_fini_priority ()
1657 if (!this->in_init_priority_hash
)
1658 return DEFAULT_INIT_PRIORITY
;
1659 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1660 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1663 /* Return the initialization and finalization priority information for
1664 DECL. If there is no previous priority information, a freshly
1665 allocated structure is returned. */
1667 symbol_priority_map
*
1668 symtab_node::priority_info (void)
1670 if (!symtab
->init_priority_hash
)
1671 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1674 symbol_priority_map
*h
1675 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1678 h
->init
= DEFAULT_INIT_PRIORITY
;
1679 h
->fini
= DEFAULT_INIT_PRIORITY
;
1680 in_init_priority_hash
= true;
1686 /* Set initialization priority to PRIORITY. */
1689 symtab_node::set_init_priority (priority_type priority
)
1691 symbol_priority_map
*h
;
1693 if (is_a
<cgraph_node
*> (this))
1694 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1696 if (priority
== DEFAULT_INIT_PRIORITY
)
1698 gcc_assert (get_init_priority() == priority
);
1701 h
= priority_info ();
1705 /* Set finalization priority to PRIORITY. */
1708 cgraph_node::set_fini_priority (priority_type priority
)
1710 symbol_priority_map
*h
;
1712 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1714 if (priority
== DEFAULT_INIT_PRIORITY
)
1716 gcc_assert (get_fini_priority() == priority
);
1719 h
= priority_info ();
1723 /* Worker for symtab_resolve_alias. */
1726 symtab_node::set_implicit_section (symtab_node
*n
,
1727 void *data ATTRIBUTE_UNUSED
)
1729 n
->implicit_section
= true;
1733 /* Add reference recording that symtab node is alias of TARGET.
1734 The function can fail in the case of aliasing cycles; in this case
1735 it returns false. */
1738 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1742 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1744 /* Never let cycles to creep into the symbol table alias references;
1745 those will make alias walkers to be infinite. */
1746 for (n
= target
; n
&& n
->alias
;
1747 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1750 if (is_a
<cgraph_node
*> (this))
1751 error ("function %q+D part of alias cycle", decl
);
1752 else if (is_a
<varpool_node
*> (this))
1753 error ("variable %q+D part of alias cycle", decl
);
1760 /* "analyze" the node - i.e. mark the reference. */
1764 transparent
|= transparent_alias
;
1765 transparent_alias
= transparent
;
1767 while (target
->transparent_alias
&& target
->analyzed
)
1768 target
= target
->get_alias_target ();
1769 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1771 /* Add alias into the comdat group of its target unless it is already there. */
1772 if (same_comdat_group
)
1773 remove_from_same_comdat_group ();
1774 set_comdat_group (NULL
);
1775 if (target
->get_comdat_group ())
1776 add_to_same_comdat_group (target
);
1778 if ((get_section () != target
->get_section ()
1779 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1781 error ("section of alias %q+D must match section of its target", decl
);
1783 call_for_symbol_and_aliases (symtab_node::set_section
,
1784 const_cast<char *>(target
->get_section ()), true);
1785 if (target
->implicit_section
)
1786 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1788 /* Alias targets become redundant after alias is resolved into an reference.
1789 We do not want to keep it around or we would have to mind updating them
1790 when renaming symbols. */
1791 alias_target
= NULL
;
1793 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1794 fixup_same_cpp_alias_visibility (target
);
1796 /* If alias has address taken, so does the target. */
1798 target
->ultimate_alias_target ()->address_taken
= true;
1800 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1801 If alias is transparent, also all transparent aliases of THIS are now
1803 Also merge same comdat group lists. */
1805 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1807 struct symtab_node
*alias_alias
= ref
->referring
;
1808 if (alias_alias
->get_comdat_group ())
1810 alias_alias
->remove_from_same_comdat_group ();
1811 alias_alias
->set_comdat_group (NULL
);
1812 if (target
->get_comdat_group ())
1813 alias_alias
->add_to_same_comdat_group (target
);
1815 if ((!alias_alias
->transparent_alias
1816 && !alias_alias
->symver
)
1819 alias_alias
->remove_all_references ();
1820 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1827 /* Worker searching noninterposable alias. */
1830 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1832 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1834 symtab_node
*fn
= node
->ultimate_alias_target ();
1836 /* Ensure that the alias is well formed this may not be the case
1837 of user defined aliases and currently it is not always the case
1838 of C++ same body aliases (that is a bug). */
1839 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1840 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1841 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1842 && flags_from_decl_or_type (node
->decl
)
1843 != flags_from_decl_or_type (fn
->decl
))
1844 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1846 *(symtab_node
**)data
= node
;
1852 /* If node cannot be overwriten by static or dynamic linker to point to
1853 different definition, return NODE. Otherwise look for alias with such
1854 property and if none exists, introduce new one. */
1857 symtab_node::noninterposable_alias (void)
1860 symtab_node
*new_node
= NULL
;
1862 /* First try to look up existing alias or base object
1863 (if that is already non-overwritable). */
1864 symtab_node
*node
= ultimate_alias_target ();
1865 gcc_assert (!node
->alias
&& !node
->weakref
);
1866 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1867 (void *)&new_node
, true);
1871 /* If aliases aren't supported by the assembler, fail. */
1872 if (!TARGET_SUPPORTS_ALIASES
)
1875 /* Otherwise create a new one. */
1876 new_decl
= copy_node (node
->decl
);
1877 DECL_DLLIMPORT_P (new_decl
) = 0;
1878 tree name
= clone_function_name (node
->decl
, "localalias");
1881 unsigned long num
= 0;
1882 /* In the rare case we already have a localalias, but the above
1883 node->call_for_symbol_and_aliases call didn't find any suitable,
1884 iterate until we find one not used yet. */
1885 while (symtab_node::get_for_asmname (name
))
1886 name
= clone_function_name (node
->decl
, "localalias", num
++);
1888 DECL_NAME (new_decl
) = name
;
1889 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1890 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1891 DECL_INITIAL (new_decl
) = NULL
;
1892 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1893 SET_DECL_RTL (new_decl
, NULL
);
1895 /* Update the properties. */
1896 DECL_EXTERNAL (new_decl
) = 0;
1897 TREE_PUBLIC (new_decl
) = 0;
1898 DECL_COMDAT (new_decl
) = 0;
1899 DECL_WEAK (new_decl
) = 0;
1901 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1902 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1903 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1905 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1906 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1907 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1909 cgraph_node
*new_cnode
= dyn_cast
<cgraph_node
*> (new_node
),
1910 *cnode
= dyn_cast
<cgraph_node
*> (node
);
1912 new_cnode
->unit_id
= cnode
->unit_id
;
1913 new_cnode
->merged_comdat
= cnode
->merged_comdat
;
1914 new_cnode
->merged_extern_inline
= cnode
->merged_extern_inline
;
1918 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1919 DECL_INITIAL (new_decl
) = error_mark_node
;
1920 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1922 new_node
->resolve_alias (node
);
1923 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1924 && targetm
.binds_local_p (new_decl
));
1928 /* Return true if symtab node and TARGET represents
1929 semantically equivalent symbols. */
1932 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1934 enum availability avail
;
1938 /* Equivalent functions are equivalent. */
1939 if (decl
== target
->decl
)
1942 /* If symbol is not overwritable by different implementation,
1943 walk to the base object it defines. */
1944 ba
= ultimate_alias_target (&avail
);
1945 if (avail
>= AVAIL_AVAILABLE
)
1952 bb
= target
->ultimate_alias_target (&avail
);
1953 if (avail
>= AVAIL_AVAILABLE
)
1963 /* Classify symbol symtab node for partitioning. */
1965 enum symbol_partitioning_class
1966 symtab_node::get_partitioning_class (void)
1968 /* Inline clones are always duplicated.
1969 This include external declarations. */
1970 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
1972 if (DECL_ABSTRACT_P (decl
))
1973 return SYMBOL_EXTERNAL
;
1975 if (cnode
&& cnode
->inlined_to
)
1976 return SYMBOL_DUPLICATE
;
1978 /* Transparent aliases are always duplicated. */
1979 if (transparent_alias
)
1980 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
1982 /* External declarations are external. */
1983 if (DECL_EXTERNAL (decl
))
1984 return SYMBOL_EXTERNAL
;
1986 /* Even static aliases of external functions as external. Those can happen
1987 when COMDAT got resolved to non-IL implementation. */
1988 if (alias
&& DECL_EXTERNAL (ultimate_alias_target ()->decl
))
1989 return SYMBOL_EXTERNAL
;
1991 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1993 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
1994 return SYMBOL_EXTERNAL
;
1995 /* Constant pool references use local symbol names that cannot
1996 be promoted global. We should never put into a constant pool
1997 objects that cannot be duplicated across partitions. */
1998 if (DECL_IN_CONSTANT_POOL (decl
))
1999 return SYMBOL_DUPLICATE
;
2000 if (DECL_HARD_REGISTER (decl
))
2001 return SYMBOL_DUPLICATE
;
2002 gcc_checking_assert (vnode
->definition
);
2004 /* Functions that are cloned may stay in callgraph even if they are unused.
2005 Handle them as external; compute_ltrans_boundary take care to make
2006 proper things to happen (i.e. to make them appear in the boundary but
2007 with body streamed, so clone can me materialized). */
2008 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
2009 return SYMBOL_EXTERNAL
;
2011 /* Linker discardable symbols are duplicated to every use unless they are
2013 if (DECL_ONE_ONLY (decl
)
2016 && !used_from_object_file_p ())
2017 return SYMBOL_DUPLICATE
;
2019 return SYMBOL_PARTITION
;
2022 /* Return true when symbol is known to be non-zero. */
2025 symtab_node::nonzero_address ()
2027 /* Weakrefs may be NULL when their target is not defined. */
2028 if (alias
&& weakref
)
2032 symtab_node
*target
= ultimate_alias_target ();
2034 if (target
->alias
&& target
->weakref
)
2036 /* We cannot recurse to target::nonzero. It is possible that the
2037 target is used only via the alias.
2038 We may walk references and look for strong use, but we do not know
2039 if this strong use will survive to final binary, so be
2041 ??? Maybe we could do the lookup during late optimization that
2042 could be useful to eliminate the NULL pointer checks in LTO
2044 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
2046 if (target
->resolution
!= LDPR_UNKNOWN
2047 && target
->resolution
!= LDPR_UNDEF
2048 && !target
->can_be_discarded_p ()
2049 && flag_delete_null_pointer_checks
)
2057 /* With !flag_delete_null_pointer_checks we assume that symbols may
2058 bind to NULL. This is on by default on embedded targets only.
2060 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2061 linking fails. Important case of WEAK we want to do well are comdats.
2062 Those are handled by later check for definition.
2064 When parsing, beware the cases when WEAK attribute is added later. */
2065 if (!DECL_WEAK (decl
)
2066 && flag_delete_null_pointer_checks
)
2068 refuse_visibility_changes
= true;
2072 /* If target is defined and either comdat or not extern, we know it will be
2073 output and thus it will bind to non-NULL.
2074 Play safe for flag_delete_null_pointer_checks where weak definition may
2075 be re-defined by NULL. */
2076 if (definition
&& (!DECL_EXTERNAL (decl
) || DECL_COMDAT (decl
))
2077 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
2079 if (!DECL_WEAK (decl
))
2080 refuse_visibility_changes
= true;
2084 /* As the last resort, check the resolution info. */
2085 if (resolution
!= LDPR_UNKNOWN
2086 && resolution
!= LDPR_UNDEF
2087 && !can_be_discarded_p ()
2088 && flag_delete_null_pointer_checks
)
2093 /* Return 0 if symbol is known to have different address than S2,
2094 Return 1 if symbol is known to have same address as S2,
2095 return -1 otherwise.
2097 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2098 and S2 is going to be accessed. This eliminates the situations when
2099 either THIS or S2 is NULL and is useful for comparing bases when deciding
2100 about memory aliasing. */
2102 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
2104 enum availability avail1
, avail2
;
2106 /* A Shortcut: equivalent symbols are always equivalent. */
2110 /* Unwind transparent aliases first; those are always equal to their
2112 if (this->transparent_alias
&& this->analyzed
)
2113 return this->get_alias_target ()->equal_address_to (s2
);
2114 while (s2
->transparent_alias
&& s2
->analyzed
)
2115 s2
= s2
->get_alias_target();
2120 /* For non-interposable aliases, lookup and compare their actual definitions.
2121 Also check if the symbol needs to bind to given definition. */
2122 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
2123 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
2124 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
2125 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
2126 bool really_binds_local1
= binds_local1
;
2127 bool really_binds_local2
= binds_local2
;
2129 /* Addresses of vtables and virtual functions cannot be used by user
2130 code and are used only within speculation. In this case we may make
2131 symbol equivalent to its alias even if interposition may break this
2132 rule. Doing so will allow us to turn speculative inlining into
2133 non-speculative more aggressively. */
2134 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
2135 binds_local1
= true;
2136 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
2137 binds_local2
= true;
2139 /* If both definitions are available we know that even if they are bound
2140 to other unit they must be defined same way and therefore we can use
2141 equivalence test. */
2142 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
2143 binds_local1
= binds_local2
= true;
2145 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2147 /* We made use of the fact that alias is not weak. */
2149 refuse_visibility_changes
= true;
2151 s2
->refuse_visibility_changes
= true;
2155 /* If both symbols may resolve to NULL, we cannot really prove them
2157 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2160 /* Except for NULL, functions and variables never overlap. */
2161 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2164 /* If one of the symbols is unresolved alias, punt. */
2165 if (rs1
->alias
|| rs2
->alias
)
2168 /* If we have a non-interposale definition of at least one of the symbols
2169 and the other symbol is different, we know other unit cannot interpose
2170 it to the first symbol; all aliases of the definition needs to be
2171 present in the current unit. */
2172 if (((really_binds_local1
|| really_binds_local2
)
2173 /* If we have both definitions and they are different, we know they
2174 will be different even in units they binds to. */
2175 || (binds_local1
&& binds_local2
))
2178 /* We make use of the fact that one symbol is not alias of the other
2179 and that the definition is non-interposable. */
2180 refuse_visibility_changes
= true;
2181 s2
->refuse_visibility_changes
= true;
2182 rs1
->refuse_visibility_changes
= true;
2183 rs2
->refuse_visibility_changes
= true;
2187 /* TODO: Alias oracle basically assume that addresses of global variables
2188 are different unless they are declared as alias of one to another while
2189 the code folding comparisons doesn't.
2190 We probably should be consistent and use this fact here, too, but for
2191 the moment return false only when we are called from the alias oracle. */
2193 return memory_accessed
&& rs1
!= rs2
? 0 : -1;
2196 /* Worker for call_for_symbol_and_aliases. */
2199 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2202 bool include_overwritable
)
2205 FOR_EACH_ALIAS (this, ref
)
2207 symtab_node
*alias
= ref
->referring
;
2208 if (include_overwritable
2209 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2210 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2211 include_overwritable
))
2217 /* Return true if address of N is possibly compared. */
2220 address_matters_1 (symtab_node
*n
, void *)
2222 struct ipa_ref
*ref
;
2224 if (!n
->address_can_be_compared_p ())
2226 if (n
->externally_visible
|| n
->force_output
)
2229 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2230 if (ref
->address_matters_p ())
2235 /* Return true if symbol's address may possibly be compared to other
2236 symbol's address. */
2239 symtab_node::address_matters_p ()
2241 gcc_assert (!alias
);
2242 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2245 /* Return true if symbol's alignment may be increased. */
2248 symtab_node::can_increase_alignment_p (void)
2250 symtab_node
*target
= ultimate_alias_target ();
2252 /* For now support only variables. */
2256 /* With -fno-toplevel-reorder we may have already output the constant. */
2257 if (TREE_ASM_WRITTEN (target
->decl
))
2260 /* If target is already placed in an anchor, we cannot touch its
2262 if (DECL_RTL_SET_P (target
->decl
)
2263 && MEM_P (DECL_RTL (target
->decl
))
2264 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2267 /* Constant pool entries may be shared. */
2268 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2271 /* We cannot change alignment of symbols that may bind to symbols
2272 in other translation unit that may contain a definition with lower
2274 if (!decl_binds_to_current_def_p (decl
))
2277 /* When compiling partition, be sure the symbol is not output by other
2280 && (target
->in_other_partition
2281 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2284 /* Do not override the alignment as specified by the ABI when the used
2285 attribute is set. */
2286 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2289 /* Do not override explicit alignment set by the user when an explicit
2290 section name is also used. This is a common idiom used by many
2291 software projects. */
2292 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2298 /* Worker for symtab_node::increase_alignment. */
2301 increase_alignment_1 (symtab_node
*n
, void *v
)
2303 unsigned int align
= (size_t)v
;
2304 if (DECL_ALIGN (n
->decl
) < align
2305 && n
->can_increase_alignment_p ())
2307 SET_DECL_ALIGN (n
->decl
, align
);
2308 DECL_USER_ALIGN (n
->decl
) = 1;
2313 /* Increase alignment of THIS to ALIGN. */
2316 symtab_node::increase_alignment (unsigned int align
)
2318 gcc_assert (can_increase_alignment_p () && align
<= MAX_OFILE_ALIGNMENT
);
2319 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2320 (void *)(size_t) align
,
2322 gcc_assert (DECL_ALIGN (decl
) >= align
);
2325 /* Helper for symtab_node::definition_alignment. */
2328 get_alignment_1 (symtab_node
*n
, void *v
)
2330 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2334 /* Return desired alignment of the definition. This is NOT alignment useful
2335 to access THIS, because THIS may be interposable and DECL_ALIGN should
2336 be used instead. It however must be guaranteed when output definition
2340 symtab_node::definition_alignment ()
2342 unsigned int align
= 0;
2343 gcc_assert (!alias
);
2344 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2348 /* Return symbol used to separate symbol name from suffix. */
2351 symbol_table::symbol_suffix_separator ()
2353 #ifndef NO_DOT_IN_LABEL
2355 #elif !defined NO_DOLLAR_IN_LABEL
2362 /* Return true when references to this symbol from REF must bind to current
2363 definition in final executable. */
2366 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2370 if (transparent_alias
)
2372 && get_alias_target()->binds_to_current_def_p (ref
);
2373 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2374 if (cnode
&& cnode
->ifunc_resolver
)
2376 if (decl_binds_to_current_def_p (decl
))
2379 /* Inline clones always binds locally. */
2380 if (cnode
&& cnode
->inlined_to
)
2383 if (DECL_EXTERNAL (decl
))
2386 gcc_assert (externally_visible
);
2390 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2392 ref
= cref
->inlined_to
;
2395 /* If this is a reference from symbol itself and there are no aliases, we
2396 may be sure that the symbol was not interposed by something else because
2397 the symbol itself would be unreachable otherwise. This is important
2398 to optimize recursive functions well.
2400 This assumption may be broken by inlining: if symbol is interposable
2401 but the body is available (i.e. declared inline), inliner may make
2402 the body reachable even with interposition. */
2403 if (this == ref
&& !has_aliases_p ()
2405 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2406 || get_availability () >= AVAIL_INTERPOSABLE
))
2410 /* References within one comdat group are always bound in a group. */
2412 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2413 && get_comdat_group ()
2414 && get_comdat_group () == ref
->get_comdat_group ())
2420 /* Return true if symbol should be output to the symbol table. */
2423 symtab_node::output_to_lto_symbol_table_p (void)
2425 /* Only externally visible symbols matter. */
2426 if (!TREE_PUBLIC (decl
))
2428 if (!real_symbol_p ())
2430 /* FIXME: variables probably should not be considered as real symbols at
2432 if (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
2434 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !definition
2435 && fndecl_built_in_p (decl
))
2437 /* Builtins like those for most math functions have actual implementations
2438 in libraries so make sure to output references into the symbol table to
2439 make those libraries referenced. Note this is incomplete handling for
2440 now and only covers math functions. */
2441 if (builtin_with_linkage_p (decl
))
2447 /* We have real symbol that should be in symbol table. However try to trim
2448 down the references to libraries bit more because linker will otherwise
2449 bring unnecessary object files into the final link.
2450 FIXME: The following checks can easily be confused i.e. by self recursive
2451 function or self-referring variable. */
2453 /* We keep external functions in symtab for sake of inlining
2454 and devirtualization. We do not want to see them in symbol table as
2455 references unless they are really used. */
2456 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2457 if (cnode
&& (!definition
|| DECL_EXTERNAL (decl
))
2461 /* Ignore all references from external vars initializers - they are not really
2462 part of the compilation unit until they are used by folding. Some symbols,
2463 like references to external construction vtables cannot be referred to at
2464 all. We decide this at can_refer_decl_in_current_unit_p. */
2465 if (!definition
|| DECL_EXTERNAL (decl
))
2468 struct ipa_ref
*ref
;
2469 for (i
= 0; iterate_referring (i
, ref
); i
++)
2471 if (ref
->use
== IPA_REF_ALIAS
)
2473 if (is_a
<cgraph_node
*> (ref
->referring
))
2475 if (!DECL_EXTERNAL (ref
->referring
->decl
))