2 Copyright (C) 2012-2017 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 ((VAR_P (decl
) && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
277 || TREE_CODE (decl
) == FUNCTION_DECL
)
278 node
= symtab_node::get (decl
);
279 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
281 SET_DECL_ASSEMBLER_NAME (decl
, name
);
283 insert_to_assembler_name_hash (node
, true);
287 if (name
== DECL_ASSEMBLER_NAME (decl
))
290 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
291 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
294 unlink_from_assembler_name_hash (node
, true);
296 const char *old_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
297 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
298 && DECL_RTL_SET_P (decl
))
299 warning (0, "%D renamed after being referenced in assembly", decl
);
301 SET_DECL_ASSEMBLER_NAME (decl
, name
);
304 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
305 TREE_CHAIN (name
) = alias
;
307 /* If we change assembler name, also all transparent aliases must
308 be updated. There are three kinds - those having same assembler name,
309 those being renamed in varasm.c and weakref being renamed by the
313 insert_to_assembler_name_hash (node
, true);
315 for (unsigned i
= 0; node
->iterate_direct_aliases (i
, ref
); i
++)
317 struct symtab_node
*alias
= ref
->referring
;
318 if (alias
->transparent_alias
&& !alias
->weakref
319 && symbol_table::assembler_names_equal_p
320 (old_name
, IDENTIFIER_POINTER (
321 DECL_ASSEMBLER_NAME (alias
->decl
))))
322 change_decl_assembler_name (alias
->decl
, name
);
323 else if (alias
->transparent_alias
324 && IDENTIFIER_TRANSPARENT_ALIAS (alias
->decl
))
326 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
))
327 && IDENTIFIER_TRANSPARENT_ALIAS
328 (DECL_ASSEMBLER_NAME (alias
->decl
)));
330 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
)) =
331 ultimate_transparent_alias_target
332 (DECL_ASSEMBLER_NAME (node
->decl
));
334 #ifdef ASM_OUTPUT_WEAKREF
335 else gcc_assert (!alias
->transparent_alias
|| alias
->weakref
);
337 else gcc_assert (!alias
->transparent_alias
);
340 gcc_assert (!node
->transparent_alias
|| !node
->definition
342 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
343 || symbol_table::assembler_names_equal_p
344 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
347 (node
->get_alias_target ()->decl
))));
352 /* Hash sections by their names. */
355 section_name_hasher::hash (section_hash_entry
*n
)
357 return htab_hash_string (n
->name
);
360 /* Return true if section P1 name equals to P2. */
363 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
365 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
368 /* Add node into symbol table. This function is not used directly, but via
369 cgraph/varpool node creation routines. */
372 symtab_node::register_symbol (void)
374 symtab
->register_symbol (this);
376 if (!decl
->decl_with_vis
.symtab_node
)
377 decl
->decl_with_vis
.symtab_node
= this;
381 /* Be sure to do this last; C++ FE might create new nodes via
382 DECL_ASSEMBLER_NAME langhook! */
383 symtab
->insert_to_assembler_name_hash (this, false);
386 /* Remove NODE from same comdat group. */
389 symtab_node::remove_from_same_comdat_group (void)
391 if (same_comdat_group
)
394 for (prev
= same_comdat_group
;
395 prev
->same_comdat_group
!= this;
396 prev
= prev
->same_comdat_group
)
398 if (same_comdat_group
== prev
)
399 prev
->same_comdat_group
= NULL
;
401 prev
->same_comdat_group
= same_comdat_group
;
402 same_comdat_group
= NULL
;
403 set_comdat_group (NULL
);
407 /* Remove node from symbol table. This function is not used directly, but via
408 cgraph/varpool node removal routines. */
411 symtab_node::unregister (void)
413 remove_all_references ();
414 remove_all_referring ();
416 /* Remove reference to section. */
417 set_section_for_node (NULL
);
419 remove_from_same_comdat_group ();
421 symtab
->unregister (this);
423 /* During LTO symtab merging we temporarily corrupt decl to symtab node
425 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
426 if (decl
->decl_with_vis
.symtab_node
== this)
428 symtab_node
*replacement_node
= NULL
;
429 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
430 replacement_node
= cnode
->find_replacement ();
431 decl
->decl_with_vis
.symtab_node
= replacement_node
;
433 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
434 symtab
->unlink_from_assembler_name_hash (this, false);
435 if (in_init_priority_hash
)
436 symtab
->init_priority_hash
->remove (this);
440 /* Remove symbol from symbol table. */
443 symtab_node::remove (void)
445 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
447 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
451 /* Add NEW_ to the same comdat group that OLD is in. */
454 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
456 gcc_assert (old_node
->get_comdat_group ());
457 gcc_assert (!same_comdat_group
);
458 gcc_assert (this != old_node
);
460 set_comdat_group (old_node
->get_comdat_group ());
461 same_comdat_group
= old_node
;
462 if (!old_node
->same_comdat_group
)
463 old_node
->same_comdat_group
= this;
467 for (n
= old_node
->same_comdat_group
;
468 n
->same_comdat_group
!= old_node
;
469 n
= n
->same_comdat_group
)
471 n
->same_comdat_group
= this;
475 /* Dissolve the same_comdat_group list in which NODE resides. */
478 symtab_node::dissolve_same_comdat_group_list (void)
480 symtab_node
*n
= this;
483 if (!same_comdat_group
)
487 next
= n
->same_comdat_group
;
488 n
->same_comdat_group
= NULL
;
489 /* Clear comdat_group for comdat locals, since
490 make_decl_local doesn't. */
491 if (!TREE_PUBLIC (n
->decl
))
492 n
->set_comdat_group (NULL
);
498 /* Return printable assembler name of NODE.
499 This function is used only for debugging. When assembler name
500 is unknown go with identifier name. */
503 symtab_node::asm_name () const
505 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
507 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
510 /* Return printable identifier name. */
513 symtab_node::name () const
515 if (!DECL_NAME (decl
))
517 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
522 return lang_hooks
.decl_printable_name (decl
, 2);
525 /* Return ipa reference from this symtab_node to
526 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
530 symtab_node::create_reference (symtab_node
*referred_node
,
531 enum ipa_ref_use use_type
)
533 return create_reference (referred_node
, use_type
, NULL
);
537 /* Return ipa reference from this symtab_node to
538 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
539 of the use and STMT the statement (if it exists). */
542 symtab_node::create_reference (symtab_node
*referred_node
,
543 enum ipa_ref_use use_type
, gimple
*stmt
)
545 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
546 ipa_ref_list
*list
, *list2
;
547 ipa_ref_t
*old_references
;
549 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
550 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
553 old_references
= vec_safe_address (list
->references
);
554 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1);
555 ref
= &list
->references
->last ();
557 list2
= &referred_node
->ref_list
;
559 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
560 if(use_type
== IPA_REF_ALIAS
)
562 list2
->referring
.safe_insert (0, ref
);
563 ref
->referred_index
= 0;
565 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
566 list2
->referring
[i
]->referred_index
= i
;
570 list2
->referring
.safe_push (ref
);
571 ref
->referred_index
= list2
->referring
.length () - 1;
574 ref
->referring
= this;
575 ref
->referred
= referred_node
;
577 ref
->lto_stmt_uid
= 0;
579 ref
->speculative
= 0;
581 /* If vector was moved in memory, update pointers. */
582 if (old_references
!= list
->references
->address ())
585 for (i
= 0; iterate_reference(i
, ref2
); i
++)
586 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
592 symtab_node::maybe_create_reference (tree val
, gimple
*stmt
)
595 ipa_ref_use use_type
;
597 switch (TREE_CODE (val
))
600 use_type
= IPA_REF_LOAD
;
603 use_type
= IPA_REF_ADDR
;
606 gcc_assert (!handled_component_p (val
));
610 val
= get_base_var (val
);
611 if (val
&& VAR_OR_FUNCTION_DECL_P (val
))
613 symtab_node
*referred
= symtab_node::get (val
);
614 gcc_checking_assert (referred
);
615 return create_reference (referred
, use_type
, stmt
);
620 /* Clone all references from symtab NODE to this symtab_node. */
623 symtab_node::clone_references (symtab_node
*node
)
625 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
627 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
629 bool speculative
= ref
->speculative
;
630 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
632 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
633 ref2
->speculative
= speculative
;
634 ref2
->lto_stmt_uid
= stmt_uid
;
638 /* Clone all referring from symtab NODE to this symtab_node. */
641 symtab_node::clone_referring (symtab_node
*node
)
643 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
645 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
647 bool speculative
= ref
->speculative
;
648 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
650 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
651 ref2
->speculative
= speculative
;
652 ref2
->lto_stmt_uid
= stmt_uid
;
656 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
659 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
661 bool speculative
= ref
->speculative
;
662 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
665 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
666 ref2
->speculative
= speculative
;
667 ref2
->lto_stmt_uid
= stmt_uid
;
671 /* Find the structure describing a reference to REFERRED_NODE
672 and associated with statement STMT. */
675 symtab_node::find_reference (symtab_node
*referred_node
,
676 gimple
*stmt
, unsigned int lto_stmt_uid
)
681 for (i
= 0; iterate_reference (i
, r
); i
++)
682 if (r
->referred
== referred_node
684 && ((stmt
&& r
->stmt
== stmt
)
685 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
686 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
691 /* Remove all references that are associated with statement STMT. */
694 symtab_node::remove_stmt_references (gimple
*stmt
)
699 while (iterate_reference (i
, r
))
701 r
->remove_reference ();
706 /* Remove all stmt references in non-speculative references.
707 Those are not maintained during inlining & clonning.
708 The exception are speculative references that are updated along
709 with callgraph edges associated with them. */
712 symtab_node::clear_stmts_in_references (void)
717 for (i
= 0; iterate_reference (i
, r
); i
++)
725 /* Remove all references in ref list. */
728 symtab_node::remove_all_references (void)
730 while (vec_safe_length (ref_list
.references
))
731 ref_list
.references
->last ().remove_reference ();
732 vec_free (ref_list
.references
);
735 /* Remove all referring items in ref list. */
738 symtab_node::remove_all_referring (void)
740 while (ref_list
.referring
.length ())
741 ref_list
.referring
.last ()->remove_reference ();
742 ref_list
.referring
.release ();
745 /* Dump references in ref list to FILE. */
748 symtab_node::dump_references (FILE *file
)
752 for (i
= 0; iterate_reference (i
, ref
); i
++)
754 fprintf (file
, "%s/%i (%s)",
755 ref
->referred
->asm_name (),
756 ref
->referred
->order
,
757 ipa_ref_use_name
[ref
->use
]);
758 if (ref
->speculative
)
759 fprintf (file
, " (speculative)");
761 fprintf (file
, "\n");
764 /* Dump referring in list to FILE. */
767 symtab_node::dump_referring (FILE *file
)
771 for (i
= 0; iterate_referring(i
, ref
); i
++)
773 fprintf (file
, "%s/%i (%s)",
774 ref
->referring
->asm_name (),
775 ref
->referring
->order
,
776 ipa_ref_use_name
[ref
->use
]);
777 if (ref
->speculative
)
778 fprintf (file
, " (speculative)");
780 fprintf (file
, "\n");
783 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
785 /* Dump base fields of symtab nodes to F. Not to be used directly. */
788 symtab_node::dump_base (FILE *f
)
790 static const char * const visibility_types
[] = {
791 "default", "protected", "hidden", "internal"
794 fprintf (f
, "%s/%i (%s)", asm_name (), order
, name ());
795 dump_addr (f
, " @", (void *)this);
796 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
799 fprintf (f
, " definition");
801 fprintf (f
, " analyzed");
803 fprintf (f
, " alias");
804 if (transparent_alias
)
805 fprintf (f
, " transparent_alias");
807 fprintf (f
, " weakref");
808 if (cpp_implicit_alias
)
809 fprintf (f
, " cpp_implicit_alias");
811 fprintf (f
, " target:%s",
812 DECL_P (alias_target
)
813 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
815 : IDENTIFIER_POINTER (alias_target
));
817 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
818 fprintf (f
, "\n Visibility:");
819 if (in_other_partition
)
820 fprintf (f
, " in_other_partition");
821 if (used_from_other_partition
)
822 fprintf (f
, " used_from_other_partition");
824 fprintf (f
, " force_output");
826 fprintf (f
, " forced_by_abi");
827 if (externally_visible
)
828 fprintf (f
, " externally_visible");
830 fprintf (f
, " no_reorder");
831 if (resolution
!= LDPR_UNKNOWN
)
833 ld_plugin_symbol_resolution_names
[(int)resolution
]);
834 if (TREE_ASM_WRITTEN (decl
))
835 fprintf (f
, " asm_written");
836 if (DECL_EXTERNAL (decl
))
837 fprintf (f
, " external");
838 if (TREE_PUBLIC (decl
))
839 fprintf (f
, " public");
840 if (DECL_COMMON (decl
))
841 fprintf (f
, " common");
842 if (DECL_WEAK (decl
))
843 fprintf (f
, " weak");
844 if (DECL_DLLIMPORT_P (decl
))
845 fprintf (f
, " dll_import");
846 if (DECL_COMDAT (decl
))
847 fprintf (f
, " comdat");
848 if (get_comdat_group ())
849 fprintf (f
, " comdat_group:%s",
850 IDENTIFIER_POINTER (get_comdat_group_id ()));
851 if (DECL_ONE_ONLY (decl
))
852 fprintf (f
, " one_only");
854 fprintf (f
, " section:%s",
856 if (implicit_section
)
857 fprintf (f
," (implicit_section)");
858 if (DECL_VISIBILITY_SPECIFIED (decl
))
859 fprintf (f
, " visibility_specified");
860 if (DECL_VISIBILITY (decl
))
861 fprintf (f
, " visibility:%s",
862 visibility_types
[DECL_VISIBILITY (decl
)]);
863 if (DECL_VIRTUAL_P (decl
))
864 fprintf (f
, " virtual");
865 if (DECL_ARTIFICIAL (decl
))
866 fprintf (f
, " artificial");
867 if (TREE_CODE (decl
) == FUNCTION_DECL
)
869 if (DECL_STATIC_CONSTRUCTOR (decl
))
870 fprintf (f
, " constructor");
871 if (DECL_STATIC_DESTRUCTOR (decl
))
872 fprintf (f
, " destructor");
876 if (same_comdat_group
)
877 fprintf (f
, " Same comdat group as: %s/%i\n",
878 same_comdat_group
->asm_name (),
879 same_comdat_group
->order
);
880 if (next_sharing_asm_name
)
881 fprintf (f
, " next sharing asm name: %i\n",
882 next_sharing_asm_name
->order
);
883 if (previous_sharing_asm_name
)
884 fprintf (f
, " previous sharing asm name: %i\n",
885 previous_sharing_asm_name
->order
);
888 fprintf (f
, " Address is taken.\n");
891 fprintf (f
, " Aux:");
892 dump_addr (f
, " @", (void *)aux
);
895 fprintf (f
, " References: ");
897 fprintf (f
, " Referring: ");
900 fprintf (f
, " Read from file: %s\n",
901 lto_file_data
->file_name
);
904 /* Dump symtab node to F. */
907 symtab_node::dump (FILE *f
)
909 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
911 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
915 /* Dump symbol table to F. */
918 symtab_node::dump_table (FILE *f
)
921 fprintf (f
, "Symbol table:\n\n");
922 FOR_EACH_SYMBOL (node
)
927 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
928 Return NULL if there's no such node. */
931 symtab_node::get_for_asmname (const_tree asmname
)
935 symtab
->symtab_initialize_asm_name_hash ();
936 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
938 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
949 /* Dump symtab node NODE to stderr. */
952 symtab_node::debug (void)
957 /* Verify common part of symtab nodes. */
960 symtab_node::verify_base (void)
962 bool error_found
= false;
963 symtab_node
*hashed_node
;
965 if (is_a
<cgraph_node
*> (this))
967 if (TREE_CODE (decl
) != FUNCTION_DECL
)
969 error ("function symbol is not function");
973 else if (is_a
<varpool_node
*> (this))
977 error ("variable symbol is not variable");
983 error ("node has unknown type");
987 if (symtab
->state
!= LTO_STREAMING
)
989 hashed_node
= symtab_node::get (decl
);
992 error ("node not found node->decl->decl_with_vis.symtab_node");
995 if (hashed_node
!= this
996 && (!is_a
<cgraph_node
*> (this)
997 || !dyn_cast
<cgraph_node
*> (this)->clone_of
998 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1000 error ("node differs from node->decl->decl_with_vis.symtab_node");
1004 if (symtab
->assembler_name_hash
)
1006 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1007 if (hashed_node
&& hashed_node
->previous_sharing_asm_name
)
1009 error ("assembler name hash list corrupted");
1014 if (hashed_node
== this)
1016 hashed_node
= hashed_node
->next_sharing_asm_name
;
1019 && !(is_a
<varpool_node
*> (this)
1020 && DECL_HARD_REGISTER (decl
)))
1022 error ("node not found in symtab assembler name hash");
1026 if (previous_sharing_asm_name
1027 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1029 error ("double linked list of assembler names corrupted");
1032 if (body_removed
&& definition
)
1034 error ("node has body_removed but is definition");
1037 if (analyzed
&& !definition
)
1039 error ("node is analyzed but it is not a definition");
1042 if (cpp_implicit_alias
&& !alias
)
1044 error ("node is alias but not implicit alias");
1047 if (alias
&& !definition
&& !weakref
)
1049 error ("node is alias but not definition");
1052 if (weakref
&& !transparent_alias
)
1054 error ("node is weakref but not an transparent_alias");
1057 if (transparent_alias
&& !alias
)
1059 error ("node is transparent_alias but not an alias");
1062 if (same_comdat_group
)
1064 symtab_node
*n
= same_comdat_group
;
1066 if (!n
->get_comdat_group ())
1068 error ("node is in same_comdat_group list but has no comdat_group");
1071 if (n
->get_comdat_group () != get_comdat_group ())
1073 error ("same_comdat_group list across different groups");
1076 if (n
->type
!= type
)
1078 error ("mixing different types of symbol in same comdat groups is not supported");
1083 error ("node is alone in a comdat group");
1088 if (!n
->same_comdat_group
)
1090 error ("same_comdat_group is not a circular list");
1094 n
= n
->same_comdat_group
;
1097 if (comdat_local_p ())
1099 ipa_ref
*ref
= NULL
;
1101 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1103 if (!in_same_comdat_group_p (ref
->referring
))
1105 error ("comdat-local symbol referred to by %s outside its "
1107 identifier_to_locale (ref
->referring
->name()));
1113 if (implicit_section
&& !get_section ())
1115 error ("implicit_section flag is set but section isn't");
1118 if (get_section () && get_comdat_group ()
1119 && !implicit_section
1120 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1122 error ("Both section and comdat group is set");
1125 /* TODO: Add string table for sections, so we do not keep holding duplicated
1127 if (alias
&& definition
1128 && get_section () != get_alias_target ()->get_section ()
1130 || !get_alias_target ()->get_section ()
1131 || strcmp (get_section(),
1132 get_alias_target ()->get_section ())))
1134 error ("Alias and target's section differs");
1135 get_alias_target ()->dump (stderr
);
1138 if (alias
&& definition
1139 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1141 error ("Alias and target's comdat groups differs");
1142 get_alias_target ()->dump (stderr
);
1145 if (transparent_alias
&& definition
&& !weakref
)
1147 symtab_node
*to
= get_alias_target ();
1149 = IDENTIFIER_POINTER (
1150 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1152 = IDENTIFIER_POINTER (
1153 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1154 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1156 error ("Transparent alias and target's assembler names differs");
1157 get_alias_target ()->dump (stderr
);
1161 if (transparent_alias
&& definition
1162 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1164 error ("Chained transparent aliases");
1165 get_alias_target ()->dump (stderr
);
1172 /* Verify consistency of NODE. */
1175 symtab_node::verify (void)
1180 timevar_push (TV_CGRAPH_VERIFY
);
1181 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1182 node
->verify_node ();
1187 internal_error ("symtab_node::verify failed");
1189 timevar_pop (TV_CGRAPH_VERIFY
);
1192 /* Verify symbol table for internal consistency. */
1195 symtab_node::verify_symtab_nodes (void)
1198 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1200 FOR_EACH_SYMBOL (node
)
1203 if (node
->get_comdat_group ())
1205 symtab_node
**entry
, *s
;
1208 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1212 else if (!DECL_EXTERNAL (node
->decl
))
1214 for (s
= (*entry
)->same_comdat_group
;
1215 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1216 s
= s
->same_comdat_group
)
1218 if (!s
|| s
== *entry
)
1220 error ("Two symbols with same comdat_group are not linked by "
1221 "the same_comdat_group list.");
1224 internal_error ("symtab_node::verify failed");
1231 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1232 but other code such as notice_global_symbol generates rtl. */
1235 symtab_node::make_decl_local (void)
1242 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1243 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1244 symtab
->change_decl_assembler_name
1245 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1246 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1247 DECL_ATTRIBUTES (decl
));
1249 /* Avoid clearing comdat_groups on comdat-local decls. */
1250 else if (TREE_PUBLIC (decl
) == 0)
1253 /* Localizing a symbol also make all its transparent aliases local. */
1255 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1257 struct symtab_node
*alias
= ref
->referring
;
1258 if (alias
->transparent_alias
)
1259 alias
->make_decl_local ();
1264 DECL_COMMON (decl
) = 0;
1265 /* ADDRESSABLE flag is not defined for public symbols. */
1266 TREE_ADDRESSABLE (decl
) = 1;
1267 TREE_STATIC (decl
) = 1;
1270 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1272 DECL_COMDAT (decl
) = 0;
1273 DECL_WEAK (decl
) = 0;
1274 DECL_EXTERNAL (decl
) = 0;
1275 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1276 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1277 TREE_PUBLIC (decl
) = 0;
1278 DECL_DLLIMPORT_P (decl
) = 0;
1279 if (!DECL_RTL_SET_P (decl
))
1282 /* Update rtl flags. */
1283 make_decl_rtl (decl
);
1285 rtl
= DECL_RTL (decl
);
1289 symbol
= XEXP (rtl
, 0);
1290 if (GET_CODE (symbol
) != SYMBOL_REF
)
1293 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1296 /* Copy visibility from N.
1297 This is useful when THIS becomes a transparent alias of N. */
1300 symtab_node::copy_visibility_from (symtab_node
*n
)
1302 gcc_checking_assert (n
->weakref
== weakref
);
1305 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1307 struct symtab_node
*alias
= ref
->referring
;
1308 if (alias
->transparent_alias
)
1309 alias
->copy_visibility_from (n
);
1314 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1315 /* ADDRESSABLE flag is not defined for public symbols. */
1316 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1317 TREE_ADDRESSABLE (decl
) = 1;
1318 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1320 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1322 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1323 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1324 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1325 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1326 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1327 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1328 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1329 resolution
= n
->resolution
;
1330 set_comdat_group (n
->get_comdat_group ());
1331 call_for_symbol_and_aliases (symtab_node::set_section
,
1332 const_cast<char *>(n
->get_section ()), true);
1333 externally_visible
= n
->externally_visible
;
1334 if (!DECL_RTL_SET_P (decl
))
1337 /* Update rtl flags. */
1338 make_decl_rtl (decl
);
1340 rtx rtl
= DECL_RTL (decl
);
1344 rtx symbol
= XEXP (rtl
, 0);
1345 if (GET_CODE (symbol
) != SYMBOL_REF
)
1348 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1351 /* Walk the alias chain to return the symbol NODE is alias of.
1352 If NODE is not an alias, return NODE.
1353 Assumes NODE is known to be alias. */
1356 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1359 bool transparent_p
= false;
1361 /* To determine visibility of the target, we follow ELF semantic of aliases.
1362 Here alias is an alternative assembler name of a given definition. Its
1363 availability prevails the availability of its target (i.e. static alias of
1364 weak definition is available.
1366 Transaparent alias is just alternative anme of a given symbol used within
1367 one compilation unit and is translated prior hitting the object file. It
1368 inherits the visibility of its target.
1369 Weakref is a different animal (and noweak definition is weak).
1371 If we ever get into supporting targets with different semantics, a target
1372 hook will be needed here. */
1376 transparent_p
= transparent_alias
;
1378 *availability
= get_availability (ref
);
1380 *availability
= AVAIL_NOT_AVAILABLE
;
1383 symtab_node
*node
= this;
1386 if (node
->alias
&& node
->analyzed
)
1387 node
= node
->get_alias_target ();
1390 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1392 else if (node
->analyzed
&& !node
->transparent_alias
)
1393 *availability
= node
->get_availability (ref
);
1395 *availability
= AVAIL_NOT_AVAILABLE
;
1398 if (node
&& availability
&& transparent_p
1399 && node
->transparent_alias
)
1401 *availability
= node
->get_availability (ref
);
1402 transparent_p
= false;
1406 *availability
= AVAIL_NOT_AVAILABLE
;
1410 /* C++ FE sometimes change linkage flags after producing same body aliases.
1412 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1413 are obviously equivalent. The way it is doing so is however somewhat
1414 kludgy and interferes with the visibility code. As a result we need to
1415 copy the visibility from the target to get things right. */
1418 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1420 if (is_a
<cgraph_node
*> (this))
1422 DECL_DECLARED_INLINE_P (decl
)
1423 = DECL_DECLARED_INLINE_P (target
->decl
);
1424 DECL_DISREGARD_INLINE_LIMITS (decl
)
1425 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1427 /* FIXME: It is not really clear why those flags should not be copied for
1431 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1432 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1433 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1435 if (TREE_PUBLIC (decl
))
1439 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1440 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1441 group
= target
->get_comdat_group ();
1442 set_comdat_group (group
);
1443 if (group
&& !same_comdat_group
)
1444 add_to_same_comdat_group (target
);
1446 externally_visible
= target
->externally_visible
;
1449 /* Set section, do not recurse into aliases.
1450 When one wants to change section of a symbol and its aliases,
1454 symtab_node::set_section_for_node (const char *section
)
1456 const char *current
= get_section ();
1457 section_hash_entry
**slot
;
1459 if (current
== section
1460 || (current
&& section
1461 && !strcmp (current
, section
)))
1466 x_section
->ref_count
--;
1467 if (!x_section
->ref_count
)
1469 hashval_t hash
= htab_hash_string (x_section
->name
);
1470 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1472 ggc_free (x_section
);
1473 symtab
->section_hash
->clear_slot (slot
);
1479 implicit_section
= false;
1482 if (!symtab
->section_hash
)
1483 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1484 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1485 htab_hash_string (section
),
1488 x_section
= (section_hash_entry
*)*slot
;
1491 int len
= strlen (section
);
1492 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1493 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1494 memcpy (x_section
->name
, section
, len
+ 1);
1496 x_section
->ref_count
++;
1499 /* Worker for set_section. */
1502 symtab_node::set_section (symtab_node
*n
, void *s
)
1504 n
->set_section_for_node ((char *)s
);
1508 /* Set section of symbol and its aliases. */
1511 symtab_node::set_section (const char *section
)
1513 gcc_assert (!this->alias
);
1514 call_for_symbol_and_aliases
1515 (symtab_node::set_section
, const_cast<char *>(section
), true);
1518 /* Return the initialization priority. */
1521 symtab_node::get_init_priority ()
1523 if (!this->in_init_priority_hash
)
1524 return DEFAULT_INIT_PRIORITY
;
1526 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1527 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1530 /* Return the finalization priority. */
1533 cgraph_node::get_fini_priority ()
1535 if (!this->in_init_priority_hash
)
1536 return DEFAULT_INIT_PRIORITY
;
1537 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1538 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1541 /* Return the initialization and finalization priority information for
1542 DECL. If there is no previous priority information, a freshly
1543 allocated structure is returned. */
1545 symbol_priority_map
*
1546 symtab_node::priority_info (void)
1548 if (!symtab
->init_priority_hash
)
1549 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1552 symbol_priority_map
*h
1553 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1556 h
->init
= DEFAULT_INIT_PRIORITY
;
1557 h
->fini
= DEFAULT_INIT_PRIORITY
;
1558 in_init_priority_hash
= true;
1564 /* Set initialization priority to PRIORITY. */
1567 symtab_node::set_init_priority (priority_type priority
)
1569 symbol_priority_map
*h
;
1571 if (is_a
<cgraph_node
*> (this))
1572 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1574 if (priority
== DEFAULT_INIT_PRIORITY
)
1576 gcc_assert (get_init_priority() == priority
);
1579 h
= priority_info ();
1583 /* Set fialization priority to PRIORITY. */
1586 cgraph_node::set_fini_priority (priority_type priority
)
1588 symbol_priority_map
*h
;
1590 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1592 if (priority
== DEFAULT_INIT_PRIORITY
)
1594 gcc_assert (get_fini_priority() == priority
);
1597 h
= priority_info ();
1601 /* Worker for symtab_resolve_alias. */
1604 symtab_node::set_implicit_section (symtab_node
*n
,
1605 void *data ATTRIBUTE_UNUSED
)
1607 n
->implicit_section
= true;
1611 /* Add reference recording that symtab node is alias of TARGET.
1612 The function can fail in the case of aliasing cycles; in this case
1613 it returns false. */
1616 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1620 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1622 /* Never let cycles to creep into the symbol table alias references;
1623 those will make alias walkers to be infinite. */
1624 for (n
= target
; n
&& n
->alias
;
1625 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1628 if (is_a
<cgraph_node
*> (this))
1629 error ("function %q+D part of alias cycle", decl
);
1630 else if (is_a
<varpool_node
*> (this))
1631 error ("variable %q+D part of alias cycle", decl
);
1638 /* "analyze" the node - i.e. mark the reference. */
1642 transparent
|= transparent_alias
;
1643 transparent_alias
= transparent
;
1645 while (target
->transparent_alias
&& target
->analyzed
)
1646 target
= target
->get_alias_target ();
1647 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1649 /* Add alias into the comdat group of its target unless it is already there. */
1650 if (same_comdat_group
)
1651 remove_from_same_comdat_group ();
1652 set_comdat_group (NULL
);
1653 if (target
->get_comdat_group ())
1654 add_to_same_comdat_group (target
);
1656 if ((get_section () != target
->get_section ()
1657 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1659 error ("section of alias %q+D must match section of its target", decl
);
1661 call_for_symbol_and_aliases (symtab_node::set_section
,
1662 const_cast<char *>(target
->get_section ()), true);
1663 if (target
->implicit_section
)
1664 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1666 /* Alias targets become redundant after alias is resolved into an reference.
1667 We do not want to keep it around or we would have to mind updating them
1668 when renaming symbols. */
1669 alias_target
= NULL
;
1671 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1672 fixup_same_cpp_alias_visibility (target
);
1674 /* If alias has address taken, so does the target. */
1676 target
->ultimate_alias_target ()->address_taken
= true;
1678 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1679 If alias is transparent, also all transparent aliases of THIS are now
1681 Also merge same comdat group lists. */
1683 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1685 struct symtab_node
*alias_alias
= ref
->referring
;
1686 if (alias_alias
->get_comdat_group ())
1688 alias_alias
->remove_from_same_comdat_group ();
1689 alias_alias
->set_comdat_group (NULL
);
1690 if (target
->get_comdat_group ())
1691 alias_alias
->add_to_same_comdat_group (target
);
1693 if (!alias_alias
->transparent_alias
|| transparent
)
1695 alias_alias
->remove_all_references ();
1696 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1703 /* Worker searching noninterposable alias. */
1706 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1708 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1710 symtab_node
*fn
= node
->ultimate_alias_target ();
1712 /* Ensure that the alias is well formed this may not be the case
1713 of user defined aliases and currently it is not always the case
1714 of C++ same body aliases (that is a bug). */
1715 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1716 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1717 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1718 && flags_from_decl_or_type (node
->decl
)
1719 != flags_from_decl_or_type (fn
->decl
))
1720 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1722 *(symtab_node
**)data
= node
;
1728 /* If node can not be overwriten by static or dynamic linker to point to
1729 different definition, return NODE. Otherwise look for alias with such
1730 property and if none exists, introduce new one. */
1733 symtab_node::noninterposable_alias (void)
1736 symtab_node
*new_node
= NULL
;
1738 /* First try to look up existing alias or base object
1739 (if that is already non-overwritable). */
1740 symtab_node
*node
= ultimate_alias_target ();
1741 gcc_assert (!node
->alias
&& !node
->weakref
);
1742 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1743 (void *)&new_node
, true);
1746 #ifndef ASM_OUTPUT_DEF
1747 /* If aliases aren't supported by the assembler, fail. */
1751 /* Otherwise create a new one. */
1752 new_decl
= copy_node (node
->decl
);
1753 DECL_DLLIMPORT_P (new_decl
) = 0;
1754 DECL_NAME (new_decl
) = clone_function_name (node
->decl
, "localalias");
1755 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1756 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1757 DECL_INITIAL (new_decl
) = NULL
;
1758 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1759 SET_DECL_RTL (new_decl
, NULL
);
1761 /* Update the properties. */
1762 DECL_EXTERNAL (new_decl
) = 0;
1763 TREE_PUBLIC (new_decl
) = 0;
1764 DECL_COMDAT (new_decl
) = 0;
1765 DECL_WEAK (new_decl
) = 0;
1767 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1768 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1769 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1771 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1772 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1773 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1777 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1778 DECL_INITIAL (new_decl
) = error_mark_node
;
1779 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1781 new_node
->resolve_alias (node
);
1782 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1783 && targetm
.binds_local_p (new_decl
));
1787 /* Return true if symtab node and TARGET represents
1788 semantically equivalent symbols. */
1791 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1793 enum availability avail
;
1797 /* Equivalent functions are equivalent. */
1798 if (decl
== target
->decl
)
1801 /* If symbol is not overwritable by different implementation,
1802 walk to the base object it defines. */
1803 ba
= ultimate_alias_target (&avail
);
1804 if (avail
>= AVAIL_AVAILABLE
)
1811 bb
= target
->ultimate_alias_target (&avail
);
1812 if (avail
>= AVAIL_AVAILABLE
)
1822 /* Classify symbol symtab node for partitioning. */
1824 enum symbol_partitioning_class
1825 symtab_node::get_partitioning_class (void)
1827 /* Inline clones are always duplicated.
1828 This include external delcarations. */
1829 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
1831 if (DECL_ABSTRACT_P (decl
))
1832 return SYMBOL_EXTERNAL
;
1834 if (cnode
&& cnode
->global
.inlined_to
)
1835 return SYMBOL_DUPLICATE
;
1837 /* Transparent aliases are always duplicated. */
1838 if (transparent_alias
)
1839 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
1841 /* External declarations are external. */
1842 if (DECL_EXTERNAL (decl
))
1843 return SYMBOL_EXTERNAL
;
1845 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1847 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
1848 return SYMBOL_EXTERNAL
;
1849 /* Constant pool references use local symbol names that can not
1850 be promoted global. We should never put into a constant pool
1851 objects that can not be duplicated across partitions. */
1852 if (DECL_IN_CONSTANT_POOL (decl
))
1853 return SYMBOL_DUPLICATE
;
1854 if (DECL_HARD_REGISTER (decl
))
1855 return SYMBOL_DUPLICATE
;
1856 gcc_checking_assert (vnode
->definition
);
1858 /* Functions that are cloned may stay in callgraph even if they are unused.
1859 Handle them as external; compute_ltrans_boundary take care to make
1860 proper things to happen (i.e. to make them appear in the boundary but
1861 with body streamed, so clone can me materialized). */
1862 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
1863 return SYMBOL_EXTERNAL
;
1865 /* Linker discardable symbols are duplicated to every use unless they are
1867 if (DECL_ONE_ONLY (decl
)
1870 && !used_from_object_file_p ())
1871 return SYMBOL_DUPLICATE
;
1873 return SYMBOL_PARTITION
;
1876 /* Return true when symbol is known to be non-zero. */
1879 symtab_node::nonzero_address ()
1881 /* Weakrefs may be NULL when their target is not defined. */
1882 if (alias
&& weakref
)
1886 symtab_node
*target
= ultimate_alias_target ();
1888 if (target
->alias
&& target
->weakref
)
1890 /* We can not recurse to target::nonzero. It is possible that the
1891 target is used only via the alias.
1892 We may walk references and look for strong use, but we do not know
1893 if this strong use will survive to final binary, so be
1895 ??? Maybe we could do the lookup during late optimization that
1896 could be useful to eliminate the NULL pointer checks in LTO
1898 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
1900 if (target
->resolution
!= LDPR_UNKNOWN
1901 && target
->resolution
!= LDPR_UNDEF
1902 && !target
->can_be_discarded_p ()
1903 && flag_delete_null_pointer_checks
)
1911 /* With !flag_delete_null_pointer_checks we assume that symbols may
1912 bind to NULL. This is on by default on embedded targets only.
1914 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
1915 linking fails. Important case of WEAK we want to do well are comdats.
1916 Those are handled by later check for definition.
1918 When parsing, beware the cases when WEAK attribute is added later. */
1919 if (!DECL_WEAK (decl
)
1920 && flag_delete_null_pointer_checks
)
1922 refuse_visibility_changes
= true;
1926 /* If target is defined and not extern, we know it will be output and thus
1927 it will bind to non-NULL.
1928 Play safe for flag_delete_null_pointer_checks where weak definition maye
1929 be re-defined by NULL. */
1930 if (definition
&& !DECL_EXTERNAL (decl
)
1931 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
1933 if (!DECL_WEAK (decl
))
1934 refuse_visibility_changes
= true;
1938 /* As the last resort, check the resolution info. */
1939 if (resolution
!= LDPR_UNKNOWN
1940 && resolution
!= LDPR_UNDEF
1941 && !can_be_discarded_p ()
1942 && flag_delete_null_pointer_checks
)
1947 /* Return 0 if symbol is known to have different address than S2,
1948 Return 1 if symbol is known to have same address as S2,
1949 return -1 otherwise.
1951 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
1952 and S2 is going to be accessed. This eliminates the situations when
1953 either THIS or S2 is NULL and is seful for comparing bases when deciding
1954 about memory aliasing. */
1956 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
1958 enum availability avail1
, avail2
;
1960 /* A Shortcut: equivalent symbols are always equivalent. */
1964 /* Unwind transparent aliases first; those are always equal to their
1966 if (this->transparent_alias
&& this->analyzed
)
1967 return this->get_alias_target ()->equal_address_to (s2
);
1968 while (s2
->transparent_alias
&& s2
->analyzed
)
1969 s2
= s2
->get_alias_target();
1974 /* For non-interposable aliases, lookup and compare their actual definitions.
1975 Also check if the symbol needs to bind to given definition. */
1976 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
1977 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
1978 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
1979 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
1980 bool really_binds_local1
= binds_local1
;
1981 bool really_binds_local2
= binds_local2
;
1983 /* Addresses of vtables and virtual functions can not be used by user
1984 code and are used only within speculation. In this case we may make
1985 symbol equivalent to its alias even if interposition may break this
1986 rule. Doing so will allow us to turn speculative inlining into
1987 non-speculative more agressively. */
1988 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
1989 binds_local1
= true;
1990 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
1991 binds_local2
= true;
1993 /* If both definitions are available we know that even if they are bound
1994 to other unit they must be defined same way and therefore we can use
1995 equivalence test. */
1996 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
1997 binds_local1
= binds_local2
= true;
1999 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2001 /* We made use of the fact that alias is not weak. */
2003 refuse_visibility_changes
= true;
2005 s2
->refuse_visibility_changes
= true;
2009 /* If both symbols may resolve to NULL, we can not really prove them
2011 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2014 /* Except for NULL, functions and variables never overlap. */
2015 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2018 /* If one of the symbols is unresolved alias, punt. */
2019 if (rs1
->alias
|| rs2
->alias
)
2022 /* If we have a non-interposale definition of at least one of the symbols
2023 and the other symbol is different, we know other unit can not interpose
2024 it to the first symbol; all aliases of the definition needs to be
2025 present in the current unit. */
2026 if (((really_binds_local1
|| really_binds_local2
)
2027 /* If we have both definitions and they are different, we know they
2028 will be different even in units they binds to. */
2029 || (binds_local1
&& binds_local2
))
2032 /* We make use of the fact that one symbol is not alias of the other
2033 and that the definition is non-interposable. */
2034 refuse_visibility_changes
= true;
2035 s2
->refuse_visibility_changes
= true;
2036 rs1
->refuse_visibility_changes
= true;
2037 rs2
->refuse_visibility_changes
= true;
2041 /* TODO: Alias oracle basically assume that addresses of global variables
2042 are different unless they are declared as alias of one to another while
2043 the code folding comparsions doesn't.
2044 We probably should be consistent and use this fact here, too, but for
2045 the moment return false only when we are called from the alias oracle. */
2047 return memory_accessed
&& rs1
!= rs2
? 0 : -1;
2050 /* Worker for call_for_symbol_and_aliases. */
2053 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2056 bool include_overwritable
)
2059 FOR_EACH_ALIAS (this, ref
)
2061 symtab_node
*alias
= ref
->referring
;
2062 if (include_overwritable
2063 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2064 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2065 include_overwritable
))
2071 /* Return true if address of N is possibly compared. */
2074 address_matters_1 (symtab_node
*n
, void *)
2076 struct ipa_ref
*ref
;
2078 if (!n
->address_can_be_compared_p ())
2080 if (n
->externally_visible
|| n
->force_output
)
2083 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2084 if (ref
->address_matters_p ())
2089 /* Return true if symbol's address may possibly be compared to other
2090 symbol's address. */
2093 symtab_node::address_matters_p ()
2095 gcc_assert (!alias
);
2096 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2099 /* Return true if symbol's alignment may be increased. */
2102 symtab_node::can_increase_alignment_p (void)
2104 symtab_node
*target
= ultimate_alias_target ();
2106 /* For now support only variables. */
2110 /* With -fno-toplevel-reorder we may have already output the constant. */
2111 if (TREE_ASM_WRITTEN (target
->decl
))
2114 /* If target is already placed in an anchor, we can not touch its
2116 if (DECL_RTL_SET_P (target
->decl
)
2117 && MEM_P (DECL_RTL (target
->decl
))
2118 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2121 /* Constant pool entries may be shared. */
2122 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2125 /* We cannot change alignment of symbols that may bind to symbols
2126 in other translation unit that may contain a definition with lower
2128 if (!decl_binds_to_current_def_p (decl
))
2131 /* When compiling partition, be sure the symbol is not output by other
2134 && (target
->in_other_partition
2135 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2138 /* Do not override the alignment as specified by the ABI when the used
2139 attribute is set. */
2140 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2143 /* Do not override explicit alignment set by the user when an explicit
2144 section name is also used. This is a common idiom used by many
2145 software projects. */
2146 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2152 /* Worker for symtab_node::increase_alignment. */
2155 increase_alignment_1 (symtab_node
*n
, void *v
)
2157 unsigned int align
= (size_t)v
;
2158 if (DECL_ALIGN (n
->decl
) < align
2159 && n
->can_increase_alignment_p ())
2161 SET_DECL_ALIGN (n
->decl
, align
);
2162 DECL_USER_ALIGN (n
->decl
) = 1;
2167 /* Increase alignment of THIS to ALIGN. */
2170 symtab_node::increase_alignment (unsigned int align
)
2172 gcc_assert (can_increase_alignment_p () && align
< MAX_OFILE_ALIGNMENT
);
2173 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2174 (void *)(size_t) align
,
2176 gcc_assert (DECL_ALIGN (decl
) >= align
);
2179 /* Helper for symtab_node::definition_alignment. */
2182 get_alignment_1 (symtab_node
*n
, void *v
)
2184 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2188 /* Return desired alignment of the definition. This is NOT alignment useful
2189 to access THIS, because THIS may be interposable and DECL_ALIGN should
2190 be used instead. It however must be guaranteed when output definition
2194 symtab_node::definition_alignment ()
2196 unsigned int align
= 0;
2197 gcc_assert (!alias
);
2198 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2202 /* Return symbol used to separate symbol name from suffix. */
2205 symbol_table::symbol_suffix_separator ()
2207 #ifndef NO_DOT_IN_LABEL
2209 #elif !defined NO_DOLLAR_IN_LABEL
2216 /* Return true when references to this symbol from REF must bind to current
2217 definition in final executable. */
2220 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2224 if (transparent_alias
)
2226 && get_alias_target()->binds_to_current_def_p (ref
);
2227 if (decl_binds_to_current_def_p (decl
))
2230 /* Inline clones always binds locally. */
2231 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2232 if (cnode
&& cnode
->global
.inlined_to
)
2235 if (DECL_EXTERNAL (decl
))
2238 gcc_assert (externally_visible
);
2242 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2244 ref
= cref
->global
.inlined_to
;
2247 /* If this is a reference from symbol itself and there are no aliases, we
2248 may be sure that the symbol was not interposed by something else because
2249 the symbol itself would be unreachable otherwise. This is important
2250 to optimize recursive functions well.
2252 This assumption may be broken by inlining: if symbol is interposable
2253 but the body is available (i.e. declared inline), inliner may make
2254 the body reachable even with interposition. */
2255 if (this == ref
&& !has_aliases_p ()
2257 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2258 || get_availability () >= AVAIL_INTERPOSABLE
))
2262 /* References within one comdat group are always bound in a group. */
2264 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2265 && get_comdat_group ()
2266 && get_comdat_group () == ref
->get_comdat_group ())