2 Copyright (C) 2012-2016 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"
39 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias","chkp"};
41 const char * const ld_plugin_symbol_resolution_names
[]=
46 "prevailing_def_ironly",
52 "prevailing_def_ironly_exp"
55 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
56 until we find an identifier that is not itself a transparent alias. */
59 ultimate_transparent_alias_target (tree alias
)
63 while (IDENTIFIER_TRANSPARENT_ALIAS (target
))
65 gcc_checking_assert (TREE_CHAIN (target
));
66 target
= TREE_CHAIN (target
);
68 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
69 && ! TREE_CHAIN (target
));
75 /* Hash asmnames ignoring the user specified marks. */
78 symbol_table::decl_assembler_name_hash (const_tree asmname
)
80 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
82 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
83 size_t ulp_len
= strlen (user_label_prefix
);
87 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
90 return htab_hash_string (decl_str
);
93 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
96 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
100 symbol_table::assembler_names_equal_p (const char *name1
, const char *name2
)
106 size_t ulp_len
= strlen (user_label_prefix
);
112 else if (strncmp (name1
, user_label_prefix
, ulp_len
) == 0)
119 size_t ulp_len
= strlen (user_label_prefix
);
125 else if (strncmp (name2
, user_label_prefix
, ulp_len
) == 0)
130 return !strcmp (name1
, name2
);
135 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
138 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
140 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
141 const char *decl_str
;
142 const char *asmname_str
;
144 if (decl_asmname
== asmname
)
147 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
148 asmname_str
= IDENTIFIER_POINTER (asmname
);
149 return assembler_names_equal_p (decl_str
, asmname_str
);
153 /* Returns nonzero if P1 and P2 are equal. */
155 /* Insert NODE to assembler name hash. */
158 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
161 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
163 gcc_checking_assert (!node
->previous_sharing_asm_name
164 && !node
->next_sharing_asm_name
);
165 if (assembler_name_hash
)
169 tree decl
= node
->decl
;
171 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
173 /* C++ FE can produce decls without associated assembler name and insert
174 them to symtab to hold section or TLS information. */
178 hashval_t hash
= decl_assembler_name_hash (name
);
179 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
180 gcc_assert (*aslot
!= node
);
181 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
183 (*aslot
)->previous_sharing_asm_name
= node
;
186 /* Update also possible inline clones sharing a decl. */
187 cnode
= dyn_cast
<cgraph_node
*> (node
);
188 if (cnode
&& cnode
->clones
&& with_clones
)
189 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
190 if (cnode
->decl
== decl
)
191 insert_to_assembler_name_hash (cnode
, true);
196 /* Remove NODE from assembler name hash. */
199 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
202 if (assembler_name_hash
)
205 tree decl
= node
->decl
;
207 if (node
->next_sharing_asm_name
)
208 node
->next_sharing_asm_name
->previous_sharing_asm_name
209 = node
->previous_sharing_asm_name
;
210 if (node
->previous_sharing_asm_name
)
212 node
->previous_sharing_asm_name
->next_sharing_asm_name
213 = node
->next_sharing_asm_name
;
217 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
223 hashval_t hash
= decl_assembler_name_hash (name
);
224 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
226 gcc_assert (*slot
== node
);
227 if (!node
->next_sharing_asm_name
)
228 assembler_name_hash
->clear_slot (slot
);
230 *slot
= node
->next_sharing_asm_name
;
232 node
->next_sharing_asm_name
= NULL
;
233 node
->previous_sharing_asm_name
= NULL
;
235 /* Update also possible inline clones sharing a decl. */
236 cnode
= dyn_cast
<cgraph_node
*> (node
);
237 if (cnode
&& cnode
->clones
&& with_clones
)
238 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
239 if (cnode
->decl
== decl
)
240 unlink_from_assembler_name_hash (cnode
, true);
244 /* Arrange node to be first in its entry of assembler_name_hash. */
247 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
249 unlink_from_assembler_name_hash (node
, false);
250 insert_to_assembler_name_hash (node
, false);
253 /* Initalize asm name hash unless. */
256 symbol_table::symtab_initialize_asm_name_hash (void)
259 if (!assembler_name_hash
)
261 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
262 FOR_EACH_SYMBOL (node
)
263 insert_to_assembler_name_hash (node
, false);
267 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
270 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
272 symtab_node
*node
= NULL
;
274 /* We can have user ASM names on things, like global register variables, that
275 are not in the symbol table. */
276 if ((TREE_CODE (decl
) == VAR_DECL
277 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
278 || TREE_CODE (decl
) == FUNCTION_DECL
)
279 node
= symtab_node::get (decl
);
280 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
282 SET_DECL_ASSEMBLER_NAME (decl
, name
);
284 insert_to_assembler_name_hash (node
, true);
288 if (name
== DECL_ASSEMBLER_NAME (decl
))
291 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
292 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
295 unlink_from_assembler_name_hash (node
, true);
297 const char *old_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
298 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
299 && DECL_RTL_SET_P (decl
))
300 warning (0, "%D renamed after being referenced in assembly", decl
);
302 SET_DECL_ASSEMBLER_NAME (decl
, name
);
305 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
306 TREE_CHAIN (name
) = alias
;
308 /* If we change assembler name, also all transparent aliases must
309 be updated. There are three kinds - those having same assembler name,
310 those being renamed in varasm.c and weakref being renamed by the
314 insert_to_assembler_name_hash (node
, true);
316 for (unsigned i
= 0; node
->iterate_direct_aliases (i
, ref
); i
++)
318 struct symtab_node
*alias
= ref
->referring
;
319 if (alias
->transparent_alias
&& !alias
->weakref
320 && symbol_table::assembler_names_equal_p
321 (old_name
, IDENTIFIER_POINTER (
322 DECL_ASSEMBLER_NAME (alias
->decl
))))
323 change_decl_assembler_name (alias
->decl
, name
);
324 else if (alias
->transparent_alias
325 && IDENTIFIER_TRANSPARENT_ALIAS (alias
->decl
))
327 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
))
328 && IDENTIFIER_TRANSPARENT_ALIAS
329 (DECL_ASSEMBLER_NAME (alias
->decl
)));
331 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
)) =
332 ultimate_transparent_alias_target
333 (DECL_ASSEMBLER_NAME (node
->decl
));
335 #ifdef ASM_OUTPUT_WEAKREF
336 else gcc_assert (!alias
->transparent_alias
|| alias
->weakref
);
338 else gcc_assert (!alias
->transparent_alias
);
341 gcc_assert (!node
->transparent_alias
|| !node
->definition
343 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
344 || symbol_table::assembler_names_equal_p
345 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
348 (node
->get_alias_target ()->decl
))));
353 /* Hash sections by their names. */
356 section_name_hasher::hash (section_hash_entry
*n
)
358 return htab_hash_string (n
->name
);
361 /* Return true if section P1 name equals to P2. */
364 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
366 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
369 /* Add node into symbol table. This function is not used directly, but via
370 cgraph/varpool node creation routines. */
373 symtab_node::register_symbol (void)
375 symtab
->register_symbol (this);
377 if (!decl
->decl_with_vis
.symtab_node
)
378 decl
->decl_with_vis
.symtab_node
= this;
382 /* Be sure to do this last; C++ FE might create new nodes via
383 DECL_ASSEMBLER_NAME langhook! */
384 symtab
->insert_to_assembler_name_hash (this, false);
387 /* Remove NODE from same comdat group. */
390 symtab_node::remove_from_same_comdat_group (void)
392 if (same_comdat_group
)
395 for (prev
= same_comdat_group
;
396 prev
->same_comdat_group
!= this;
397 prev
= prev
->same_comdat_group
)
399 if (same_comdat_group
== prev
)
400 prev
->same_comdat_group
= NULL
;
402 prev
->same_comdat_group
= same_comdat_group
;
403 same_comdat_group
= NULL
;
404 set_comdat_group (NULL
);
408 /* Remove node from symbol table. This function is not used directly, but via
409 cgraph/varpool node removal routines. */
412 symtab_node::unregister (void)
414 remove_all_references ();
415 remove_all_referring ();
417 /* Remove reference to section. */
418 set_section_for_node (NULL
);
420 remove_from_same_comdat_group ();
422 symtab
->unregister (this);
424 /* During LTO symtab merging we temporarily corrupt decl to symtab node
426 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
427 if (decl
->decl_with_vis
.symtab_node
== this)
429 symtab_node
*replacement_node
= NULL
;
430 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
431 replacement_node
= cnode
->find_replacement ();
432 decl
->decl_with_vis
.symtab_node
= replacement_node
;
434 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
435 symtab
->unlink_from_assembler_name_hash (this, false);
436 if (in_init_priority_hash
)
437 symtab
->init_priority_hash
->remove (this);
441 /* Remove symbol from symbol table. */
444 symtab_node::remove (void)
446 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
448 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
452 /* Add NEW_ to the same comdat group that OLD is in. */
455 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
457 gcc_assert (old_node
->get_comdat_group ());
458 gcc_assert (!same_comdat_group
);
459 gcc_assert (this != old_node
);
461 set_comdat_group (old_node
->get_comdat_group ());
462 same_comdat_group
= old_node
;
463 if (!old_node
->same_comdat_group
)
464 old_node
->same_comdat_group
= this;
468 for (n
= old_node
->same_comdat_group
;
469 n
->same_comdat_group
!= old_node
;
470 n
= n
->same_comdat_group
)
472 n
->same_comdat_group
= this;
476 /* Dissolve the same_comdat_group list in which NODE resides. */
479 symtab_node::dissolve_same_comdat_group_list (void)
481 symtab_node
*n
= this;
484 if (!same_comdat_group
)
488 next
= n
->same_comdat_group
;
489 n
->same_comdat_group
= NULL
;
490 /* Clear comdat_group for comdat locals, since
491 make_decl_local doesn't. */
492 if (!TREE_PUBLIC (n
->decl
))
493 n
->set_comdat_group (NULL
);
499 /* Return printable assembler name of NODE.
500 This function is used only for debugging. When assembler name
501 is unknown go with identifier name. */
504 symtab_node::asm_name () const
506 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
508 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
511 /* Return printable identifier name. */
514 symtab_node::name () const
516 if (!DECL_NAME (decl
))
518 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
523 return lang_hooks
.decl_printable_name (decl
, 2);
526 /* Return ipa reference from this symtab_node to
527 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
531 symtab_node::create_reference (symtab_node
*referred_node
,
532 enum ipa_ref_use use_type
)
534 return create_reference (referred_node
, use_type
, NULL
);
538 /* Return ipa reference from this symtab_node to
539 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
540 of the use and STMT the statement (if it exists). */
543 symtab_node::create_reference (symtab_node
*referred_node
,
544 enum ipa_ref_use use_type
, gimple
*stmt
)
546 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
547 ipa_ref_list
*list
, *list2
;
548 ipa_ref_t
*old_references
;
550 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
551 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
554 old_references
= vec_safe_address (list
->references
);
555 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1);
556 ref
= &list
->references
->last ();
558 list2
= &referred_node
->ref_list
;
560 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
561 if(use_type
== IPA_REF_ALIAS
)
563 list2
->referring
.safe_insert (0, ref
);
564 ref
->referred_index
= 0;
566 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
567 list2
->referring
[i
]->referred_index
= i
;
571 list2
->referring
.safe_push (ref
);
572 ref
->referred_index
= list2
->referring
.length () - 1;
575 ref
->referring
= this;
576 ref
->referred
= referred_node
;
578 ref
->lto_stmt_uid
= 0;
580 ref
->speculative
= 0;
582 /* If vector was moved in memory, update pointers. */
583 if (old_references
!= list
->references
->address ())
586 for (i
= 0; iterate_reference(i
, ref2
); i
++)
587 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
592 /* If VAL is a reference to a function or a variable, add a reference from
593 this symtab_node to the corresponding symbol table node. USE_TYPE specify
594 type of the use and STMT the statement (if it exists). Return the new
595 reference or NULL if none was created. */
598 symtab_node::maybe_create_reference (tree val
, enum ipa_ref_use use_type
,
602 if (TREE_CODE (val
) != ADDR_EXPR
)
604 val
= get_base_var (val
);
605 if (val
&& (TREE_CODE (val
) == FUNCTION_DECL
606 || TREE_CODE (val
) == VAR_DECL
))
608 symtab_node
*referred
= symtab_node::get (val
);
609 gcc_checking_assert (referred
);
610 return create_reference (referred
, use_type
, stmt
);
615 /* Clone all references from symtab NODE to this symtab_node. */
618 symtab_node::clone_references (symtab_node
*node
)
620 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
622 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
624 bool speculative
= ref
->speculative
;
625 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
627 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
628 ref2
->speculative
= speculative
;
629 ref2
->lto_stmt_uid
= stmt_uid
;
633 /* Clone all referring from symtab NODE to this symtab_node. */
636 symtab_node::clone_referring (symtab_node
*node
)
638 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
640 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
642 bool speculative
= ref
->speculative
;
643 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
645 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
646 ref2
->speculative
= speculative
;
647 ref2
->lto_stmt_uid
= stmt_uid
;
651 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
654 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
656 bool speculative
= ref
->speculative
;
657 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
660 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
661 ref2
->speculative
= speculative
;
662 ref2
->lto_stmt_uid
= stmt_uid
;
666 /* Find the structure describing a reference to REFERRED_NODE
667 and associated with statement STMT. */
670 symtab_node::find_reference (symtab_node
*referred_node
,
671 gimple
*stmt
, unsigned int lto_stmt_uid
)
676 for (i
= 0; iterate_reference (i
, r
); i
++)
677 if (r
->referred
== referred_node
679 && ((stmt
&& r
->stmt
== stmt
)
680 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
681 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
686 /* Remove all references that are associated with statement STMT. */
689 symtab_node::remove_stmt_references (gimple
*stmt
)
694 while (iterate_reference (i
, r
))
696 r
->remove_reference ();
701 /* Remove all stmt references in non-speculative references.
702 Those are not maintained during inlining & clonning.
703 The exception are speculative references that are updated along
704 with callgraph edges associated with them. */
707 symtab_node::clear_stmts_in_references (void)
712 for (i
= 0; iterate_reference (i
, r
); i
++)
720 /* Remove all references in ref list. */
723 symtab_node::remove_all_references (void)
725 while (vec_safe_length (ref_list
.references
))
726 ref_list
.references
->last ().remove_reference ();
727 vec_free (ref_list
.references
);
730 /* Remove all referring items in ref list. */
733 symtab_node::remove_all_referring (void)
735 while (ref_list
.referring
.length ())
736 ref_list
.referring
.last ()->remove_reference ();
737 ref_list
.referring
.release ();
740 /* Dump references in ref list to FILE. */
743 symtab_node::dump_references (FILE *file
)
747 for (i
= 0; iterate_reference (i
, ref
); i
++)
749 fprintf (file
, "%s/%i (%s)",
750 ref
->referred
->asm_name (),
751 ref
->referred
->order
,
752 ipa_ref_use_name
[ref
->use
]);
753 if (ref
->speculative
)
754 fprintf (file
, " (speculative)");
756 fprintf (file
, "\n");
759 /* Dump referring in list to FILE. */
762 symtab_node::dump_referring (FILE *file
)
766 for (i
= 0; iterate_referring(i
, ref
); i
++)
768 fprintf (file
, "%s/%i (%s)",
769 ref
->referring
->asm_name (),
770 ref
->referring
->order
,
771 ipa_ref_use_name
[ref
->use
]);
772 if (ref
->speculative
)
773 fprintf (file
, " (speculative)");
775 fprintf (file
, "\n");
778 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
780 /* Dump base fields of symtab nodes to F. Not to be used directly. */
783 symtab_node::dump_base (FILE *f
)
785 static const char * const visibility_types
[] = {
786 "default", "protected", "hidden", "internal"
789 fprintf (f
, "%s/%i (%s)", asm_name (), order
, name ());
790 dump_addr (f
, " @", (void *)this);
791 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
794 fprintf (f
, " definition");
796 fprintf (f
, " analyzed");
798 fprintf (f
, " alias");
799 if (transparent_alias
)
800 fprintf (f
, " transparent_alias");
802 fprintf (f
, " weakref");
803 if (cpp_implicit_alias
)
804 fprintf (f
, " cpp_implicit_alias");
806 fprintf (f
, " target:%s",
807 DECL_P (alias_target
)
808 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
810 : IDENTIFIER_POINTER (alias_target
));
812 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
813 fprintf (f
, "\n Visibility:");
814 if (in_other_partition
)
815 fprintf (f
, " in_other_partition");
816 if (used_from_other_partition
)
817 fprintf (f
, " used_from_other_partition");
819 fprintf (f
, " force_output");
821 fprintf (f
, " forced_by_abi");
822 if (externally_visible
)
823 fprintf (f
, " externally_visible");
825 fprintf (f
, " no_reorder");
826 if (resolution
!= LDPR_UNKNOWN
)
828 ld_plugin_symbol_resolution_names
[(int)resolution
]);
829 if (TREE_ASM_WRITTEN (decl
))
830 fprintf (f
, " asm_written");
831 if (DECL_EXTERNAL (decl
))
832 fprintf (f
, " external");
833 if (TREE_PUBLIC (decl
))
834 fprintf (f
, " public");
835 if (DECL_COMMON (decl
))
836 fprintf (f
, " common");
837 if (DECL_WEAK (decl
))
838 fprintf (f
, " weak");
839 if (DECL_DLLIMPORT_P (decl
))
840 fprintf (f
, " dll_import");
841 if (DECL_COMDAT (decl
))
842 fprintf (f
, " comdat");
843 if (get_comdat_group ())
844 fprintf (f
, " comdat_group:%s",
845 IDENTIFIER_POINTER (get_comdat_group_id ()));
846 if (DECL_ONE_ONLY (decl
))
847 fprintf (f
, " one_only");
849 fprintf (f
, " section:%s",
851 if (implicit_section
)
852 fprintf (f
," (implicit_section)");
853 if (DECL_VISIBILITY_SPECIFIED (decl
))
854 fprintf (f
, " visibility_specified");
855 if (DECL_VISIBILITY (decl
))
856 fprintf (f
, " visibility:%s",
857 visibility_types
[DECL_VISIBILITY (decl
)]);
858 if (DECL_VIRTUAL_P (decl
))
859 fprintf (f
, " virtual");
860 if (DECL_ARTIFICIAL (decl
))
861 fprintf (f
, " artificial");
862 if (TREE_CODE (decl
) == FUNCTION_DECL
)
864 if (DECL_STATIC_CONSTRUCTOR (decl
))
865 fprintf (f
, " constructor");
866 if (DECL_STATIC_DESTRUCTOR (decl
))
867 fprintf (f
, " destructor");
871 if (same_comdat_group
)
872 fprintf (f
, " Same comdat group as: %s/%i\n",
873 same_comdat_group
->asm_name (),
874 same_comdat_group
->order
);
875 if (next_sharing_asm_name
)
876 fprintf (f
, " next sharing asm name: %i\n",
877 next_sharing_asm_name
->order
);
878 if (previous_sharing_asm_name
)
879 fprintf (f
, " previous sharing asm name: %i\n",
880 previous_sharing_asm_name
->order
);
883 fprintf (f
, " Address is taken.\n");
886 fprintf (f
, " Aux:");
887 dump_addr (f
, " @", (void *)aux
);
890 fprintf (f
, " References: ");
892 fprintf (f
, " Referring: ");
895 fprintf (f
, " Read from file: %s\n",
896 lto_file_data
->file_name
);
899 /* Dump symtab node to F. */
902 symtab_node::dump (FILE *f
)
904 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
906 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
910 /* Dump symbol table to F. */
913 symtab_node::dump_table (FILE *f
)
916 fprintf (f
, "Symbol table:\n\n");
917 FOR_EACH_SYMBOL (node
)
922 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
923 Return NULL if there's no such node. */
926 symtab_node::get_for_asmname (const_tree asmname
)
930 symtab
->symtab_initialize_asm_name_hash ();
931 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
933 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
944 /* Dump symtab node NODE to stderr. */
947 symtab_node::debug (void)
952 /* Verify common part of symtab nodes. */
955 symtab_node::verify_base (void)
957 bool error_found
= false;
958 symtab_node
*hashed_node
;
960 if (is_a
<cgraph_node
*> (this))
962 if (TREE_CODE (decl
) != FUNCTION_DECL
)
964 error ("function symbol is not function");
968 else if (is_a
<varpool_node
*> (this))
970 if (TREE_CODE (decl
) != VAR_DECL
)
972 error ("variable symbol is not variable");
978 error ("node has unknown type");
982 if (symtab
->state
!= LTO_STREAMING
)
984 hashed_node
= symtab_node::get (decl
);
987 error ("node not found node->decl->decl_with_vis.symtab_node");
990 if (hashed_node
!= this
991 && (!is_a
<cgraph_node
*> (this)
992 || !dyn_cast
<cgraph_node
*> (this)->clone_of
993 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
995 error ("node differs from node->decl->decl_with_vis.symtab_node");
999 if (symtab
->assembler_name_hash
)
1001 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1002 if (hashed_node
&& hashed_node
->previous_sharing_asm_name
)
1004 error ("assembler name hash list corrupted");
1009 if (hashed_node
== this)
1011 hashed_node
= hashed_node
->next_sharing_asm_name
;
1014 && !(is_a
<varpool_node
*> (this)
1015 && DECL_HARD_REGISTER (decl
)))
1017 error ("node not found in symtab assembler name hash");
1021 if (previous_sharing_asm_name
1022 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1024 error ("double linked list of assembler names corrupted");
1027 if (body_removed
&& definition
)
1029 error ("node has body_removed but is definition");
1032 if (analyzed
&& !definition
)
1034 error ("node is analyzed byt it is not a definition");
1037 if (cpp_implicit_alias
&& !alias
)
1039 error ("node is alias but not implicit alias");
1042 if (alias
&& !definition
&& !weakref
)
1044 error ("node is alias but not definition");
1047 if (weakref
&& !transparent_alias
)
1049 error ("node is weakref but not an transparent_alias");
1052 if (transparent_alias
&& !alias
)
1054 error ("node is transparent_alias but not an alias");
1057 if (same_comdat_group
)
1059 symtab_node
*n
= same_comdat_group
;
1061 if (!n
->get_comdat_group ())
1063 error ("node is in same_comdat_group list but has no comdat_group");
1066 if (n
->get_comdat_group () != get_comdat_group ())
1068 error ("same_comdat_group list across different groups");
1071 if (n
->type
!= type
)
1073 error ("mixing different types of symbol in same comdat groups is not supported");
1078 error ("node is alone in a comdat group");
1083 if (!n
->same_comdat_group
)
1085 error ("same_comdat_group is not a circular list");
1089 n
= n
->same_comdat_group
;
1092 if (comdat_local_p ())
1094 ipa_ref
*ref
= NULL
;
1096 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1098 if (!in_same_comdat_group_p (ref
->referring
))
1100 error ("comdat-local symbol referred to by %s outside its "
1102 identifier_to_locale (ref
->referring
->name()));
1108 if (implicit_section
&& !get_section ())
1110 error ("implicit_section flag is set but section isn't");
1113 if (get_section () && get_comdat_group ()
1114 && !implicit_section
1115 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1117 error ("Both section and comdat group is set");
1120 /* TODO: Add string table for sections, so we do not keep holding duplicated
1122 if (alias
&& definition
1123 && get_section () != get_alias_target ()->get_section ()
1125 || !get_alias_target ()->get_section ()
1126 || strcmp (get_section(),
1127 get_alias_target ()->get_section ())))
1129 error ("Alias and target's section differs");
1130 get_alias_target ()->dump (stderr
);
1133 if (alias
&& definition
1134 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1136 error ("Alias and target's comdat groups differs");
1137 get_alias_target ()->dump (stderr
);
1140 if (transparent_alias
&& definition
&& !weakref
)
1142 symtab_node
*to
= get_alias_target ();
1144 = IDENTIFIER_POINTER (
1145 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1147 = IDENTIFIER_POINTER (
1148 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1149 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1151 error ("Transparent alias and target's assembler names differs");
1152 get_alias_target ()->dump (stderr
);
1156 if (transparent_alias
&& definition
1157 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1159 error ("Chained transparent aliases");
1160 get_alias_target ()->dump (stderr
);
1167 /* Verify consistency of NODE. */
1170 symtab_node::verify (void)
1175 timevar_push (TV_CGRAPH_VERIFY
);
1176 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1177 node
->verify_node ();
1182 internal_error ("symtab_node::verify failed");
1184 timevar_pop (TV_CGRAPH_VERIFY
);
1187 /* Verify symbol table for internal consistency. */
1190 symtab_node::verify_symtab_nodes (void)
1193 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1195 FOR_EACH_SYMBOL (node
)
1198 if (node
->get_comdat_group ())
1200 symtab_node
**entry
, *s
;
1203 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1207 else if (!DECL_EXTERNAL (node
->decl
))
1209 for (s
= (*entry
)->same_comdat_group
;
1210 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1211 s
= s
->same_comdat_group
)
1213 if (!s
|| s
== *entry
)
1215 error ("Two symbols with same comdat_group are not linked by "
1216 "the same_comdat_group list.");
1219 internal_error ("symtab_node::verify failed");
1226 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1227 but other code such as notice_global_symbol generates rtl. */
1230 symtab_node::make_decl_local (void)
1237 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1238 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1239 symtab
->change_decl_assembler_name
1240 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1241 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1242 DECL_ATTRIBUTES (decl
));
1244 /* Avoid clearing comdat_groups on comdat-local decls. */
1245 else if (TREE_PUBLIC (decl
) == 0)
1248 /* Localizing a symbol also make all its transparent aliases local. */
1250 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1252 struct symtab_node
*alias
= ref
->referring
;
1253 if (alias
->transparent_alias
)
1254 alias
->make_decl_local ();
1257 if (TREE_CODE (decl
) == VAR_DECL
)
1259 DECL_COMMON (decl
) = 0;
1260 /* ADDRESSABLE flag is not defined for public symbols. */
1261 TREE_ADDRESSABLE (decl
) = 1;
1262 TREE_STATIC (decl
) = 1;
1264 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1266 DECL_COMDAT (decl
) = 0;
1267 DECL_WEAK (decl
) = 0;
1268 DECL_EXTERNAL (decl
) = 0;
1269 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1270 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1271 TREE_PUBLIC (decl
) = 0;
1272 DECL_DLLIMPORT_P (decl
) = 0;
1273 if (!DECL_RTL_SET_P (decl
))
1276 /* Update rtl flags. */
1277 make_decl_rtl (decl
);
1279 rtl
= DECL_RTL (decl
);
1283 symbol
= XEXP (rtl
, 0);
1284 if (GET_CODE (symbol
) != SYMBOL_REF
)
1287 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1290 /* Walk the alias chain to return the symbol NODE is alias of.
1291 If NODE is not an alias, return NODE.
1292 Assumes NODE is known to be alias. */
1295 symtab_node::ultimate_alias_target_1 (enum availability
*availability
)
1297 bool transparent_p
= false;
1299 /* To determine visibility of the target, we follow ELF semantic of aliases.
1300 Here alias is an alternative assembler name of a given definition. Its
1301 availability prevails the availability of its target (i.e. static alias of
1302 weak definition is available.
1304 Transaparent alias is just alternative anme of a given symbol used within
1305 one compilation unit and is translated prior hitting the object file. It
1306 inherits the visibility of its target.
1307 Weakref is a different animal (and noweak definition is weak).
1309 If we ever get into supporting targets with different semantics, a target
1310 hook will be needed here. */
1314 transparent_p
= transparent_alias
;
1316 *availability
= get_availability ();
1318 *availability
= AVAIL_NOT_AVAILABLE
;
1321 symtab_node
*node
= this;
1324 if (node
->alias
&& node
->analyzed
)
1325 node
= node
->get_alias_target ();
1328 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1330 else if (node
->analyzed
&& !node
->transparent_alias
)
1331 *availability
= node
->get_availability ();
1333 *availability
= AVAIL_NOT_AVAILABLE
;
1336 if (node
&& availability
&& transparent_p
1337 && node
->transparent_alias
)
1339 *availability
= node
->get_availability ();
1340 transparent_p
= false;
1344 *availability
= AVAIL_NOT_AVAILABLE
;
1348 /* C++ FE sometimes change linkage flags after producing same body aliases.
1350 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1351 are obviously equivalent. The way it is doing so is however somewhat
1352 kludgy and interferes with the visibility code. As a result we need to
1353 copy the visibility from the target to get things right. */
1356 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1358 if (is_a
<cgraph_node
*> (this))
1360 DECL_DECLARED_INLINE_P (decl
)
1361 = DECL_DECLARED_INLINE_P (target
->decl
);
1362 DECL_DISREGARD_INLINE_LIMITS (decl
)
1363 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1365 /* FIXME: It is not really clear why those flags should not be copied for
1369 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1370 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1371 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1373 if (TREE_PUBLIC (decl
))
1377 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1378 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1379 group
= target
->get_comdat_group ();
1380 set_comdat_group (group
);
1381 if (group
&& !same_comdat_group
)
1382 add_to_same_comdat_group (target
);
1384 externally_visible
= target
->externally_visible
;
1387 /* Set section, do not recurse into aliases.
1388 When one wants to change section of symbol and its aliases,
1392 symtab_node::set_section_for_node (const char *section
)
1394 const char *current
= get_section ();
1395 section_hash_entry
**slot
;
1397 if (current
== section
1398 || (current
&& section
1399 && !strcmp (current
, section
)))
1404 x_section
->ref_count
--;
1405 if (!x_section
->ref_count
)
1407 hashval_t hash
= htab_hash_string (x_section
->name
);
1408 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1410 ggc_free (x_section
);
1411 symtab
->section_hash
->clear_slot (slot
);
1417 implicit_section
= false;
1420 if (!symtab
->section_hash
)
1421 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1422 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1423 htab_hash_string (section
),
1426 x_section
= (section_hash_entry
*)*slot
;
1429 int len
= strlen (section
);
1430 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1431 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1432 memcpy (x_section
->name
, section
, len
+ 1);
1434 x_section
->ref_count
++;
1437 /* Worker for set_section. */
1440 symtab_node::set_section (symtab_node
*n
, void *s
)
1442 n
->set_section_for_node ((char *)s
);
1446 /* Set section of symbol and its aliases. */
1449 symtab_node::set_section (const char *section
)
1451 gcc_assert (!this->alias
);
1452 call_for_symbol_and_aliases
1453 (symtab_node::set_section
, const_cast<char *>(section
), true);
1456 /* Return the initialization priority. */
1459 symtab_node::get_init_priority ()
1461 if (!this->in_init_priority_hash
)
1462 return DEFAULT_INIT_PRIORITY
;
1464 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1465 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1468 /* Return the finalization priority. */
1471 cgraph_node::get_fini_priority ()
1473 if (!this->in_init_priority_hash
)
1474 return DEFAULT_INIT_PRIORITY
;
1475 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1476 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1479 /* Return the initialization and finalization priority information for
1480 DECL. If there is no previous priority information, a freshly
1481 allocated structure is returned. */
1483 symbol_priority_map
*
1484 symtab_node::priority_info (void)
1486 if (!symtab
->init_priority_hash
)
1487 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1490 symbol_priority_map
*h
1491 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1494 h
->init
= DEFAULT_INIT_PRIORITY
;
1495 h
->fini
= DEFAULT_INIT_PRIORITY
;
1496 in_init_priority_hash
= true;
1502 /* Set initialization priority to PRIORITY. */
1505 symtab_node::set_init_priority (priority_type priority
)
1507 symbol_priority_map
*h
;
1509 if (is_a
<cgraph_node
*> (this))
1510 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1512 if (priority
== DEFAULT_INIT_PRIORITY
)
1514 gcc_assert (get_init_priority() == priority
);
1517 h
= priority_info ();
1521 /* Set fialization priority to PRIORITY. */
1524 cgraph_node::set_fini_priority (priority_type priority
)
1526 symbol_priority_map
*h
;
1528 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1530 if (priority
== DEFAULT_INIT_PRIORITY
)
1532 gcc_assert (get_fini_priority() == priority
);
1535 h
= priority_info ();
1539 /* Worker for symtab_resolve_alias. */
1542 symtab_node::set_implicit_section (symtab_node
*n
,
1543 void *data ATTRIBUTE_UNUSED
)
1545 n
->implicit_section
= true;
1549 /* Add reference recording that symtab node is alias of TARGET.
1550 The function can fail in the case of aliasing cycles; in this case
1551 it returns false. */
1554 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1558 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1560 /* Never let cycles to creep into the symbol table alias references;
1561 those will make alias walkers to be infinite. */
1562 for (n
= target
; n
&& n
->alias
;
1563 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1566 if (is_a
<cgraph_node
*> (this))
1567 error ("function %q+D part of alias cycle", decl
);
1568 else if (is_a
<varpool_node
*> (this))
1569 error ("variable %q+D part of alias cycle", decl
);
1576 /* "analyze" the node - i.e. mark the reference. */
1580 transparent
|= transparent_alias
;
1581 transparent_alias
= transparent
;
1583 while (target
->transparent_alias
&& target
->analyzed
)
1584 target
= target
->get_alias_target ();
1585 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1587 /* Add alias into the comdat group of its target unless it is already there. */
1588 if (same_comdat_group
)
1589 remove_from_same_comdat_group ();
1590 set_comdat_group (NULL
);
1591 if (target
->get_comdat_group ())
1592 add_to_same_comdat_group (target
);
1594 if ((get_section () != target
->get_section ()
1595 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1597 error ("section of alias %q+D must match section of its target", decl
);
1599 call_for_symbol_and_aliases (symtab_node::set_section
,
1600 const_cast<char *>(target
->get_section ()), true);
1601 if (target
->implicit_section
)
1602 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1604 /* Alias targets become redundant after alias is resolved into an reference.
1605 We do not want to keep it around or we would have to mind updating them
1606 when renaming symbols. */
1607 alias_target
= NULL
;
1609 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1610 fixup_same_cpp_alias_visibility (target
);
1612 /* If alias has address taken, so does the target. */
1614 target
->ultimate_alias_target ()->address_taken
= true;
1616 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1617 If alias is transparent, also all transparent aliases of THIS are now
1619 Also merge same comdat group lists. */
1621 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1623 struct symtab_node
*alias_alias
= ref
->referring
;
1624 if (alias_alias
->get_comdat_group ())
1626 alias_alias
->remove_from_same_comdat_group ();
1627 alias_alias
->set_comdat_group (NULL
);
1628 if (target
->get_comdat_group ())
1629 alias_alias
->add_to_same_comdat_group (target
);
1631 if (!alias_alias
->transparent_alias
|| transparent
)
1633 alias_alias
->remove_all_references ();
1634 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1641 /* Worker searching noninterposable alias. */
1644 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1646 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1648 symtab_node
*fn
= node
->ultimate_alias_target ();
1650 /* Ensure that the alias is well formed this may not be the case
1651 of user defined aliases and currently it is not always the case
1652 of C++ same body aliases (that is a bug). */
1653 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1654 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1655 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1656 && flags_from_decl_or_type (node
->decl
)
1657 != flags_from_decl_or_type (fn
->decl
))
1658 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1660 *(symtab_node
**)data
= node
;
1666 /* If node can not be overwriten by static or dynamic linker to point to
1667 different definition, return NODE. Otherwise look for alias with such
1668 property and if none exists, introduce new one. */
1671 symtab_node::noninterposable_alias (void)
1674 symtab_node
*new_node
= NULL
;
1676 /* First try to look up existing alias or base object
1677 (if that is already non-overwritable). */
1678 symtab_node
*node
= ultimate_alias_target ();
1679 gcc_assert (!node
->alias
&& !node
->weakref
);
1680 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1681 (void *)&new_node
, true);
1684 #ifndef ASM_OUTPUT_DEF
1685 /* If aliases aren't supported by the assembler, fail. */
1689 /* Otherwise create a new one. */
1690 new_decl
= copy_node (node
->decl
);
1691 DECL_DLLIMPORT_P (new_decl
) = 0;
1692 DECL_NAME (new_decl
) = clone_function_name (node
->decl
, "localalias");
1693 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1694 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1695 DECL_INITIAL (new_decl
) = NULL
;
1696 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1697 SET_DECL_RTL (new_decl
, NULL
);
1699 /* Update the properties. */
1700 DECL_EXTERNAL (new_decl
) = 0;
1701 TREE_PUBLIC (new_decl
) = 0;
1702 DECL_COMDAT (new_decl
) = 0;
1703 DECL_WEAK (new_decl
) = 0;
1705 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1706 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1707 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1709 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1710 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1711 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1715 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1716 DECL_INITIAL (new_decl
) = error_mark_node
;
1717 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1719 new_node
->resolve_alias (node
);
1720 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1721 && targetm
.binds_local_p (new_decl
));
1725 /* Return true if symtab node and TARGET represents
1726 semantically equivalent symbols. */
1729 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1731 enum availability avail
;
1735 /* Equivalent functions are equivalent. */
1736 if (decl
== target
->decl
)
1739 /* If symbol is not overwritable by different implementation,
1740 walk to the base object it defines. */
1741 ba
= ultimate_alias_target (&avail
);
1742 if (avail
>= AVAIL_AVAILABLE
)
1749 bb
= target
->ultimate_alias_target (&avail
);
1750 if (avail
>= AVAIL_AVAILABLE
)
1760 /* Classify symbol symtab node for partitioning. */
1762 enum symbol_partitioning_class
1763 symtab_node::get_partitioning_class (void)
1765 /* Inline clones are always duplicated.
1766 This include external delcarations. */
1767 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
1769 if (DECL_ABSTRACT_P (decl
))
1770 return SYMBOL_EXTERNAL
;
1772 if (cnode
&& cnode
->global
.inlined_to
)
1773 return SYMBOL_DUPLICATE
;
1775 /* Transparent aliases are always duplicated. */
1776 if (transparent_alias
)
1777 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
1779 /* External declarations are external. */
1780 if (DECL_EXTERNAL (decl
))
1781 return SYMBOL_EXTERNAL
;
1783 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1785 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
1786 return SYMBOL_EXTERNAL
;
1787 /* Constant pool references use local symbol names that can not
1788 be promoted global. We should never put into a constant pool
1789 objects that can not be duplicated across partitions. */
1790 if (DECL_IN_CONSTANT_POOL (decl
))
1791 return SYMBOL_DUPLICATE
;
1792 if (DECL_HARD_REGISTER (decl
))
1793 return SYMBOL_DUPLICATE
;
1794 gcc_checking_assert (vnode
->definition
);
1796 /* Functions that are cloned may stay in callgraph even if they are unused.
1797 Handle them as external; compute_ltrans_boundary take care to make
1798 proper things to happen (i.e. to make them appear in the boundary but
1799 with body streamed, so clone can me materialized). */
1800 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
1801 return SYMBOL_EXTERNAL
;
1803 /* Linker discardable symbols are duplicated to every use unless they are
1805 if (DECL_ONE_ONLY (decl
)
1808 && !used_from_object_file_p ())
1809 return SYMBOL_DUPLICATE
;
1811 return SYMBOL_PARTITION
;
1814 /* Return true when symbol is known to be non-zero. */
1817 symtab_node::nonzero_address ()
1819 /* Weakrefs may be NULL when their target is not defined. */
1820 if (alias
&& weakref
)
1824 symtab_node
*target
= ultimate_alias_target ();
1826 if (target
->alias
&& target
->weakref
)
1828 /* We can not recurse to target::nonzero. It is possible that the
1829 target is used only via the alias.
1830 We may walk references and look for strong use, but we do not know
1831 if this strong use will survive to final binary, so be
1833 ??? Maybe we could do the lookup during late optimization that
1834 could be useful to eliminate the NULL pointer checks in LTO
1836 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
1838 if (target
->resolution
!= LDPR_UNKNOWN
1839 && target
->resolution
!= LDPR_UNDEF
1840 && !target
->can_be_discarded_p ()
1841 && flag_delete_null_pointer_checks
)
1849 /* With !flag_delete_null_pointer_checks we assume that symbols may
1850 bind to NULL. This is on by default on embedded targets only.
1852 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
1853 linking fails. Important case of WEAK we want to do well are comdats.
1854 Those are handled by later check for definition.
1856 When parsing, beware the cases when WEAK attribute is added later. */
1857 if (!DECL_WEAK (decl
)
1858 && flag_delete_null_pointer_checks
)
1860 refuse_visibility_changes
= true;
1864 /* If target is defined and not extern, we know it will be output and thus
1865 it will bind to non-NULL.
1866 Play safe for flag_delete_null_pointer_checks where weak definition maye
1867 be re-defined by NULL. */
1868 if (definition
&& !DECL_EXTERNAL (decl
)
1869 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
1871 if (!DECL_WEAK (decl
))
1872 refuse_visibility_changes
= true;
1876 /* As the last resort, check the resolution info. */
1877 if (resolution
!= LDPR_UNKNOWN
1878 && resolution
!= LDPR_UNDEF
1879 && !can_be_discarded_p ()
1880 && flag_delete_null_pointer_checks
)
1885 /* Return 0 if symbol is known to have different address than S2,
1886 Return 1 if symbol is known to have same address as S2,
1887 return -1 otherwise.
1889 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
1890 and S2 is going to be accessed. This eliminates the situations when
1891 either THIS or S2 is NULL and is seful for comparing bases when deciding
1892 about memory aliasing. */
1894 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
1896 enum availability avail1
, avail2
;
1898 /* A Shortcut: equivalent symbols are always equivalent. */
1902 /* Unwind transparent aliases first; those are always equal to their
1904 if (this->transparent_alias
&& this->analyzed
)
1905 return this->get_alias_target ()->equal_address_to (s2
);
1906 while (s2
->transparent_alias
&& s2
->analyzed
)
1907 s2
= s2
->get_alias_target();
1912 /* For non-interposable aliases, lookup and compare their actual definitions.
1913 Also check if the symbol needs to bind to given definition. */
1914 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
1915 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
1916 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
1917 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
1918 bool really_binds_local1
= binds_local1
;
1919 bool really_binds_local2
= binds_local2
;
1921 /* Addresses of vtables and virtual functions can not be used by user
1922 code and are used only within speculation. In this case we may make
1923 symbol equivalent to its alias even if interposition may break this
1924 rule. Doing so will allow us to turn speculative inlining into
1925 non-speculative more agressively. */
1926 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
1927 binds_local1
= true;
1928 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
1929 binds_local2
= true;
1931 /* If both definitions are available we know that even if they are bound
1932 to other unit they must be defined same way and therefore we can use
1933 equivalence test. */
1934 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
1935 binds_local1
= binds_local2
= true;
1937 if ((binds_local1
? rs1
: this)
1938 == (binds_local2
? rs2
: s2
))
1940 /* We made use of the fact that alias is not weak. */
1941 if (binds_local1
&& rs1
!= this)
1942 refuse_visibility_changes
= true;
1943 if (binds_local2
&& rs2
!= s2
)
1944 s2
->refuse_visibility_changes
= true;
1948 /* If both symbols may resolve to NULL, we can not really prove them
1950 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
1953 /* Except for NULL, functions and variables never overlap. */
1954 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
1957 /* If one of the symbols is unresolved alias, punt. */
1958 if (rs1
->alias
|| rs2
->alias
)
1961 /* If we have a non-interposale definition of at least one of the symbols
1962 and the other symbol is different, we know other unit can not interpose
1963 it to the first symbol; all aliases of the definition needs to be
1964 present in the current unit. */
1965 if (((really_binds_local1
|| really_binds_local2
)
1966 /* If we have both definitions and they are different, we know they
1967 will be different even in units they binds to. */
1968 || (binds_local1
&& binds_local2
))
1971 /* We make use of the fact that one symbol is not alias of the other
1972 and that the definition is non-interposable. */
1973 refuse_visibility_changes
= true;
1974 s2
->refuse_visibility_changes
= true;
1975 rs1
->refuse_visibility_changes
= true;
1976 rs2
->refuse_visibility_changes
= true;
1980 /* TODO: Alias oracle basically assume that addresses of global variables
1981 are different unless they are declared as alias of one to another while
1982 the code folding comparsions doesn't.
1983 We probably should be consistent and use this fact here, too, but for
1984 the moment return false only when we are called from the alias oracle. */
1986 return memory_accessed
&& rs1
!= rs2
? 0 : -1;
1989 /* Worker for call_for_symbol_and_aliases. */
1992 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
1995 bool include_overwritable
)
1998 FOR_EACH_ALIAS (this, ref
)
2000 symtab_node
*alias
= ref
->referring
;
2001 if (include_overwritable
2002 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2003 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2004 include_overwritable
))
2010 /* Return true if address of N is possibly compared. */
2013 address_matters_1 (symtab_node
*n
, void *)
2015 struct ipa_ref
*ref
;
2017 if (!n
->address_can_be_compared_p ())
2019 if (n
->externally_visible
|| n
->force_output
)
2022 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2023 if (ref
->address_matters_p ())
2028 /* Return true if symbol's address may possibly be compared to other
2029 symbol's address. */
2032 symtab_node::address_matters_p ()
2034 gcc_assert (!alias
);
2035 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2038 /* Return true if symbol's alignment may be increased. */
2041 symtab_node::can_increase_alignment_p (void)
2043 symtab_node
*target
= ultimate_alias_target ();
2045 /* For now support only variables. */
2046 if (TREE_CODE (decl
) != VAR_DECL
)
2049 /* With -fno-toplevel-reorder we may have already output the constant. */
2050 if (TREE_ASM_WRITTEN (target
->decl
))
2053 /* If target is already placed in an anchor, we can not touch its
2055 if (DECL_RTL_SET_P (target
->decl
)
2056 && MEM_P (DECL_RTL (target
->decl
))
2057 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2060 /* Constant pool entries may be shared. */
2061 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2064 /* We cannot change alignment of symbols that may bind to symbols
2065 in other translation unit that may contain a definition with lower
2067 if (!decl_binds_to_current_def_p (decl
))
2070 /* When compiling partition, be sure the symbol is not output by other
2073 && (target
->in_other_partition
2074 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2077 /* Do not override the alignment as specified by the ABI when the used
2078 attribute is set. */
2079 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2082 /* Do not override explicit alignment set by the user when an explicit
2083 section name is also used. This is a common idiom used by many
2084 software projects. */
2085 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2091 /* Worker for symtab_node::increase_alignment. */
2094 increase_alignment_1 (symtab_node
*n
, void *v
)
2096 unsigned int align
= (size_t)v
;
2097 if (DECL_ALIGN (n
->decl
) < align
2098 && n
->can_increase_alignment_p ())
2100 DECL_ALIGN (n
->decl
) = align
;
2101 DECL_USER_ALIGN (n
->decl
) = 1;
2106 /* Increase alignment of THIS to ALIGN. */
2109 symtab_node::increase_alignment (unsigned int align
)
2111 gcc_assert (can_increase_alignment_p () && align
< MAX_OFILE_ALIGNMENT
);
2112 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2113 (void *)(size_t) align
,
2115 gcc_assert (DECL_ALIGN (decl
) >= align
);
2118 /* Helper for symtab_node::definition_alignment. */
2121 get_alignment_1 (symtab_node
*n
, void *v
)
2123 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2127 /* Return desired alignment of the definition. This is NOT alignment useful
2128 to access THIS, because THIS may be interposable and DECL_ALIGN should
2129 be used instead. It however must be guaranteed when output definition
2133 symtab_node::definition_alignment ()
2135 unsigned int align
= 0;
2136 gcc_assert (!alias
);
2137 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);