2 Copyright (C) 2012-2014 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"
27 #include "print-tree.h"
31 #include "basic-block.h"
32 #include "tree-ssa-alias.h"
33 #include "internal-fn.h"
34 #include "gimple-expr.h"
37 #include "tree-inline.h"
38 #include "langhooks.h"
41 #include "diagnostic.h"
43 #include "lto-streamer.h"
45 #include "ipa-utils.h"
48 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias"};
50 const char * const ld_plugin_symbol_resolution_names
[]=
55 "prevailing_def_ironly",
61 "prevailing_def_ironly_exp"
64 /* Hash asmnames ignoring the user specified marks. */
67 symbol_table::decl_assembler_name_hash (const_tree asmname
)
69 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
71 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
72 size_t ulp_len
= strlen (user_label_prefix
);
76 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
79 return htab_hash_string (decl_str
);
82 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
86 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
89 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
91 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
93 const char *asmname_str
;
96 if (decl_asmname
== asmname
)
99 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
100 asmname_str
= IDENTIFIER_POINTER (asmname
);
103 /* If the target assembler name was set by the user, things are trickier.
104 We have a leading '*' to begin with. After that, it's arguable what
105 is the correct thing to do with -fleading-underscore. Arguably, we've
106 historically been doing the wrong thing in assemble_alias by always
107 printing the leading underscore. Since we're not changing that, make
108 sure user_label_prefix follows the '*' before matching. */
109 if (decl_str
[0] == '*')
111 size_t ulp_len
= strlen (user_label_prefix
);
117 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
118 decl_str
+= ulp_len
, test
=true;
122 if (asmname_str
[0] == '*')
124 size_t ulp_len
= strlen (user_label_prefix
);
130 else if (strncmp (asmname_str
, user_label_prefix
, ulp_len
) == 0)
131 asmname_str
+= ulp_len
, test
=true;
138 return strcmp (decl_str
, asmname_str
) == 0;
142 /* Returns nonzero if P1 and P2 are equal. */
144 /* Insert NODE to assembler name hash. */
147 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
150 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
152 gcc_checking_assert (!node
->previous_sharing_asm_name
153 && !node
->next_sharing_asm_name
);
154 if (assembler_name_hash
)
158 tree decl
= node
->decl
;
160 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
162 hashval_t hash
= decl_assembler_name_hash (name
);
163 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
164 gcc_assert (*aslot
!= node
);
165 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
167 (*aslot
)->previous_sharing_asm_name
= node
;
170 /* Update also possible inline clones sharing a decl. */
171 cnode
= dyn_cast
<cgraph_node
*> (node
);
172 if (cnode
&& cnode
->clones
&& with_clones
)
173 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
174 if (cnode
->decl
== decl
)
175 insert_to_assembler_name_hash (cnode
, true);
180 /* Remove NODE from assembler name hash. */
183 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
186 if (assembler_name_hash
)
189 tree decl
= node
->decl
;
191 if (node
->next_sharing_asm_name
)
192 node
->next_sharing_asm_name
->previous_sharing_asm_name
193 = node
->previous_sharing_asm_name
;
194 if (node
->previous_sharing_asm_name
)
196 node
->previous_sharing_asm_name
->next_sharing_asm_name
197 = node
->next_sharing_asm_name
;
201 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
203 hashval_t hash
= decl_assembler_name_hash (name
);
204 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
206 gcc_assert (*slot
== node
);
207 if (!node
->next_sharing_asm_name
)
208 assembler_name_hash
->clear_slot (slot
);
210 *slot
= node
->next_sharing_asm_name
;
212 node
->next_sharing_asm_name
= NULL
;
213 node
->previous_sharing_asm_name
= NULL
;
215 /* Update also possible inline clones sharing a decl. */
216 cnode
= dyn_cast
<cgraph_node
*> (node
);
217 if (cnode
&& cnode
->clones
&& with_clones
)
218 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
219 if (cnode
->decl
== decl
)
220 unlink_from_assembler_name_hash (cnode
, true);
224 /* Arrange node to be first in its entry of assembler_name_hash. */
227 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
229 unlink_from_assembler_name_hash (node
, false);
230 insert_to_assembler_name_hash (node
, false);
233 /* Initalize asm name hash unless. */
236 symbol_table::symtab_initialize_asm_name_hash (void)
239 if (!assembler_name_hash
)
241 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
242 FOR_EACH_SYMBOL (node
)
243 insert_to_assembler_name_hash (node
, false);
247 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
250 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
252 symtab_node
*node
= NULL
;
254 /* We can have user ASM names on things, like global register variables, that
255 are not in the symbol table. */
256 if ((TREE_CODE (decl
) == VAR_DECL
257 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
258 || TREE_CODE (decl
) == FUNCTION_DECL
)
259 node
= symtab_node::get (decl
);
260 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
262 SET_DECL_ASSEMBLER_NAME (decl
, name
);
264 insert_to_assembler_name_hash (node
, true);
268 if (name
== DECL_ASSEMBLER_NAME (decl
))
271 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
272 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
275 unlink_from_assembler_name_hash (node
, true);
276 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
277 && DECL_RTL_SET_P (decl
))
278 warning (0, "%D renamed after being referenced in assembly", decl
);
280 SET_DECL_ASSEMBLER_NAME (decl
, name
);
283 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
284 TREE_CHAIN (name
) = alias
;
287 insert_to_assembler_name_hash (node
, true);
291 /* Return true when RESOLUTION indicate that linker will use
292 the symbol from non-LTO object files. */
295 resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution
)
297 return (resolution
== LDPR_PREVAILING_DEF
298 || resolution
== LDPR_PREEMPTED_REG
299 || resolution
== LDPR_RESOLVED_EXEC
300 || resolution
== LDPR_RESOLVED_DYN
);
303 /* Hash sections by their names. */
306 section_name_hasher::hash (section_hash_entry
*n
)
308 return htab_hash_string (n
->name
);
311 /* Return true if section P1 name equals to P2. */
314 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
316 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
319 /* Add node into symbol table. This function is not used directly, but via
320 cgraph/varpool node creation routines. */
323 symtab_node::register_symbol (void)
325 symtab
->register_symbol (this);
327 if (!decl
->decl_with_vis
.symtab_node
)
328 decl
->decl_with_vis
.symtab_node
= this;
332 /* Be sure to do this last; C++ FE might create new nodes via
333 DECL_ASSEMBLER_NAME langhook! */
334 symtab
->insert_to_assembler_name_hash (this, false);
337 /* Remove NODE from same comdat group. */
340 symtab_node::remove_from_same_comdat_group (void)
342 if (same_comdat_group
)
345 for (prev
= same_comdat_group
;
346 prev
->same_comdat_group
!= this;
347 prev
= prev
->same_comdat_group
)
349 if (same_comdat_group
== prev
)
350 prev
->same_comdat_group
= NULL
;
352 prev
->same_comdat_group
= same_comdat_group
;
353 same_comdat_group
= NULL
;
354 set_comdat_group (NULL
);
358 /* Remove node from symbol table. This function is not used directly, but via
359 cgraph/varpool node removal routines. */
362 symtab_node::unregister (void)
364 remove_all_references ();
365 remove_all_referring ();
367 /* Remove reference to section. */
368 set_section_for_node (NULL
);
370 remove_from_same_comdat_group ();
372 symtab
->unregister (this);
374 /* During LTO symtab merging we temporarily corrupt decl to symtab node
376 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
377 if (decl
->decl_with_vis
.symtab_node
== this)
379 symtab_node
*replacement_node
= NULL
;
380 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
381 replacement_node
= cnode
->find_replacement ();
382 decl
->decl_with_vis
.symtab_node
= replacement_node
;
384 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
385 symtab
->unlink_from_assembler_name_hash (this, false);
386 if (in_init_priority_hash
)
387 symtab
->init_priority_hash
->remove (this);
391 /* Remove symbol from symbol table. */
394 symtab_node::remove (void)
396 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
398 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
402 /* Add NEW_ to the same comdat group that OLD is in. */
405 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
407 gcc_assert (old_node
->get_comdat_group ());
408 gcc_assert (!same_comdat_group
);
409 gcc_assert (this != old_node
);
411 set_comdat_group (old_node
->get_comdat_group ());
412 same_comdat_group
= old_node
;
413 if (!old_node
->same_comdat_group
)
414 old_node
->same_comdat_group
= this;
418 for (n
= old_node
->same_comdat_group
;
419 n
->same_comdat_group
!= old_node
;
420 n
= n
->same_comdat_group
)
422 n
->same_comdat_group
= this;
426 /* Dissolve the same_comdat_group list in which NODE resides. */
429 symtab_node::dissolve_same_comdat_group_list (void)
431 symtab_node
*n
= this;
434 if (!same_comdat_group
)
438 next
= n
->same_comdat_group
;
439 n
->same_comdat_group
= NULL
;
440 /* Clear comdat_group for comdat locals, since
441 make_decl_local doesn't. */
442 if (!TREE_PUBLIC (n
->decl
))
443 n
->set_comdat_group (NULL
);
449 /* Return printable assembler name of NODE.
450 This function is used only for debugging. When assembler name
451 is unknown go with identifier name. */
454 symtab_node::asm_name () const
456 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
457 return lang_hooks
.decl_printable_name (decl
, 2);
458 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
461 /* Return printable identifier name. */
464 symtab_node::name () const
466 return lang_hooks
.decl_printable_name (decl
, 2);
469 /* Return ipa reference from this symtab_node to
470 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
474 symtab_node::create_reference (symtab_node
*referred_node
,
475 enum ipa_ref_use use_type
)
477 return create_reference (referred_node
, use_type
, NULL
);
481 /* Return ipa reference from this symtab_node to
482 REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
483 of the use and STMT the statement (if it exists). */
486 symtab_node::create_reference (symtab_node
*referred_node
,
487 enum ipa_ref_use use_type
, gimple stmt
)
489 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
490 ipa_ref_list
*list
, *list2
;
491 ipa_ref_t
*old_references
;
493 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
494 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
497 old_references
= vec_safe_address (list
->references
);
498 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1);
499 ref
= &list
->references
->last ();
501 list2
= &referred_node
->ref_list
;
503 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
504 if(use_type
== IPA_REF_ALIAS
)
506 list2
->referring
.safe_insert (0, ref
);
507 ref
->referred_index
= 0;
509 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
510 list2
->referring
[i
]->referred_index
= i
;
514 list2
->referring
.safe_push (ref
);
515 ref
->referred_index
= list2
->referring
.length () - 1;
518 ref
->referring
= this;
519 ref
->referred
= referred_node
;
521 ref
->lto_stmt_uid
= 0;
523 ref
->speculative
= 0;
525 /* If vector was moved in memory, update pointers. */
526 if (old_references
!= list
->references
->address ())
529 for (i
= 0; iterate_reference(i
, ref2
); i
++)
530 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
535 /* If VAL is a reference to a function or a variable, add a reference from
536 this symtab_node to the corresponding symbol table node. USE_TYPE specify
537 type of the use and STMT the statement (if it exists). Return the new
538 reference or NULL if none was created. */
541 symtab_node::maybe_create_reference (tree val
, enum ipa_ref_use use_type
,
545 if (TREE_CODE (val
) != ADDR_EXPR
)
547 val
= get_base_var (val
);
548 if (val
&& (TREE_CODE (val
) == FUNCTION_DECL
549 || TREE_CODE (val
) == VAR_DECL
))
551 symtab_node
*referred
= symtab_node::get (val
);
552 gcc_checking_assert (referred
);
553 return create_reference (referred
, use_type
, stmt
);
558 /* Clone all references from symtab NODE to this symtab_node. */
561 symtab_node::clone_references (symtab_node
*node
)
563 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
565 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
567 bool speculative
= ref
->speculative
;
568 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
570 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
571 ref2
->speculative
= speculative
;
572 ref2
->lto_stmt_uid
= stmt_uid
;
576 /* Clone all referring from symtab NODE to this symtab_node. */
579 symtab_node::clone_referring (symtab_node
*node
)
581 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
583 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
585 bool speculative
= ref
->speculative
;
586 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
588 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
589 ref2
->speculative
= speculative
;
590 ref2
->lto_stmt_uid
= stmt_uid
;
594 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
597 symtab_node::clone_reference (ipa_ref
*ref
, gimple stmt
)
599 bool speculative
= ref
->speculative
;
600 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
603 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
604 ref2
->speculative
= speculative
;
605 ref2
->lto_stmt_uid
= stmt_uid
;
609 /* Find the structure describing a reference to REFERRED_NODE
610 and associated with statement STMT. */
613 symtab_node::find_reference (symtab_node
*referred_node
,
614 gimple stmt
, unsigned int lto_stmt_uid
)
619 for (i
= 0; iterate_reference (i
, r
); i
++)
620 if (r
->referred
== referred_node
622 && ((stmt
&& r
->stmt
== stmt
)
623 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
624 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
629 /* Remove all references that are associated with statement STMT. */
632 symtab_node::remove_stmt_references (gimple stmt
)
637 while (iterate_reference (i
, r
))
639 r
->remove_reference ();
644 /* Remove all stmt references in non-speculative references.
645 Those are not maintained during inlining & clonning.
646 The exception are speculative references that are updated along
647 with callgraph edges associated with them. */
650 symtab_node::clear_stmts_in_references (void)
655 for (i
= 0; iterate_reference (i
, r
); i
++)
663 /* Remove all references in ref list. */
666 symtab_node::remove_all_references (void)
668 while (vec_safe_length (ref_list
.references
))
669 ref_list
.references
->last ().remove_reference ();
670 vec_free (ref_list
.references
);
673 /* Remove all referring items in ref list. */
676 symtab_node::remove_all_referring (void)
678 while (ref_list
.referring
.length ())
679 ref_list
.referring
.last ()->remove_reference ();
680 ref_list
.referring
.release ();
683 /* Dump references in ref list to FILE. */
686 symtab_node::dump_references (FILE *file
)
690 for (i
= 0; iterate_reference (i
, ref
); i
++)
692 fprintf (file
, "%s/%i (%s)",
693 ref
->referred
->asm_name (),
694 ref
->referred
->order
,
695 ipa_ref_use_name
[ref
->use
]);
696 if (ref
->speculative
)
697 fprintf (file
, " (speculative)");
699 fprintf (file
, "\n");
702 /* Dump referring in list to FILE. */
705 symtab_node::dump_referring (FILE *file
)
709 for (i
= 0; iterate_referring(i
, ref
); i
++)
711 fprintf (file
, "%s/%i (%s)",
712 ref
->referring
->asm_name (),
713 ref
->referring
->order
,
714 ipa_ref_use_name
[ref
->use
]);
715 if (ref
->speculative
)
716 fprintf (file
, " (speculative)");
718 fprintf (file
, "\n");
721 /* Return true if list contains an alias. */
723 symtab_node::has_aliases_p (void)
728 for (i
= 0; iterate_referring (i
, ref
); i
++)
729 if (ref
->use
== IPA_REF_ALIAS
)
734 /* Iterates I-th reference in the list, REF is also set. */
737 symtab_node::iterate_reference (unsigned i
, ipa_ref
*&ref
)
739 vec_safe_iterate (ref_list
.references
, i
, &ref
);
744 /* Iterates I-th referring item in the list, REF is also set. */
747 symtab_node::iterate_referring (unsigned i
, ipa_ref
*&ref
)
749 ref_list
.referring
.iterate (i
, &ref
);
754 /* Iterates I-th referring alias item in the list, REF is also set. */
757 symtab_node::iterate_direct_aliases (unsigned i
, ipa_ref
*&ref
)
759 ref_list
.referring
.iterate (i
, &ref
);
761 if (ref
&& ref
->use
!= IPA_REF_ALIAS
)
767 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
769 /* Dump base fields of symtab nodes to F. Not to be used directly. */
772 symtab_node::dump_base (FILE *f
)
774 static const char * const visibility_types
[] = {
775 "default", "protected", "hidden", "internal"
778 fprintf (f
, "%s/%i (%s)", asm_name (), order
, name ());
779 dump_addr (f
, " @", (void *)this);
780 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
783 fprintf (f
, " definition");
785 fprintf (f
, " analyzed");
787 fprintf (f
, " alias");
789 fprintf (f
, " weakref");
790 if (cpp_implicit_alias
)
791 fprintf (f
, " cpp_implicit_alias");
793 fprintf (f
, " target:%s",
794 DECL_P (alias_target
)
795 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
797 : IDENTIFIER_POINTER (alias_target
));
799 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
800 fprintf (f
, "\n Visibility:");
801 if (in_other_partition
)
802 fprintf (f
, " in_other_partition");
803 if (used_from_other_partition
)
804 fprintf (f
, " used_from_other_partition");
806 fprintf (f
, " force_output");
808 fprintf (f
, " forced_by_abi");
809 if (externally_visible
)
810 fprintf (f
, " externally_visible");
812 fprintf (f
, " no_reorder");
813 if (resolution
!= LDPR_UNKNOWN
)
815 ld_plugin_symbol_resolution_names
[(int)resolution
]);
816 if (TREE_ASM_WRITTEN (decl
))
817 fprintf (f
, " asm_written");
818 if (DECL_EXTERNAL (decl
))
819 fprintf (f
, " external");
820 if (TREE_PUBLIC (decl
))
821 fprintf (f
, " public");
822 if (DECL_COMMON (decl
))
823 fprintf (f
, " common");
824 if (DECL_WEAK (decl
))
825 fprintf (f
, " weak");
826 if (DECL_DLLIMPORT_P (decl
))
827 fprintf (f
, " dll_import");
828 if (DECL_COMDAT (decl
))
829 fprintf (f
, " comdat");
830 if (get_comdat_group ())
831 fprintf (f
, " comdat_group:%s",
832 IDENTIFIER_POINTER (get_comdat_group_id ()));
833 if (DECL_ONE_ONLY (decl
))
834 fprintf (f
, " one_only");
836 fprintf (f
, " section:%s",
838 if (implicit_section
)
839 fprintf (f
," (implicit_section)");
840 if (DECL_VISIBILITY_SPECIFIED (decl
))
841 fprintf (f
, " visibility_specified");
842 if (DECL_VISIBILITY (decl
))
843 fprintf (f
, " visibility:%s",
844 visibility_types
[DECL_VISIBILITY (decl
)]);
845 if (DECL_VIRTUAL_P (decl
))
846 fprintf (f
, " virtual");
847 if (DECL_ARTIFICIAL (decl
))
848 fprintf (f
, " artificial");
849 if (TREE_CODE (decl
) == FUNCTION_DECL
)
851 if (DECL_STATIC_CONSTRUCTOR (decl
))
852 fprintf (f
, " constructor");
853 if (DECL_STATIC_DESTRUCTOR (decl
))
854 fprintf (f
, " destructor");
858 if (same_comdat_group
)
859 fprintf (f
, " Same comdat group as: %s/%i\n",
860 same_comdat_group
->asm_name (),
861 same_comdat_group
->order
);
862 if (next_sharing_asm_name
)
863 fprintf (f
, " next sharing asm name: %i\n",
864 next_sharing_asm_name
->order
);
865 if (previous_sharing_asm_name
)
866 fprintf (f
, " previous sharing asm name: %i\n",
867 previous_sharing_asm_name
->order
);
870 fprintf (f
, " Address is taken.\n");
873 fprintf (f
, " Aux:");
874 dump_addr (f
, " @", (void *)aux
);
877 fprintf (f
, " References: ");
879 fprintf (f
, " Referring: ");
882 fprintf (f
, " Read from file: %s\n",
883 lto_file_data
->file_name
);
886 /* Dump symtab node to F. */
889 symtab_node::dump (FILE *f
)
891 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
893 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
897 /* Dump symbol table to F. */
900 symtab_node::dump_table (FILE *f
)
903 fprintf (f
, "Symbol table:\n\n");
904 FOR_EACH_SYMBOL (node
)
909 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
910 Return NULL if there's no such node. */
913 symtab_node::get_for_asmname (const_tree asmname
)
917 symtab
->symtab_initialize_asm_name_hash ();
918 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
920 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
931 /* Dump symtab node NODE to stderr. */
934 symtab_node::debug (void)
939 /* Verify common part of symtab nodes. */
942 symtab_node::verify_base (void)
944 bool error_found
= false;
945 symtab_node
*hashed_node
;
947 if (is_a
<cgraph_node
*> (this))
949 if (TREE_CODE (decl
) != FUNCTION_DECL
)
951 error ("function symbol is not function");
955 else if (is_a
<varpool_node
*> (this))
957 if (TREE_CODE (decl
) != VAR_DECL
)
959 error ("variable symbol is not variable");
965 error ("node has unknown type");
969 if (symtab
->state
!= LTO_STREAMING
)
971 hashed_node
= symtab_node::get (decl
);
974 error ("node not found node->decl->decl_with_vis.symtab_node");
977 if (hashed_node
!= this
978 && (!is_a
<cgraph_node
*> (this)
979 || !dyn_cast
<cgraph_node
*> (this)->clone_of
980 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
982 error ("node differs from node->decl->decl_with_vis.symtab_node");
986 if (symtab
->assembler_name_hash
)
988 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
989 if (hashed_node
&& hashed_node
->previous_sharing_asm_name
)
991 error ("assembler name hash list corrupted");
996 if (hashed_node
== this)
998 hashed_node
= hashed_node
->next_sharing_asm_name
;
1001 && !(is_a
<varpool_node
*> (this)
1002 || DECL_HARD_REGISTER (decl
)))
1004 error ("node not found in symtab assembler name hash");
1008 if (previous_sharing_asm_name
1009 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1011 error ("double linked list of assembler names corrupted");
1014 if (analyzed
&& !definition
)
1016 error ("node is analyzed byt it is not a definition");
1019 if (cpp_implicit_alias
&& !alias
)
1021 error ("node is alias but not implicit alias");
1024 if (alias
&& !definition
&& !weakref
)
1026 error ("node is alias but not definition");
1029 if (weakref
&& !alias
)
1031 error ("node is weakref but not an alias");
1034 if (same_comdat_group
)
1036 symtab_node
*n
= same_comdat_group
;
1038 if (!n
->get_comdat_group ())
1040 error ("node is in same_comdat_group list but has no comdat_group");
1043 if (n
->get_comdat_group () != get_comdat_group ())
1045 error ("same_comdat_group list across different groups");
1050 error ("Node has same_comdat_group but it is not a definition");
1053 if (n
->type
!= type
)
1055 error ("mixing different types of symbol in same comdat groups is not supported");
1060 error ("node is alone in a comdat group");
1065 if (!n
->same_comdat_group
)
1067 error ("same_comdat_group is not a circular list");
1071 n
= n
->same_comdat_group
;
1074 if (comdat_local_p ())
1076 ipa_ref
*ref
= NULL
;
1078 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1080 if (!in_same_comdat_group_p (ref
->referring
))
1082 error ("comdat-local symbol referred to by %s outside its "
1084 identifier_to_locale (ref
->referring
->name()));
1090 if (implicit_section
&& !get_section ())
1092 error ("implicit_section flag is set but section isn't");
1095 if (get_section () && get_comdat_group ()
1096 && !implicit_section
)
1098 error ("Both section and comdat group is set");
1101 /* TODO: Add string table for sections, so we do not keep holding duplicated
1103 if (alias
&& definition
1104 && get_section () != get_alias_target ()->get_section ()
1106 || !get_alias_target ()->get_section ()
1107 || strcmp (get_section(),
1108 get_alias_target ()->get_section ())))
1110 error ("Alias and target's section differs");
1111 get_alias_target ()->dump (stderr
);
1114 if (alias
&& definition
1115 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1117 error ("Alias and target's comdat groups differs");
1118 get_alias_target ()->dump (stderr
);
1125 /* Verify consistency of NODE. */
1128 symtab_node::verify (void)
1133 timevar_push (TV_CGRAPH_VERIFY
);
1134 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1135 node
->verify_node ();
1140 internal_error ("symtab_node::verify failed");
1142 timevar_pop (TV_CGRAPH_VERIFY
);
1145 /* Verify symbol table for internal consistency. */
1148 symtab_node::verify_symtab_nodes (void)
1151 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1153 FOR_EACH_SYMBOL (node
)
1156 if (node
->get_comdat_group ())
1158 symtab_node
**entry
, *s
;
1161 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1166 for (s
= (*entry
)->same_comdat_group
; s
!= NULL
&& s
!= node
; s
= s
->same_comdat_group
)
1167 if (!s
|| s
== *entry
)
1169 error ("Two symbols with same comdat_group are not linked by the same_comdat_group list.");
1172 internal_error ("symtab_node::verify failed");
1178 /* Return true when NODE is known to be used from other (non-LTO)
1179 object file. Known only when doing LTO via linker plugin. */
1182 symtab_node::used_from_object_file_p_worker (symtab_node
*node
)
1184 if (!TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
))
1186 if (resolution_used_from_other_file_p (node
->resolution
))
1192 /* Return true when symtab_node is known to be used from other (non-LTO)
1193 object file. Known only when doing LTO via linker plugin. */
1196 symtab_node::used_from_object_file_p (void)
1198 return symtab_node::used_from_object_file_p_worker (this);
1201 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1202 but other code such as notice_global_symbol generates rtl. */
1205 symtab_node::make_decl_local (void)
1209 /* Avoid clearing comdat_groups on comdat-local decls. */
1210 if (TREE_PUBLIC (decl
) == 0)
1213 if (TREE_CODE (decl
) == VAR_DECL
)
1214 DECL_COMMON (decl
) = 0;
1215 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1217 DECL_COMDAT (decl
) = 0;
1218 DECL_WEAK (decl
) = 0;
1219 DECL_EXTERNAL (decl
) = 0;
1220 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1221 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1222 TREE_PUBLIC (decl
) = 0;
1223 if (!DECL_RTL_SET_P (decl
))
1226 /* Update rtl flags. */
1227 make_decl_rtl (decl
);
1229 rtl
= DECL_RTL (decl
);
1233 symbol
= XEXP (rtl
, 0);
1234 if (GET_CODE (symbol
) != SYMBOL_REF
)
1237 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1240 /* Walk the alias chain to return the symbol NODE is alias of.
1241 If NODE is not an alias, return NODE.
1242 When AVAILABILITY is non-NULL, get minimal availability in the chain. */
1245 symtab_node::ultimate_alias_target (enum availability
*availability
)
1247 bool weakref_p
= false;
1252 *availability
= get_availability ();
1256 /* To determine visibility of the target, we follow ELF semantic of aliases.
1257 Here alias is an alternative assembler name of a given definition. Its
1258 availability prevails the availability of its target (i.e. static alias of
1259 weak definition is available.
1261 Weakref is a different animal (and not part of ELF per se). It is just
1262 alternative name of a given symbol used within one complation unit
1263 and is translated prior hitting the object file. It inherits the
1264 visibility of its target (i.e. weakref of non-overwritable definition
1265 is non-overwritable, while weakref of weak definition is weak).
1267 If we ever get into supporting targets with different semantics, a target
1268 hook will be needed here. */
1272 weakref_p
= weakref
;
1274 *availability
= get_availability ();
1276 *availability
= AVAIL_LOCAL
;
1279 symtab_node
*node
= this;
1282 if (node
->alias
&& node
->analyzed
)
1283 node
= node
->get_alias_target ();
1288 else if (node
->analyzed
)
1292 enum availability a
= node
->get_availability ();
1293 if (a
< *availability
)
1298 *availability
= AVAIL_NOT_AVAILABLE
;
1301 if (node
&& availability
&& weakref_p
)
1303 enum availability a
= node
->get_availability ();
1304 if (a
< *availability
)
1306 weakref_p
= node
->weakref
;
1310 *availability
= AVAIL_NOT_AVAILABLE
;
1314 /* C++ FE sometimes change linkage flags after producing same body aliases.
1316 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1317 are obviously equivalent. The way it is doing so is however somewhat
1318 kludgy and interferes with the visibility code. As a result we need to
1319 copy the visibility from the target to get things right. */
1322 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1324 if (is_a
<cgraph_node
*> (this))
1326 DECL_DECLARED_INLINE_P (decl
)
1327 = DECL_DECLARED_INLINE_P (target
->decl
);
1328 DECL_DISREGARD_INLINE_LIMITS (decl
)
1329 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1331 /* FIXME: It is not really clear why those flags should not be copied for
1335 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1336 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1337 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1339 DECL_VIRTUAL_P (decl
) = DECL_VIRTUAL_P (target
->decl
);
1340 if (TREE_PUBLIC (decl
))
1344 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1345 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1346 group
= target
->get_comdat_group ();
1347 set_comdat_group (group
);
1348 if (group
&& !same_comdat_group
)
1349 add_to_same_comdat_group (target
);
1351 externally_visible
= target
->externally_visible
;
1354 /* Set section, do not recurse into aliases.
1355 When one wants to change section of symbol and its aliases,
1359 symtab_node::set_section_for_node (const char *section
)
1361 const char *current
= get_section ();
1362 section_hash_entry
**slot
;
1364 if (current
== section
1365 || (current
&& section
1366 && !strcmp (current
, section
)))
1371 x_section
->ref_count
--;
1372 if (!x_section
->ref_count
)
1374 hashval_t hash
= htab_hash_string (x_section
->name
);
1375 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1377 ggc_free (x_section
);
1378 symtab
->section_hash
->clear_slot (slot
);
1384 implicit_section
= false;
1387 if (!symtab
->section_hash
)
1388 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1389 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1390 htab_hash_string (section
),
1393 x_section
= (section_hash_entry
*)*slot
;
1396 int len
= strlen (section
);
1397 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1398 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1399 memcpy (x_section
->name
, section
, len
+ 1);
1401 x_section
->ref_count
++;
1404 /* Worker for set_section. */
1407 symtab_node::set_section (symtab_node
*n
, void *s
)
1409 n
->set_section_for_node ((char *)s
);
1413 /* Set section of symbol and its aliases. */
1416 symtab_node::set_section (const char *section
)
1418 gcc_assert (!this->alias
);
1419 call_for_symbol_and_aliases
1420 (symtab_node::set_section
, const_cast<char *>(section
), true);
1423 /* Return the initialization priority. */
1426 symtab_node::get_init_priority ()
1428 if (!this->in_init_priority_hash
)
1429 return DEFAULT_INIT_PRIORITY
;
1431 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1432 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1435 /* Return availability of NODE. */
1436 enum availability
symtab_node::get_availability (void)
1438 if (is_a
<cgraph_node
*> (this))
1439 return dyn_cast
<cgraph_node
*> (this)->get_availability ();
1441 return dyn_cast
<varpool_node
*> (this)->get_availability ();;
1445 /* Return the finalization priority. */
1448 cgraph_node::get_fini_priority ()
1450 if (!this->in_init_priority_hash
)
1451 return DEFAULT_INIT_PRIORITY
;
1452 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1453 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1456 /* Return the initialization and finalization priority information for
1457 DECL. If there is no previous priority information, a freshly
1458 allocated structure is returned. */
1460 symbol_priority_map
*
1461 symtab_node::priority_info (void)
1463 if (!symtab
->init_priority_hash
)
1464 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1467 symbol_priority_map
*h
1468 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1471 h
->init
= DEFAULT_INIT_PRIORITY
;
1472 h
->fini
= DEFAULT_INIT_PRIORITY
;
1473 in_init_priority_hash
= true;
1479 /* Set initialization priority to PRIORITY. */
1482 symtab_node::set_init_priority (priority_type priority
)
1484 symbol_priority_map
*h
;
1486 if (is_a
<cgraph_node
*> (this))
1487 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1489 if (priority
== DEFAULT_INIT_PRIORITY
)
1491 gcc_assert (get_init_priority() == priority
);
1494 h
= priority_info ();
1498 /* Set fialization priority to PRIORITY. */
1501 cgraph_node::set_fini_priority (priority_type priority
)
1503 symbol_priority_map
*h
;
1505 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1507 if (priority
== DEFAULT_INIT_PRIORITY
)
1509 gcc_assert (get_fini_priority() == priority
);
1512 h
= priority_info ();
1516 /* Worker for symtab_resolve_alias. */
1519 symtab_node::set_implicit_section (symtab_node
*n
,
1520 void *data ATTRIBUTE_UNUSED
)
1522 n
->implicit_section
= true;
1526 /* Add reference recording that symtab node is alias of TARGET.
1527 The function can fail in the case of aliasing cycles; in this case
1528 it returns false. */
1531 symtab_node::resolve_alias (symtab_node
*target
)
1535 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1537 /* Never let cycles to creep into the symbol table alias references;
1538 those will make alias walkers to be infinite. */
1539 for (n
= target
; n
&& n
->alias
;
1540 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1543 if (is_a
<cgraph_node
*> (this))
1544 error ("function %q+D part of alias cycle", decl
);
1545 else if (is_a
<varpool_node
*> (this))
1546 error ("variable %q+D part of alias cycle", decl
);
1553 /* "analyze" the node - i.e. mark the reference. */
1557 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1559 /* Add alias into the comdat group of its target unless it is already there. */
1560 if (same_comdat_group
)
1561 remove_from_same_comdat_group ();
1562 set_comdat_group (NULL
);
1563 if (target
->get_comdat_group ())
1564 add_to_same_comdat_group (target
);
1566 if ((get_section () != target
->get_section ()
1567 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1569 error ("section of alias %q+D must match section of its target", decl
);
1571 call_for_symbol_and_aliases (symtab_node::set_section
,
1572 const_cast<char *>(target
->get_section ()), true);
1573 if (target
->implicit_section
)
1574 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1576 /* Alias targets become redundant after alias is resolved into an reference.
1577 We do not want to keep it around or we would have to mind updating them
1578 when renaming symbols. */
1579 alias_target
= NULL
;
1581 if (cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1582 fixup_same_cpp_alias_visibility (target
);
1584 /* If alias has address taken, so does the target. */
1586 target
->ultimate_alias_target ()->address_taken
= true;
1590 /* Call calback on symtab node and aliases associated to this node.
1591 When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
1595 symtab_node::call_for_symbol_and_aliases (bool (*callback
) (symtab_node
*,
1597 void *data
, bool include_overwritable
)
1602 if (callback (this, data
))
1604 for (i
= 0; iterate_referring (i
, ref
); i
++)
1605 if (ref
->use
== IPA_REF_ALIAS
)
1607 symtab_node
*alias
= ref
->referring
;
1608 if (include_overwritable
1609 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
1610 if (alias
->call_for_symbol_and_aliases (callback
, data
,
1611 include_overwritable
))
1617 /* Worker searching noninterposable alias. */
1620 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1622 if (decl_binds_to_current_def_p (node
->decl
))
1624 symtab_node
*fn
= node
->ultimate_alias_target ();
1626 /* Ensure that the alias is well formed this may not be the case
1627 of user defined aliases and currently it is not always the case
1628 of C++ same body aliases (that is a bug). */
1629 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1630 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1631 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1632 && flags_from_decl_or_type (node
->decl
)
1633 != flags_from_decl_or_type (fn
->decl
))
1634 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1637 *(symtab_node
**)data
= node
;
1643 /* If node can not be overwriten by static or dynamic linker to point to
1644 different definition, return NODE. Otherwise look for alias with such
1645 property and if none exists, introduce new one. */
1648 symtab_node::noninterposable_alias (void)
1651 symtab_node
*new_node
= NULL
;
1653 /* First try to look up existing alias or base object
1654 (if that is already non-overwritable). */
1655 symtab_node
*node
= ultimate_alias_target ();
1656 gcc_assert (!node
->alias
&& !node
->weakref
);
1657 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1658 (void *)&new_node
, true);
1661 #ifndef ASM_OUTPUT_DEF
1662 /* If aliases aren't supported by the assembler, fail. */
1666 /* Otherwise create a new one. */
1667 new_decl
= copy_node (node
->decl
);
1668 DECL_NAME (new_decl
) = clone_function_name (node
->decl
, "localalias");
1669 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1670 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1671 DECL_INITIAL (new_decl
) = NULL
;
1672 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1673 SET_DECL_RTL (new_decl
, NULL
);
1675 /* Update the properties. */
1676 DECL_EXTERNAL (new_decl
) = 0;
1677 TREE_PUBLIC (new_decl
) = 0;
1678 DECL_COMDAT (new_decl
) = 0;
1679 DECL_WEAK (new_decl
) = 0;
1681 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1682 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1683 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1685 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1686 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1687 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1691 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1692 DECL_INITIAL (new_decl
) = error_mark_node
;
1693 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1695 new_node
->resolve_alias (node
);
1696 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1697 && targetm
.binds_local_p (new_decl
));
1701 /* Return true if symtab node and TARGET represents
1702 semantically equivalent symbols. */
1705 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1707 enum availability avail
;
1711 /* Equivalent functions are equivalent. */
1712 if (decl
== target
->decl
)
1715 /* If symbol is not overwritable by different implementation,
1716 walk to the base object it defines. */
1717 ba
= ultimate_alias_target (&avail
);
1718 if (avail
>= AVAIL_AVAILABLE
)
1725 bb
= target
->ultimate_alias_target (&avail
);
1726 if (avail
>= AVAIL_AVAILABLE
)
1736 /* Classify symbol symtab node for partitioning. */
1738 enum symbol_partitioning_class
1739 symtab_node::get_partitioning_class (void)
1741 /* Inline clones are always duplicated.
1742 This include external delcarations. */
1743 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
1745 if (DECL_ABSTRACT_P (decl
))
1746 return SYMBOL_EXTERNAL
;
1748 if (cnode
&& cnode
->global
.inlined_to
)
1749 return SYMBOL_DUPLICATE
;
1751 /* Weakref aliases are always duplicated. */
1753 return SYMBOL_DUPLICATE
;
1755 /* External declarations are external. */
1756 if (DECL_EXTERNAL (decl
))
1757 return SYMBOL_EXTERNAL
;
1759 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
1761 /* Constant pool references use local symbol names that can not
1762 be promoted global. We should never put into a constant pool
1763 objects that can not be duplicated across partitions. */
1764 if (DECL_IN_CONSTANT_POOL (decl
))
1765 return SYMBOL_DUPLICATE
;
1766 gcc_checking_assert (vnode
->definition
);
1768 /* Functions that are cloned may stay in callgraph even if they are unused.
1769 Handle them as external; compute_ltrans_boundary take care to make
1770 proper things to happen (i.e. to make them appear in the boundary but
1771 with body streamed, so clone can me materialized). */
1772 else if (!dyn_cast
<cgraph_node
*> (this)->definition
)
1773 return SYMBOL_EXTERNAL
;
1775 /* Linker discardable symbols are duplicated to every use unless they are
1777 if (DECL_ONE_ONLY (decl
)
1780 && !used_from_object_file_p ())
1781 return SYMBOL_DUPLICATE
;
1783 return SYMBOL_PARTITION
;
1786 /* Return true when symbol is known to be non-zero. */
1789 symtab_node::nonzero_address ()
1791 /* Weakrefs may be NULL when their target is not defined. */
1792 if (alias
&& weakref
)
1796 symtab_node
*target
= ultimate_alias_target ();
1798 if (target
->alias
&& target
->weakref
)
1800 /* We can not recurse to target::nonzero. It is possible that the
1801 target is used only via the alias.
1802 We may walk references and look for strong use, but we do not know
1803 if this strong use will survive to final binary, so be
1805 ??? Maybe we could do the lookup during late optimization that
1806 could be useful to eliminate the NULL pointer checks in LTO
1808 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
1810 if (target
->resolution
!= LDPR_UNKNOWN
1811 && target
->resolution
!= LDPR_UNDEF
1812 && flag_delete_null_pointer_checks
)
1820 /* With !flag_delete_null_pointer_checks we assume that symbols may
1821 bind to NULL. This is on by default on embedded targets only.
1823 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
1824 linking fails. Important case of WEAK we want to do well are comdats.
1825 Those are handled by later check for definition.
1827 When parsing, beware the cases when WEAK attribute is added later. */
1828 if (!DECL_WEAK (decl
)
1829 && flag_delete_null_pointer_checks
)
1831 refuse_visibility_changes
= true;
1835 /* If target is defined and not extern, we know it will be output and thus
1836 it will bind to non-NULL.
1837 Play safe for flag_delete_null_pointer_checks where weak definition maye
1838 be re-defined by NULL. */
1839 if (definition
&& !DECL_EXTERNAL (decl
)
1840 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
1842 if (!DECL_WEAK (decl
))
1843 refuse_visibility_changes
= true;
1847 /* As the last resort, check the resolution info. */
1848 if (resolution
!= LDPR_UNKNOWN
1849 && resolution
!= LDPR_UNDEF
1850 && flag_delete_null_pointer_checks
)