2 Copyright (C) 2012-2015 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"
33 #include "fold-const.h"
34 #include "print-tree.h"
37 #include "hard-reg-set.h"
42 #include "basic-block.h"
43 #include "tree-ssa-alias.h"
44 #include "internal-fn.h"
45 #include "gimple-expr.h"
48 #include "tree-inline.h"
49 #include "langhooks.h"
51 #include "plugin-api.h"
54 #include "diagnostic.h"
56 #include "lto-streamer.h"
58 #include "ipa-utils.h"
61 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias","chkp"};
63 const char * const ld_plugin_symbol_resolution_names
[]=
68 "prevailing_def_ironly",
74 "prevailing_def_ironly_exp"
77 /* Hash asmnames ignoring the user specified marks. */
80 symbol_table::decl_assembler_name_hash (const_tree asmname
)
82 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
84 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
85 size_t ulp_len
= strlen (user_label_prefix
);
89 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
92 return htab_hash_string (decl_str
);
95 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
99 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
102 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
104 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
105 const char *decl_str
;
106 const char *asmname_str
;
109 if (decl_asmname
== asmname
)
112 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
113 asmname_str
= IDENTIFIER_POINTER (asmname
);
116 /* If the target assembler name was set by the user, things are trickier.
117 We have a leading '*' to begin with. After that, it's arguable what
118 is the correct thing to do with -fleading-underscore. Arguably, we've
119 historically been doing the wrong thing in assemble_alias by always
120 printing the leading underscore. Since we're not changing that, make
121 sure user_label_prefix follows the '*' before matching. */
122 if (decl_str
[0] == '*')
124 size_t ulp_len
= strlen (user_label_prefix
);
130 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
131 decl_str
+= ulp_len
, test
=true;
135 if (asmname_str
[0] == '*')
137 size_t ulp_len
= strlen (user_label_prefix
);
143 else if (strncmp (asmname_str
, user_label_prefix
, ulp_len
) == 0)
144 asmname_str
+= ulp_len
, test
=true;
151 return strcmp (decl_str
, asmname_str
) == 0;
155 /* Returns nonzero if P1 and P2 are equal. */
157 /* Insert NODE to assembler name hash. */
160 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
163 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
165 gcc_checking_assert (!node
->previous_sharing_asm_name
166 && !node
->next_sharing_asm_name
);
167 if (assembler_name_hash
)
171 tree decl
= node
->decl
;
173 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
175 /* C++ FE can produce decls without associated assembler name and insert
176 them to symtab to hold section or TLS information. */
180 hashval_t hash
= decl_assembler_name_hash (name
);
181 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
182 gcc_assert (*aslot
!= node
);
183 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
185 (*aslot
)->previous_sharing_asm_name
= node
;
188 /* Update also possible inline clones sharing a decl. */
189 cnode
= dyn_cast
<cgraph_node
*> (node
);
190 if (cnode
&& cnode
->clones
&& with_clones
)
191 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
192 if (cnode
->decl
== decl
)
193 insert_to_assembler_name_hash (cnode
, true);
198 /* Remove NODE from assembler name hash. */
201 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
204 if (assembler_name_hash
)
207 tree decl
= node
->decl
;
209 if (node
->next_sharing_asm_name
)
210 node
->next_sharing_asm_name
->previous_sharing_asm_name
211 = node
->previous_sharing_asm_name
;
212 if (node
->previous_sharing_asm_name
)
214 node
->previous_sharing_asm_name
->next_sharing_asm_name
215 = node
->next_sharing_asm_name
;
219 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
225 hashval_t hash
= decl_assembler_name_hash (name
);
226 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
228 gcc_assert (*slot
== node
);
229 if (!node
->next_sharing_asm_name
)
230 assembler_name_hash
->clear_slot (slot
);
232 *slot
= node
->next_sharing_asm_name
;
234 node
->next_sharing_asm_name
= NULL
;
235 node
->previous_sharing_asm_name
= NULL
;
237 /* Update also possible inline clones sharing a decl. */
238 cnode
= dyn_cast
<cgraph_node
*> (node
);
239 if (cnode
&& cnode
->clones
&& with_clones
)
240 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
241 if (cnode
->decl
== decl
)
242 unlink_from_assembler_name_hash (cnode
, true);
246 /* Arrange node to be first in its entry of assembler_name_hash. */
249 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
251 unlink_from_assembler_name_hash (node
, false);
252 insert_to_assembler_name_hash (node
, false);
255 /* Initalize asm name hash unless. */
258 symbol_table::symtab_initialize_asm_name_hash (void)
261 if (!assembler_name_hash
)
263 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
264 FOR_EACH_SYMBOL (node
)
265 insert_to_assembler_name_hash (node
, false);
269 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
272 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
274 symtab_node
*node
= NULL
;
276 /* We can have user ASM names on things, like global register variables, that
277 are not in the symbol table. */
278 if ((TREE_CODE (decl
) == VAR_DECL
279 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
280 || TREE_CODE (decl
) == FUNCTION_DECL
)
281 node
= symtab_node::get (decl
);
282 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
284 SET_DECL_ASSEMBLER_NAME (decl
, name
);
286 insert_to_assembler_name_hash (node
, true);
290 if (name
== DECL_ASSEMBLER_NAME (decl
))
293 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
297 unlink_from_assembler_name_hash (node
, true);
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
;
309 insert_to_assembler_name_hash (node
, true);
313 /* Hash sections by their names. */
316 section_name_hasher::hash (section_hash_entry
*n
)
318 return htab_hash_string (n
->name
);
321 /* Return true if section P1 name equals to P2. */
324 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
326 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
329 /* Add node into symbol table. This function is not used directly, but via
330 cgraph/varpool node creation routines. */
333 symtab_node::register_symbol (void)
335 symtab
->register_symbol (this);
337 if (!decl
->decl_with_vis
.symtab_node
)
338 decl
->decl_with_vis
.symtab_node
= this;
342 /* Be sure to do this last; C++ FE might create new nodes via
343 DECL_ASSEMBLER_NAME langhook! */
344 symtab
->insert_to_assembler_name_hash (this, false);
347 /* Remove NODE from same comdat group. */
350 symtab_node::remove_from_same_comdat_group (void)
352 if (same_comdat_group
)
355 for (prev
= same_comdat_group
;
356 prev
->same_comdat_group
!= this;
357 prev
= prev
->same_comdat_group
)
359 if (same_comdat_group
== prev
)
360 prev
->same_comdat_group
= NULL
;
362 prev
->same_comdat_group
= same_comdat_group
;
363 same_comdat_group
= NULL
;
364 set_comdat_group (NULL
);
368 /* Remove node from symbol table. This function is not used directly, but via
369 cgraph/varpool node removal routines. */
372 symtab_node::unregister (void)
374 remove_all_references ();
375 remove_all_referring ();
377 /* Remove reference to section. */
378 set_section_for_node (NULL
);
380 remove_from_same_comdat_group ();
382 symtab
->unregister (this);
384 /* During LTO symtab merging we temporarily corrupt decl to symtab node
386 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
387 if (decl
->decl_with_vis
.symtab_node
== this)
389 symtab_node
*replacement_node
= NULL
;
390 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
391 replacement_node
= cnode
->find_replacement ();
392 decl
->decl_with_vis
.symtab_node
= replacement_node
;
394 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
395 symtab
->unlink_from_assembler_name_hash (this, false);
396 if (in_init_priority_hash
)
397 symtab
->init_priority_hash
->remove (this);
401 /* Remove symbol from symbol table. */
404 symtab_node::remove (void)
406 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
408 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
412 /* Add NEW_ to the same comdat group that OLD is in. */
415 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
417 gcc_assert (old_node
->get_comdat_group ());
418 gcc_assert (!same_comdat_group
);
419 gcc_assert (this != old_node
);
421 set_comdat_group (old_node
->get_comdat_group ());
422 same_comdat_group
= old_node
;
423 if (!old_node
->same_comdat_group
)
424 old_node
->same_comdat_group
= this;
428 for (n
= old_node
->same_comdat_group
;
429 n
->same_comdat_group
!= old_node
;
430 n
= n
->same_comdat_group
)
432 n
->same_comdat_group
= this;
436 /* Dissolve the same_comdat_group list in which NODE resides. */
439 symtab_node::dissolve_same_comdat_group_list (void)
441 symtab_node
*n
= this;
444 if (!same_comdat_group
)
448 next
= n
->same_comdat_group
;
449 n
->same_comdat_group
= NULL
;
450 /* Clear comdat_group for comdat locals, since
451 make_decl_local doesn't. */
452 if (!TREE_PUBLIC (n
->decl
))
453 n
->set_comdat_group (NULL
);
459 /* Return printable assembler name of NODE.
460 This function is used only for debugging. When assembler name
461 is unknown go with identifier name. */
464 symtab_node::asm_name () const
466 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
467 return lang_hooks
.decl_printable_name (decl
, 2);
468 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
471 /* Return printable identifier name. */
474 symtab_node::name () const
476 return lang_hooks
.decl_printable_name (decl
, 2);
479 /* Return ipa reference from this symtab_node to
480 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
484 symtab_node::create_reference (symtab_node
*referred_node
,
485 enum ipa_ref_use use_type
)
487 return create_reference (referred_node
, use_type
, NULL
);
491 /* Return ipa reference from this symtab_node to
492 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
493 of the use and STMT the statement (if it exists). */
496 symtab_node::create_reference (symtab_node
*referred_node
,
497 enum ipa_ref_use use_type
, gimple stmt
)
499 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
500 ipa_ref_list
*list
, *list2
;
501 ipa_ref_t
*old_references
;
503 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
504 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
507 old_references
= vec_safe_address (list
->references
);
508 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1);
509 ref
= &list
->references
->last ();
511 list2
= &referred_node
->ref_list
;
513 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
514 if(use_type
== IPA_REF_ALIAS
)
516 list2
->referring
.safe_insert (0, ref
);
517 ref
->referred_index
= 0;
519 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
520 list2
->referring
[i
]->referred_index
= i
;
524 list2
->referring
.safe_push (ref
);
525 ref
->referred_index
= list2
->referring
.length () - 1;
528 ref
->referring
= this;
529 ref
->referred
= referred_node
;
531 ref
->lto_stmt_uid
= 0;
533 ref
->speculative
= 0;
535 /* If vector was moved in memory, update pointers. */
536 if (old_references
!= list
->references
->address ())
539 for (i
= 0; iterate_reference(i
, ref2
); i
++)
540 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
545 /* If VAL is a reference to a function or a variable, add a reference from
546 this symtab_node to the corresponding symbol table node. USE_TYPE specify
547 type of the use and STMT the statement (if it exists). Return the new
548 reference or NULL if none was created. */
551 symtab_node::maybe_create_reference (tree val
, enum ipa_ref_use use_type
,
555 if (TREE_CODE (val
) != ADDR_EXPR
)
557 val
= get_base_var (val
);
558 if (val
&& (TREE_CODE (val
) == FUNCTION_DECL
559 || TREE_CODE (val
) == VAR_DECL
))
561 symtab_node
*referred
= symtab_node::get (val
);
562 gcc_checking_assert (referred
);
563 return create_reference (referred
, use_type
, stmt
);
568 /* Clone all references from symtab NODE to this symtab_node. */
571 symtab_node::clone_references (symtab_node
*node
)
573 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
575 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
577 bool speculative
= ref
->speculative
;
578 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
580 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
581 ref2
->speculative
= speculative
;
582 ref2
->lto_stmt_uid
= stmt_uid
;
586 /* Clone all referring from symtab NODE to this symtab_node. */
589 symtab_node::clone_referring (symtab_node
*node
)
591 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
593 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
595 bool speculative
= ref
->speculative
;
596 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
598 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
599 ref2
->speculative
= speculative
;
600 ref2
->lto_stmt_uid
= stmt_uid
;
604 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
607 symtab_node::clone_reference (ipa_ref
*ref
, gimple stmt
)
609 bool speculative
= ref
->speculative
;
610 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
613 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
614 ref2
->speculative
= speculative
;
615 ref2
->lto_stmt_uid
= stmt_uid
;
619 /* Find the structure describing a reference to REFERRED_NODE
620 and associated with statement STMT. */
623 symtab_node::find_reference (symtab_node
*referred_node
,
624 gimple stmt
, unsigned int lto_stmt_uid
)
629 for (i
= 0; iterate_reference (i
, r
); i
++)
630 if (r
->referred
== referred_node
632 && ((stmt
&& r
->stmt
== stmt
)
633 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
634 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
639 /* Remove all references that are associated with statement STMT. */
642 symtab_node::remove_stmt_references (gimple stmt
)
647 while (iterate_reference (i
, r
))
649 r
->remove_reference ();
654 /* Remove all stmt references in non-speculative references.
655 Those are not maintained during inlining & clonning.
656 The exception are speculative references that are updated along
657 with callgraph edges associated with them. */
660 symtab_node::clear_stmts_in_references (void)
665 for (i
= 0; iterate_reference (i
, r
); i
++)
673 /* Remove all references in ref list. */
676 symtab_node::remove_all_references (void)
678 while (vec_safe_length (ref_list
.references
))
679 ref_list
.references
->last ().remove_reference ();
680 vec_free (ref_list
.references
);
683 /* Remove all referring items in ref list. */
686 symtab_node::remove_all_referring (void)
688 while (ref_list
.referring
.length ())
689 ref_list
.referring
.last ()->remove_reference ();
690 ref_list
.referring
.release ();
693 /* Dump references in ref list to FILE. */
696 symtab_node::dump_references (FILE *file
)
700 for (i
= 0; iterate_reference (i
, ref
); i
++)
702 fprintf (file
, "%s/%i (%s)",
703 ref
->referred
->asm_name (),
704 ref
->referred
->order
,
705 ipa_ref_use_name
[ref
->use
]);
706 if (ref
->speculative
)
707 fprintf (file
, " (speculative)");
709 fprintf (file
, "\n");
712 /* Dump referring in list to FILE. */
715 symtab_node::dump_referring (FILE *file
)
719 for (i
= 0; iterate_referring(i
, ref
); i
++)
721 fprintf (file
, "%s/%i (%s)",
722 ref
->referring
->asm_name (),
723 ref
->referring
->order
,
724 ipa_ref_use_name
[ref
->use
]);
725 if (ref
->speculative
)
726 fprintf (file
, " (speculative)");
728 fprintf (file
, "\n");
731 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
733 /* Dump base fields of symtab nodes to F. Not to be used directly. */
736 symtab_node::dump_base (FILE *f
)
738 static const char * const visibility_types
[] = {
739 "default", "protected", "hidden", "internal"
742 fprintf (f
, "%s/%i (%s)", asm_name (), order
, name ());
743 dump_addr (f
, " @", (void *)this);
744 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
747 fprintf (f
, " definition");
749 fprintf (f
, " analyzed");
751 fprintf (f
, " alias");
753 fprintf (f
, " weakref");
754 if (cpp_implicit_alias
)
755 fprintf (f
, " cpp_implicit_alias");
757 fprintf (f
, " target:%s",
758 DECL_P (alias_target
)
759 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
761 : IDENTIFIER_POINTER (alias_target
));
763 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
764 fprintf (f
, "\n Visibility:");
765 if (in_other_partition
)
766 fprintf (f
, " in_other_partition");
767 if (used_from_other_partition
)
768 fprintf (f
, " used_from_other_partition");
770 fprintf (f
, " force_output");
772 fprintf (f
, " forced_by_abi");
773 if (externally_visible
)
774 fprintf (f
, " externally_visible");
776 fprintf (f
, " no_reorder");
777 if (resolution
!= LDPR_UNKNOWN
)
779 ld_plugin_symbol_resolution_names
[(int)resolution
]);
780 if (TREE_ASM_WRITTEN (decl
))
781 fprintf (f
, " asm_written");
782 if (DECL_EXTERNAL (decl
))
783 fprintf (f
, " external");
784 if (TREE_PUBLIC (decl
))
785 fprintf (f
, " public");
786 if (DECL_COMMON (decl
))
787 fprintf (f
, " common");
788 if (DECL_WEAK (decl
))
789 fprintf (f
, " weak");
790 if (DECL_DLLIMPORT_P (decl
))
791 fprintf (f
, " dll_import");
792 if (DECL_COMDAT (decl
))
793 fprintf (f
, " comdat");
794 if (get_comdat_group ())
795 fprintf (f
, " comdat_group:%s",
796 IDENTIFIER_POINTER (get_comdat_group_id ()));
797 if (DECL_ONE_ONLY (decl
))
798 fprintf (f
, " one_only");
800 fprintf (f
, " section:%s",
802 if (implicit_section
)
803 fprintf (f
," (implicit_section)");
804 if (DECL_VISIBILITY_SPECIFIED (decl
))
805 fprintf (f
, " visibility_specified");
806 if (DECL_VISIBILITY (decl
))
807 fprintf (f
, " visibility:%s",
808 visibility_types
[DECL_VISIBILITY (decl
)]);
809 if (DECL_VIRTUAL_P (decl
))
810 fprintf (f
, " virtual");
811 if (DECL_ARTIFICIAL (decl
))
812 fprintf (f
, " artificial");
813 if (TREE_CODE (decl
) == FUNCTION_DECL
)
815 if (DECL_STATIC_CONSTRUCTOR (decl
))
816 fprintf (f
, " constructor");
817 if (DECL_STATIC_DESTRUCTOR (decl
))
818 fprintf (f
, " destructor");
822 if (same_comdat_group
)
823 fprintf (f
, " Same comdat group as: %s/%i\n",
824 same_comdat_group
->asm_name (),
825 same_comdat_group
->order
);
826 if (next_sharing_asm_name
)
827 fprintf (f
, " next sharing asm name: %i\n",
828 next_sharing_asm_name
->order
);
829 if (previous_sharing_asm_name
)
830 fprintf (f
, " previous sharing asm name: %i\n",
831 previous_sharing_asm_name
->order
);
834 fprintf (f
, " Address is taken.\n");
837 fprintf (f
, " Aux:");
838 dump_addr (f
, " @", (void *)aux
);
841 fprintf (f
, " References: ");
843 fprintf (f
, " Referring: ");
846 fprintf (f
, " Read from file: %s\n",
847 lto_file_data
->file_name
);
850 /* Dump symtab node to F. */
853 symtab_node::dump (FILE *f
)
855 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
857 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
861 /* Dump symbol table to F. */
864 symtab_node::dump_table (FILE *f
)
867 fprintf (f
, "Symbol table:\n\n");
868 FOR_EACH_SYMBOL (node
)
873 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
874 Return NULL if there's no such node. */
877 symtab_node::get_for_asmname (const_tree asmname
)
881 symtab
->symtab_initialize_asm_name_hash ();
882 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
884 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
895 /* Dump symtab node NODE to stderr. */
898 symtab_node::debug (void)
903 /* Verify common part of symtab nodes. */
906 symtab_node::verify_base (void)
908 bool error_found
= false;
909 symtab_node
*hashed_node
;
911 if (is_a
<cgraph_node
*> (this))
913 if (TREE_CODE (decl
) != FUNCTION_DECL
)
915 error ("function symbol is not function");
919 else if (is_a
<varpool_node
*> (this))
921 if (TREE_CODE (decl
) != VAR_DECL
)
923 error ("variable symbol is not variable");
929 error ("node has unknown type");
933 if (symtab
->state
!= LTO_STREAMING
)
935 hashed_node
= symtab_node::get (decl
);
938 error ("node not found node->decl->decl_with_vis.symtab_node");
941 if (hashed_node
!= this
942 && (!is_a
<cgraph_node
*> (this)
943 || !dyn_cast
<cgraph_node
*> (this)->clone_of
944 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
946 error ("node differs from node->decl->decl_with_vis.symtab_node");
950 if (symtab
->assembler_name_hash
)
952 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
953 if (hashed_node
&& hashed_node
->previous_sharing_asm_name
)
955 error ("assembler name hash list corrupted");
960 if (hashed_node
== this)
962 hashed_node
= hashed_node
->next_sharing_asm_name
;
965 && !(is_a
<varpool_node
*> (this)
966 || DECL_HARD_REGISTER (decl
)))
968 error ("node not found in symtab assembler name hash");
972 if (previous_sharing_asm_name
973 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
975 error ("double linked list of assembler names corrupted");
978 if (body_removed
&& definition
)
980 error ("node has body_removed but is definition");
983 if (analyzed
&& !definition
)
985 error ("node is analyzed byt it is not a definition");
988 if (cpp_implicit_alias
&& !alias
)
990 error ("node is alias but not implicit alias");
993 if (alias
&& !definition
&& !weakref
)
995 error ("node is alias but not definition");
998 if (weakref
&& !alias
)
1000 error ("node is weakref but not an alias");
1003 if (same_comdat_group
)
1005 symtab_node
*n
= same_comdat_group
;
1007 if (!n
->get_comdat_group ())
1009 error ("node is in same_comdat_group list but has no comdat_group");
1012 if (n
->get_comdat_group () != get_comdat_group ())
1014 error ("same_comdat_group list across different groups");
1017 if (n
->type
!= type
)
1019 error ("mixing different types of symbol in same comdat groups is not supported");
1024 error ("node is alone in a comdat group");
1029 if (!n
->same_comdat_group
)
1031 error ("same_comdat_group is not a circular list");
1035 n
= n
->same_comdat_group
;
1038 if (comdat_local_p ())
1040 ipa_ref
*ref
= NULL
;
1042 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1044 if (!in_same_comdat_group_p (ref
->referring
))
1046 error ("comdat-local symbol referred to by %s outside its "
1048 identifier_to_locale (ref
->referring
->name()));
1054 if (implicit_section
&& !get_section ())
1056 error ("implicit_section flag is set but section isn't");
1059 if (get_section () && get_comdat_group ()
1060 && !implicit_section
1061 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1063 error ("Both section and comdat group is set");
1066 /* TODO: Add string table for sections, so we do not keep holding duplicated
1068 if (alias
&& definition
1069 && get_section () != get_alias_target ()->get_section ()
1071 || !get_alias_target ()->get_section ()
1072 || strcmp (get_section(),
1073 get_alias_target ()->get_section ())))
1075 error ("Alias and target's section differs");
1076 get_alias_target ()->dump (stderr
);
1079 if (alias
&& definition
1080 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1082 error ("Alias and target's comdat groups differs");
1083 get_alias_target ()->dump (stderr
);
1090 /* Verify consistency of NODE. */
1093 symtab_node::verify (void)
1098 timevar_push (TV_CGRAPH_VERIFY
);
1099 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1100 node
->verify_node ();
1105 internal_error ("symtab_node::verify failed");
1107 timevar_pop (TV_CGRAPH_VERIFY
);
1110 /* Verify symbol table for internal consistency. */
1113 symtab_node::verify_symtab_nodes (void)
1116 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1118 FOR_EACH_SYMBOL (node
)
1121 if (node
->get_comdat_group ())
1123 symtab_node
**entry
, *s
;
1126 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1130 else if (!DECL_EXTERNAL (node
->decl
))
1132 for (s
= (*entry
)->same_comdat_group
;
1133 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1134 s
= s
->same_comdat_group
)
1136 if (!s
|| s
== *entry
)
1138 error ("Two symbols with same comdat_group are not linked by "
1139 "the same_comdat_group list.");
1142 internal_error ("symtab_node::verify failed");
1149 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1150 but other code such as notice_global_symbol generates rtl. */
1153 symtab_node::make_decl_local (void)
1157 /* Avoid clearing comdat_groups on comdat-local decls. */
1158 if (TREE_PUBLIC (decl
) == 0)
1161 if (TREE_CODE (decl
) == VAR_DECL
)
1163 DECL_COMMON (decl
) = 0;
1164 /* ADDRESSABLE flag is not defined for public symbols. */
1165 TREE_ADDRESSABLE (decl
) = 1;
1167 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1169 DECL_COMDAT (decl
) = 0;
1170 DECL_WEAK (decl
) = 0;
1171 DECL_EXTERNAL (decl
) = 0;
1172 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1173 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1174 TREE_PUBLIC (decl
) = 0;
1175 DECL_DLLIMPORT_P (decl
) = 0;
1176 if (!DECL_RTL_SET_P (decl
))
1179 /* Update rtl flags. */
1180 make_decl_rtl (decl
);
1182 rtl
= DECL_RTL (decl
);
1186 symbol
= XEXP (rtl
, 0);
1187 if (GET_CODE (symbol
) != SYMBOL_REF
)
1190 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1193 /* Walk the alias chain to return the symbol NODE is alias of.
1194 If NODE is not an alias, return NODE.
1195 Assumes NODE is known to be alias. */
1198 symtab_node::ultimate_alias_target_1 (enum availability
*availability
)
1200 bool weakref_p
= false;
1202 /* To determine visibility of the target, we follow ELF semantic of aliases.
1203 Here alias is an alternative assembler name of a given definition. Its
1204 availability prevails the availability of its target (i.e. static alias of
1205 weak definition is available.
1207 Weakref is a different animal (and not part of ELF per se). It is just
1208 alternative name of a given symbol used within one complation unit
1209 and is translated prior hitting the object file. It inherits the
1210 visibility of its target (i.e. weakref of non-overwritable definition
1211 is non-overwritable, while weakref of weak definition is weak).
1213 If we ever get into supporting targets with different semantics, a target
1214 hook will be needed here. */
1218 weakref_p
= weakref
;
1220 *availability
= get_availability ();
1222 *availability
= AVAIL_LOCAL
;
1225 symtab_node
*node
= this;
1228 if (node
->alias
&& node
->analyzed
)
1229 node
= node
->get_alias_target ();
1234 else if (node
->analyzed
)
1238 enum availability a
= node
->get_availability ();
1239 if (a
< *availability
)
1244 *availability
= AVAIL_NOT_AVAILABLE
;
1247 if (node
&& availability
&& weakref_p
)
1249 enum availability a
= node
->get_availability ();
1250 if (a
< *availability
)
1252 weakref_p
= node
->weakref
;
1256 *availability
= AVAIL_NOT_AVAILABLE
;
1260 /* C++ FE sometimes change linkage flags after producing same body aliases.
1262 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1263 are obviously equivalent. The way it is doing so is however somewhat
1264 kludgy and interferes with the visibility code. As a result we need to
1265 copy the visibility from the target to get things right. */
1268 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1270 if (is_a
<cgraph_node
*> (this))
1272 DECL_DECLARED_INLINE_P (decl
)
1273 = DECL_DECLARED_INLINE_P (target
->decl
);
1274 DECL_DISREGARD_INLINE_LIMITS (decl
)
1275 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1277 /* FIXME: It is not really clear why those flags should not be copied for
1281 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1282 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1283 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1285 DECL_VIRTUAL_P (decl
) = DECL_VIRTUAL_P (target
->decl
);
1286 if (TREE_PUBLIC (decl
))
1290 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1291 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1292 group
= target
->get_comdat_group ();
1293 set_comdat_group (group
);
1294 if (group
&& !same_comdat_group
)
1295 add_to_same_comdat_group (target
);
1297 externally_visible
= target
->externally_visible
;
1300 /* Set section, do not recurse into aliases.
1301 When one wants to change section of symbol and its aliases,
1305 symtab_node::set_section_for_node (const char *section
)
1307 const char *current
= get_section ();
1308 section_hash_entry
**slot
;
1310 if (current
== section
1311 || (current
&& section
1312 && !strcmp (current
, section
)))
1317 x_section
->ref_count
--;
1318 if (!x_section
->ref_count
)
1320 hashval_t hash
= htab_hash_string (x_section
->name
);
1321 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1323 ggc_free (x_section
);
1324 symtab
->section_hash
->clear_slot (slot
);
1330 implicit_section
= false;
1333 if (!symtab
->section_hash
)
1334 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1335 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1336 htab_hash_string (section
),
1339 x_section
= (section_hash_entry
*)*slot
;
1342 int len
= strlen (section
);
1343 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1344 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1345 memcpy (x_section
->name
, section
, len
+ 1);
1347 x_section
->ref_count
++;
1350 /* Worker for set_section. */
1353 symtab_node::set_section (symtab_node
*n
, void *s
)
1355 n
->set_section_for_node ((char *)s
);
1359 /* Set section of symbol and its aliases. */
1362 symtab_node::set_section (const char *section
)
1364 gcc_assert (!this->alias
);
1365 call_for_symbol_and_aliases
1366 (symtab_node::set_section
, const_cast<char *>(section
), true);
1369 /* Return the initialization priority. */
1372 symtab_node::get_init_priority ()
1374 if (!this->in_init_priority_hash
)
1375 return DEFAULT_INIT_PRIORITY
;
1377 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1378 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1381 /* Return the finalization priority. */
1384 cgraph_node::get_fini_priority ()
1386 if (!this->in_init_priority_hash
)
1387 return DEFAULT_INIT_PRIORITY
;
1388 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1389 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1392 /* Return the initialization and finalization priority information for
1393 DECL. If there is no previous priority information, a freshly
1394 allocated structure is returned. */
1396 symbol_priority_map
*
1397 symtab_node::priority_info (void)
1399 if (!symtab
->init_priority_hash
)
1400 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1403 symbol_priority_map
*h
1404 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1407 h
->init
= DEFAULT_INIT_PRIORITY
;
1408 h
->fini
= DEFAULT_INIT_PRIORITY
;
1409 in_init_priority_hash
= true;
1415 /* Set initialization priority to PRIORITY. */
1418 symtab_node::set_init_priority (priority_type priority
)
1420 symbol_priority_map
*h
;
1422 if (is_a
<cgraph_node
*> (this))
1423 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1425 if (priority
== DEFAULT_INIT_PRIORITY
)
1427 gcc_assert (get_init_priority() == priority
);
1430 h
= priority_info ();
1434 /* Set fialization priority to PRIORITY. */
1437 cgraph_node::set_fini_priority (priority_type priority
)
1439 symbol_priority_map
*h
;
1441 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1443 if (priority
== DEFAULT_INIT_PRIORITY
)
1445 gcc_assert (get_fini_priority() == priority
);
1448 h
= priority_info ();
1452 /* Worker for symtab_resolve_alias. */
1455 symtab_node::set_implicit_section (symtab_node
*n
,
1456 void *data ATTRIBUTE_UNUSED
)
1458 n
->implicit_section
= true;
1462 /* Add reference recording that symtab node is alias of TARGET.
1463 The function can fail in the case of aliasing cycles; in this case
1464 it returns false. */
1467 symtab_node::resolve_alias (symtab_node
*target
)
1471 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1473 /* Never let cycles to creep into the symbol table alias references;
1474 those will make alias walkers to be infinite. */
1475 for (n
= target
; n
&& n
->alias
;
1476 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1479 if (is_a
<cgraph_node
*> (this))
1480 error ("function %q+D part of alias cycle", decl
);
1481 else if (is_a
<varpool_node
*> (this))
1482 error ("variable %q+D part of alias cycle", decl
);
1489 /* "analyze" the node - i.e. mark the reference. */
1493 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1495 /* Add alias into the comdat group of its target unless it is already there. */
1496 if (same_comdat_group
)
1497 remove_from_same_comdat_group ();
1498 set_comdat_group (NULL
);
1499 if (target
->get_comdat_group ())
1500 add_to_same_comdat_group (target
);
1502 if ((get_section () != target
->get_section ()
1503 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1505 error ("section of alias %q+D must match section of its target", decl
);
1507 call_for_symbol_and_aliases (symtab_node::set_section
,
1508 const_cast<char *>(target
->get_section ()), true);
1509 if (target
->implicit_section
)
1510 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1512 /* Alias targets become redundant after alias is resolved into an reference.
1513 We do not want to keep it around or we would have to mind updating them
1514 when renaming symbols. */
1515 alias_target
= NULL
;
1517 if (cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1518 fixup_same_cpp_alias_visibility (target
);
1520 /* If alias has address taken, so does the target. */
1522 target
->ultimate_alias_target ()->address_taken
= true;
1524 /* All non-weakref aliases of THIS are now in fact aliases of TARGET. */
1526 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1528 struct symtab_node
*alias_alias
= ref
->referring
;
1529 if (!alias_alias
->weakref
)
1531 alias_alias
->remove_all_references ();
1532 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1539 /* Worker searching noninterposable alias. */
1542 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1544 if (decl_binds_to_current_def_p (node
->decl
))
1546 symtab_node
*fn
= node
->ultimate_alias_target ();
1548 /* Ensure that the alias is well formed this may not be the case
1549 of user defined aliases and currently it is not always the case
1550 of C++ same body aliases (that is a bug). */
1551 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1552 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1553 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1554 && flags_from_decl_or_type (node
->decl
)
1555 != flags_from_decl_or_type (fn
->decl
))
1556 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1558 *(symtab_node
**)data
= node
;
1564 /* If node can not be overwriten by static or dynamic linker to point to
1565 different definition, return NODE. Otherwise look for alias with such
1566 property and if none exists, introduce new one. */
1569 symtab_node::noninterposable_alias (void)
1572 symtab_node
*new_node
= NULL
;
1574 /* First try to look up existing alias or base object
1575 (if that is already non-overwritable). */
1576 symtab_node
*node
= ultimate_alias_target ();
1577 gcc_assert (!node
->alias
&& !node
->weakref
);
1578 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1579 (void *)&new_node
, true);
1582 #ifndef ASM_OUTPUT_DEF
1583 /* If aliases aren't supported by the assembler, fail. */
1587 /* Otherwise create a new one. */
1588 new_decl
= copy_node (node
->decl
);
1589 DECL_DLLIMPORT_P (new_decl
) = 0;
1590 DECL_NAME (new_decl
) = clone_function_name (node
->decl
, "localalias");
1591 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1592 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1593 DECL_INITIAL (new_decl
) = NULL
;
1594 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1595 SET_DECL_RTL (new_decl
, NULL
);
1597 /* Update the properties. */
1598 DECL_EXTERNAL (new_decl
) = 0;
1599 TREE_PUBLIC (new_decl
) = 0;
1600 DECL_COMDAT (new_decl
) = 0;
1601 DECL_WEAK (new_decl
) = 0;
1603 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1604 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1605 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1607 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1608 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1609 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1613 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1614 DECL_INITIAL (new_decl
) = error_mark_node
;
1615 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1617 new_node
->resolve_alias (node
);
1618 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1619 && targetm
.binds_local_p (new_decl
));
1623 /* Return true if symtab node and TARGET represents
1624 semantically equivalent symbols. */
1627 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1629 enum availability avail
;
1633 /* Equivalent functions are equivalent. */
1634 if (decl
== target
->decl
)
1637 /* If symbol is not overwritable by different implementation,
1638 walk to the base object it defines. */
1639 ba
= ultimate_alias_target (&avail
);
1640 if (avail
>= AVAIL_AVAILABLE
)
1647 bb
= target
->ultimate_alias_target (&avail
);
1648 if (avail
>= AVAIL_AVAILABLE
)
1658 /* Classify symbol symtab node for partitioning. */
1660 enum symbol_partitioning_class
1661 symtab_node::get_partitioning_class (void)
1663 /* Inline clones are always duplicated.
1664 This include external delcarations. */
1665 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
1667 if (DECL_ABSTRACT_P (decl
))
1668 return SYMBOL_EXTERNAL
;
1670 if (cnode
&& cnode
->global
.inlined_to
)
1671 return SYMBOL_DUPLICATE
;
1673 /* Weakref aliases are always duplicated. */
1675 return SYMBOL_DUPLICATE
;
1677 /* External declarations are external. */
1678 if (DECL_EXTERNAL (decl
))
1679 return SYMBOL_EXTERNAL
;
1681 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1683 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
1684 return SYMBOL_EXTERNAL
;
1685 /* Constant pool references use local symbol names that can not
1686 be promoted global. We should never put into a constant pool
1687 objects that can not be duplicated across partitions. */
1688 if (DECL_IN_CONSTANT_POOL (decl
))
1689 return SYMBOL_DUPLICATE
;
1690 if (DECL_HARD_REGISTER (decl
))
1691 return SYMBOL_DUPLICATE
;
1692 gcc_checking_assert (vnode
->definition
);
1694 /* Functions that are cloned may stay in callgraph even if they are unused.
1695 Handle them as external; compute_ltrans_boundary take care to make
1696 proper things to happen (i.e. to make them appear in the boundary but
1697 with body streamed, so clone can me materialized). */
1698 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
1699 return SYMBOL_EXTERNAL
;
1701 /* Linker discardable symbols are duplicated to every use unless they are
1703 if (DECL_ONE_ONLY (decl
)
1706 && !used_from_object_file_p ())
1707 return SYMBOL_DUPLICATE
;
1709 return SYMBOL_PARTITION
;
1712 /* Return true when symbol is known to be non-zero. */
1715 symtab_node::nonzero_address ()
1717 /* Weakrefs may be NULL when their target is not defined. */
1718 if (alias
&& weakref
)
1722 symtab_node
*target
= ultimate_alias_target ();
1724 if (target
->alias
&& target
->weakref
)
1726 /* We can not recurse to target::nonzero. It is possible that the
1727 target is used only via the alias.
1728 We may walk references and look for strong use, but we do not know
1729 if this strong use will survive to final binary, so be
1731 ??? Maybe we could do the lookup during late optimization that
1732 could be useful to eliminate the NULL pointer checks in LTO
1734 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
1736 if (target
->resolution
!= LDPR_UNKNOWN
1737 && target
->resolution
!= LDPR_UNDEF
1738 && flag_delete_null_pointer_checks
)
1746 /* With !flag_delete_null_pointer_checks we assume that symbols may
1747 bind to NULL. This is on by default on embedded targets only.
1749 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
1750 linking fails. Important case of WEAK we want to do well are comdats.
1751 Those are handled by later check for definition.
1753 When parsing, beware the cases when WEAK attribute is added later. */
1754 if (!DECL_WEAK (decl
)
1755 && flag_delete_null_pointer_checks
)
1757 refuse_visibility_changes
= true;
1761 /* If target is defined and not extern, we know it will be output and thus
1762 it will bind to non-NULL.
1763 Play safe for flag_delete_null_pointer_checks where weak definition maye
1764 be re-defined by NULL. */
1765 if (definition
&& !DECL_EXTERNAL (decl
)
1766 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
1768 if (!DECL_WEAK (decl
))
1769 refuse_visibility_changes
= true;
1773 /* As the last resort, check the resolution info. */
1774 if (resolution
!= LDPR_UNKNOWN
1775 && resolution
!= LDPR_UNDEF
1776 && flag_delete_null_pointer_checks
)
1781 /* Return 0 if symbol is known to have different address than S2,
1782 Return 1 if symbol is known to have same address as S2,
1783 return 2 otherwise. */
1785 symtab_node::equal_address_to (symtab_node
*s2
)
1787 enum availability avail1
, avail2
;
1789 /* A Shortcut: equivalent symbols are always equivalent. */
1793 /* For non-interposable aliases, lookup and compare their actual definitions.
1794 Also check if the symbol needs to bind to given definition. */
1795 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
1796 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
1797 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
1798 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
1799 bool really_binds_local1
= binds_local1
;
1800 bool really_binds_local2
= binds_local2
;
1802 /* Addresses of vtables and virtual functions can not be used by user
1803 code and are used only within speculation. In this case we may make
1804 symbol equivalent to its alias even if interposition may break this
1805 rule. Doing so will allow us to turn speculative inlining into
1806 non-speculative more agressively. */
1807 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
1808 binds_local1
= true;
1809 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
1810 binds_local2
= true;
1812 /* If both definitions are available we know that even if they are bound
1813 to other unit they must be defined same way and therefore we can use
1814 equivalence test. */
1815 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
1816 binds_local1
= binds_local2
= true;
1818 if ((binds_local1
? rs1
: this)
1819 == (binds_local2
? rs2
: s2
))
1821 /* We made use of the fact that alias is not weak. */
1822 if (binds_local1
&& rs1
!= this)
1823 refuse_visibility_changes
= true;
1824 if (binds_local2
&& rs2
!= s2
)
1825 s2
->refuse_visibility_changes
= true;
1829 /* If both symbols may resolve to NULL, we can not really prove them different. */
1830 if (!nonzero_address () && !s2
->nonzero_address ())
1833 /* Except for NULL, functions and variables never overlap. */
1834 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
1837 /* If one of the symbols is unresolved alias, punt. */
1838 if (rs1
->alias
|| rs2
->alias
)
1841 /* If we have a non-interposale definition of at least one of the symbols
1842 and the other symbol is different, we know other unit can not interpose
1843 it to the first symbol; all aliases of the definition needs to be
1844 present in the current unit. */
1845 if (((really_binds_local1
|| really_binds_local2
)
1846 /* If we have both definitions and they are different, we know they
1847 will be different even in units they binds to. */
1848 || (binds_local1
&& binds_local2
))
1851 /* We make use of the fact that one symbol is not alias of the other
1852 and that the definition is non-interposable. */
1853 refuse_visibility_changes
= true;
1854 s2
->refuse_visibility_changes
= true;
1855 rs1
->refuse_visibility_changes
= true;
1856 rs2
->refuse_visibility_changes
= true;
1860 /* TODO: Alias oracle basically assume that addresses of global variables
1861 are different unless they are declared as alias of one to another.
1862 We probably should be consistent and use this fact here, too, and update
1863 alias oracle to use this predicate. */
1868 /* Worker for call_for_symbol_and_aliases. */
1871 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
1874 bool include_overwritable
)
1877 FOR_EACH_ALIAS (this, ref
)
1879 symtab_node
*alias
= ref
->referring
;
1880 if (include_overwritable
1881 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
1882 if (alias
->call_for_symbol_and_aliases (callback
, data
,
1883 include_overwritable
))
1889 /* Return ture if address of N is possibly compared. */
1892 address_matters_1 (symtab_node
*n
, void *)
1894 struct ipa_ref
*ref
;
1896 if (!n
->address_can_be_compared_p ())
1898 if (n
->externally_visible
|| n
->force_output
)
1901 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
1902 if (ref
->address_matters_p ())
1907 /* Return true if symbol's address may possibly be compared to other
1908 symbol's address. */
1911 symtab_node::address_matters_p ()
1913 gcc_assert (!alias
);
1914 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
1917 /* Return ture if symbol's alignment may be increased. */
1920 symtab_node::can_increase_alignment_p (void)
1922 symtab_node
*target
= ultimate_alias_target ();
1924 /* For now support only variables. */
1925 if (TREE_CODE (decl
) != VAR_DECL
)
1928 /* With -fno-toplevel-reorder we may have already output the constant. */
1929 if (TREE_ASM_WRITTEN (target
->decl
))
1932 /* If target is already placed in an anchor, we can not touch its
1934 if (DECL_RTL_SET_P (target
->decl
)
1935 && MEM_P (DECL_RTL (target
->decl
))
1936 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
1939 /* Constant pool entries may be shared. */
1940 if (DECL_IN_CONSTANT_POOL (target
->decl
))
1943 /* We cannot change alignment of symbols that may bind to symbols
1944 in other translation unit that may contain a definition with lower
1946 if (!decl_binds_to_current_def_p (decl
))
1949 /* When compiling partition, be sure the symbol is not output by other
1952 && (target
->in_other_partition
1953 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
1956 /* Do not override the alignment as specified by the ABI when the used
1957 attribute is set. */
1958 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
1961 /* Do not override explicit alignment set by the user when an explicit
1962 section name is also used. This is a common idiom used by many
1963 software projects. */
1964 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
1970 /* Worker for symtab_node::increase_alignment. */
1973 increase_alignment_1 (symtab_node
*n
, void *v
)
1975 unsigned int align
= (size_t)v
;
1976 if (DECL_ALIGN (n
->decl
) < align
1977 && n
->can_increase_alignment_p ())
1979 DECL_ALIGN (n
->decl
) = align
;
1980 DECL_USER_ALIGN (n
->decl
) = 1;
1985 /* Increase alignment of THIS to ALIGN. */
1988 symtab_node::increase_alignment (unsigned int align
)
1990 gcc_assert (can_increase_alignment_p () && align
< MAX_OFILE_ALIGNMENT
);
1991 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
1992 (void *)(size_t) align
,
1994 gcc_assert (DECL_ALIGN (decl
) >= align
);
1997 /* Helper for symtab_node::definition_alignment. */
2000 get_alignment_1 (symtab_node
*n
, void *v
)
2002 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2006 /* Return desired alignment of the definition. This is NOT alignment useful
2007 to access THIS, because THIS may be interposable and DECL_ALIGN should
2008 be used instead. It however must be guaranteed when output definition
2012 symtab_node::definition_alignment ()
2014 unsigned int align
= 0;
2015 gcc_assert (!alias
);
2016 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);