2 Copyright (C) 2012-2020 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
31 #include "lto-streamer.h"
32 #include "print-tree.h"
34 #include "langhooks.h"
36 #include "ipa-utils.h"
38 #include "stringpool.h"
42 static const char *ipa_ref_use_name
[] = {"read","write","addr","alias"};
44 const char * const ld_plugin_symbol_resolution_names
[]=
49 "prevailing_def_ironly",
55 "prevailing_def_ironly_exp"
58 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
59 until we find an identifier that is not itself a transparent alias. */
62 ultimate_transparent_alias_target (tree alias
)
66 while (IDENTIFIER_TRANSPARENT_ALIAS (target
))
68 gcc_checking_assert (TREE_CHAIN (target
));
69 target
= TREE_CHAIN (target
);
71 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target
)
72 && ! TREE_CHAIN (target
));
78 /* Hash asmnames ignoring the user specified marks. */
81 symbol_table::decl_assembler_name_hash (const_tree asmname
)
83 if (IDENTIFIER_POINTER (asmname
)[0] == '*')
85 const char *decl_str
= IDENTIFIER_POINTER (asmname
) + 1;
86 size_t ulp_len
= strlen (user_label_prefix
);
90 else if (strncmp (decl_str
, user_label_prefix
, ulp_len
) == 0)
93 return htab_hash_string (decl_str
);
96 return htab_hash_string (IDENTIFIER_POINTER (asmname
));
99 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
103 symbol_table::assembler_names_equal_p (const char *name1
, const char *name2
)
109 size_t ulp_len
= strlen (user_label_prefix
);
115 else if (strncmp (name1
, user_label_prefix
, ulp_len
) == 0)
122 size_t ulp_len
= strlen (user_label_prefix
);
128 else if (strncmp (name2
, user_label_prefix
, ulp_len
) == 0)
133 return !strcmp (name1
, name2
);
138 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
141 symbol_table::decl_assembler_name_equal (tree decl
, const_tree asmname
)
143 tree decl_asmname
= DECL_ASSEMBLER_NAME (decl
);
144 const char *decl_str
;
145 const char *asmname_str
;
147 if (decl_asmname
== asmname
)
150 decl_str
= IDENTIFIER_POINTER (decl_asmname
);
151 asmname_str
= IDENTIFIER_POINTER (asmname
);
152 return assembler_names_equal_p (decl_str
, asmname_str
);
156 /* Returns nonzero if P1 and P2 are equal. */
158 /* Insert NODE to assembler name hash. */
161 symbol_table::insert_to_assembler_name_hash (symtab_node
*node
,
164 if (is_a
<varpool_node
*> (node
) && DECL_HARD_REGISTER (node
->decl
))
166 gcc_checking_assert (!node
->previous_sharing_asm_name
167 && !node
->next_sharing_asm_name
);
168 if (assembler_name_hash
)
172 tree decl
= node
->decl
;
174 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
176 /* C++ FE can produce decls without associated assembler name and insert
177 them to symtab to hold section or TLS information. */
181 hashval_t hash
= decl_assembler_name_hash (name
);
182 aslot
= assembler_name_hash
->find_slot_with_hash (name
, hash
, INSERT
);
183 gcc_assert (*aslot
!= node
);
184 node
->next_sharing_asm_name
= (symtab_node
*)*aslot
;
186 (*aslot
)->previous_sharing_asm_name
= node
;
189 /* Update also possible inline clones sharing a decl. */
190 cnode
= dyn_cast
<cgraph_node
*> (node
);
191 if (cnode
&& cnode
->clones
&& with_clones
)
192 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
193 if (cnode
->decl
== decl
)
194 insert_to_assembler_name_hash (cnode
, true);
199 /* Remove NODE from assembler name hash. */
202 symbol_table::unlink_from_assembler_name_hash (symtab_node
*node
,
205 if (assembler_name_hash
)
208 tree decl
= node
->decl
;
210 if (node
->next_sharing_asm_name
)
211 node
->next_sharing_asm_name
->previous_sharing_asm_name
212 = node
->previous_sharing_asm_name
;
213 if (node
->previous_sharing_asm_name
)
215 node
->previous_sharing_asm_name
->next_sharing_asm_name
216 = node
->next_sharing_asm_name
;
220 tree name
= DECL_ASSEMBLER_NAME (node
->decl
);
226 hashval_t hash
= decl_assembler_name_hash (name
);
227 slot
= assembler_name_hash
->find_slot_with_hash (name
, hash
,
229 gcc_assert (*slot
== node
);
230 if (!node
->next_sharing_asm_name
)
231 assembler_name_hash
->clear_slot (slot
);
233 *slot
= node
->next_sharing_asm_name
;
235 node
->next_sharing_asm_name
= NULL
;
236 node
->previous_sharing_asm_name
= NULL
;
238 /* Update also possible inline clones sharing a decl. */
239 cnode
= dyn_cast
<cgraph_node
*> (node
);
240 if (cnode
&& cnode
->clones
&& with_clones
)
241 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
242 if (cnode
->decl
== decl
)
243 unlink_from_assembler_name_hash (cnode
, true);
247 /* Arrange node to be first in its entry of assembler_name_hash. */
250 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node
*node
)
252 unlink_from_assembler_name_hash (node
, false);
253 insert_to_assembler_name_hash (node
, false);
256 /* Initialize asm name hash unless. */
259 symbol_table::symtab_initialize_asm_name_hash (void)
262 if (!assembler_name_hash
)
264 assembler_name_hash
= hash_table
<asmname_hasher
>::create_ggc (10);
265 FOR_EACH_SYMBOL (node
)
266 insert_to_assembler_name_hash (node
, false);
270 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
273 symbol_table::change_decl_assembler_name (tree decl
, tree name
)
275 symtab_node
*node
= NULL
;
277 /* We can have user ASM names on things, like global register variables, that
278 are not in the symbol table. */
279 if ((VAR_P (decl
) && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
280 || TREE_CODE (decl
) == FUNCTION_DECL
)
281 node
= symtab_node::get (decl
);
282 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
284 SET_DECL_ASSEMBLER_NAME (decl
, name
);
286 insert_to_assembler_name_hash (node
, true);
290 if (name
== DECL_ASSEMBLER_NAME (decl
))
293 tree alias
= (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
))
294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
297 unlink_from_assembler_name_hash (node
, true);
299 const char *old_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
300 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
301 && DECL_RTL_SET_P (decl
))
302 warning (0, "%qD renamed after being referenced in assembly", decl
);
304 SET_DECL_ASSEMBLER_NAME (decl
, name
);
307 IDENTIFIER_TRANSPARENT_ALIAS (name
) = 1;
308 TREE_CHAIN (name
) = alias
;
310 /* If we change assembler name, also all transparent aliases must
311 be updated. There are three kinds - those having same assembler name,
312 those being renamed in varasm.c and weakref being renamed by the
316 insert_to_assembler_name_hash (node
, true);
318 for (unsigned i
= 0; node
->iterate_direct_aliases (i
, ref
); i
++)
320 struct symtab_node
*alias
= ref
->referring
;
321 if (alias
->transparent_alias
&& !alias
->weakref
322 && symbol_table::assembler_names_equal_p
323 (old_name
, IDENTIFIER_POINTER (
324 DECL_ASSEMBLER_NAME (alias
->decl
))))
325 change_decl_assembler_name (alias
->decl
, name
);
326 else if (alias
->transparent_alias
327 && IDENTIFIER_TRANSPARENT_ALIAS (alias
->decl
))
329 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
))
330 && IDENTIFIER_TRANSPARENT_ALIAS
331 (DECL_ASSEMBLER_NAME (alias
->decl
)));
333 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias
->decl
)) =
334 ultimate_transparent_alias_target
335 (DECL_ASSEMBLER_NAME (node
->decl
));
337 #ifdef ASM_OUTPUT_WEAKREF
338 else gcc_assert (!alias
->transparent_alias
|| alias
->weakref
);
340 else gcc_assert (!alias
->transparent_alias
);
343 gcc_assert (!node
->transparent_alias
|| !node
->definition
345 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
))
346 || symbol_table::assembler_names_equal_p
347 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
350 (node
->get_alias_target ()->decl
))));
355 /* Hash sections by their names. */
358 section_name_hasher::hash (section_hash_entry
*n
)
360 return htab_hash_string (n
->name
);
363 /* Return true if section P1 name equals to P2. */
366 section_name_hasher::equal (section_hash_entry
*n1
, const char *name
)
368 return n1
->name
== name
|| !strcmp (n1
->name
, name
);
371 /* Add node into symbol table. This function is not used directly, but via
372 cgraph/varpool node creation routines. */
375 symtab_node::register_symbol (void)
377 symtab
->register_symbol (this);
379 if (!decl
->decl_with_vis
.symtab_node
)
380 decl
->decl_with_vis
.symtab_node
= this;
384 /* Be sure to do this last; C++ FE might create new nodes via
385 DECL_ASSEMBLER_NAME langhook! */
386 symtab
->insert_to_assembler_name_hash (this, false);
389 /* Remove NODE from same comdat group. */
392 symtab_node::remove_from_same_comdat_group (void)
394 if (same_comdat_group
)
397 for (prev
= same_comdat_group
;
398 prev
->same_comdat_group
!= this;
399 prev
= prev
->same_comdat_group
)
401 if (same_comdat_group
== prev
)
402 prev
->same_comdat_group
= NULL
;
404 prev
->same_comdat_group
= same_comdat_group
;
405 same_comdat_group
= NULL
;
406 set_comdat_group (NULL
);
410 /* Remove node from symbol table. This function is not used directly, but via
411 cgraph/varpool node removal routines. */
414 symtab_node::unregister (void)
416 remove_all_references ();
417 remove_all_referring ();
419 /* Remove reference to section. */
420 set_section_for_node (NULL
);
422 remove_from_same_comdat_group ();
424 symtab
->unregister (this);
426 /* During LTO symtab merging we temporarily corrupt decl to symtab node
428 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
429 if (decl
->decl_with_vis
.symtab_node
== this)
431 symtab_node
*replacement_node
= NULL
;
432 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
433 replacement_node
= cnode
->find_replacement ();
434 decl
->decl_with_vis
.symtab_node
= replacement_node
;
436 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
437 symtab
->unlink_from_assembler_name_hash (this, false);
438 if (in_init_priority_hash
)
439 symtab
->init_priority_hash
->remove (this);
443 /* Remove symbol from symbol table. */
446 symtab_node::remove (void)
448 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
450 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
454 /* Add NEW_ to the same comdat group that OLD is in. */
457 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
459 gcc_assert (old_node
->get_comdat_group ());
460 gcc_assert (!same_comdat_group
);
461 gcc_assert (this != old_node
);
463 set_comdat_group (old_node
->get_comdat_group ());
464 same_comdat_group
= old_node
;
465 if (!old_node
->same_comdat_group
)
466 old_node
->same_comdat_group
= this;
470 for (n
= old_node
->same_comdat_group
;
471 n
->same_comdat_group
!= old_node
;
472 n
= n
->same_comdat_group
)
474 n
->same_comdat_group
= this;
478 if (comdat_local_p ()
479 && (n
= dyn_cast
<cgraph_node
*> (this)) != NULL
)
481 for (cgraph_edge
*e
= n
->callers
; e
; e
= e
->next_caller
)
482 if (e
->caller
->inlined_to
)
483 e
->caller
->inlined_to
->calls_comdat_local
= true;
485 e
->caller
->calls_comdat_local
= true;
489 /* Dissolve the same_comdat_group list in which NODE resides. */
492 symtab_node::dissolve_same_comdat_group_list (void)
494 symtab_node
*n
= this;
497 if (!same_comdat_group
)
501 next
= n
->same_comdat_group
;
502 n
->same_comdat_group
= NULL
;
503 if (dyn_cast
<cgraph_node
*> (n
))
504 dyn_cast
<cgraph_node
*> (n
)->calls_comdat_local
= false;
505 /* Clear comdat_group for comdat locals, since
506 make_decl_local doesn't. */
507 if (!TREE_PUBLIC (n
->decl
))
508 n
->set_comdat_group (NULL
);
514 /* Return printable assembler name of NODE.
515 This function is used only for debugging. When assembler name
516 is unknown go with identifier name. */
519 symtab_node::asm_name () const
521 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
523 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
526 /* Return printable identifier name. */
529 symtab_node::name () const
531 if (!DECL_NAME (decl
))
533 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
538 return lang_hooks
.decl_printable_name (decl
, 2);
542 symtab_node::get_dump_name (bool asm_name_p
) const
545 const char *fname
= asm_name_p
? asm_name () : name ();
546 unsigned l
= strlen (fname
);
548 char *s
= (char *)ggc_internal_cleared_alloc (l
+ EXTRA
);
549 snprintf (s
, l
+ EXTRA
, "%s/%d", fname
, order
);
555 symtab_node::dump_name () const
557 return get_dump_name (false);
561 symtab_node::dump_asm_name () const
563 return get_dump_name (true);
566 /* Return ipa reference from this symtab_node to
567 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
571 symtab_node::create_reference (symtab_node
*referred_node
,
572 enum ipa_ref_use use_type
)
574 return create_reference (referred_node
, use_type
, NULL
);
578 /* Return ipa reference from this symtab_node to
579 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
580 of the use and STMT the statement (if it exists). */
583 symtab_node::create_reference (symtab_node
*referred_node
,
584 enum ipa_ref_use use_type
, gimple
*stmt
)
586 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
587 ipa_ref_list
*list
, *list2
;
588 ipa_ref_t
*old_references
;
590 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
591 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
594 old_references
= vec_safe_address (list
->references
);
595 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1,
597 ref
= &list
->references
->last ();
599 list2
= &referred_node
->ref_list
;
601 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
602 if(use_type
== IPA_REF_ALIAS
)
604 list2
->referring
.safe_insert (0, ref
);
605 ref
->referred_index
= 0;
607 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
608 list2
->referring
[i
]->referred_index
= i
;
612 list2
->referring
.safe_push (ref
);
613 ref
->referred_index
= list2
->referring
.length () - 1;
616 ref
->referring
= this;
617 ref
->referred
= referred_node
;
619 ref
->lto_stmt_uid
= 0;
620 ref
->speculative_id
= 0;
622 ref
->speculative
= 0;
624 /* If vector was moved in memory, update pointers. */
625 if (old_references
!= list
->references
->address ())
628 for (i
= 0; iterate_reference(i
, ref2
); i
++)
629 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
635 symtab_node::maybe_create_reference (tree val
, gimple
*stmt
)
638 ipa_ref_use use_type
;
640 switch (TREE_CODE (val
))
643 use_type
= IPA_REF_LOAD
;
646 use_type
= IPA_REF_ADDR
;
649 gcc_assert (!handled_component_p (val
));
653 val
= get_base_var (val
);
654 if (val
&& VAR_OR_FUNCTION_DECL_P (val
))
656 symtab_node
*referred
= symtab_node::get (val
);
657 gcc_checking_assert (referred
);
658 return create_reference (referred
, use_type
, stmt
);
663 /* Clone all references from symtab NODE to this symtab_node. */
666 symtab_node::clone_references (symtab_node
*node
)
668 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
670 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
672 bool speculative
= ref
->speculative
;
673 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
674 unsigned int spec_id
= ref
->speculative_id
;
676 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
677 ref2
->speculative
= speculative
;
678 ref2
->lto_stmt_uid
= stmt_uid
;
679 ref2
->speculative_id
= spec_id
;
683 /* Clone all referring from symtab NODE to this symtab_node. */
686 symtab_node::clone_referring (symtab_node
*node
)
688 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
690 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
692 bool speculative
= ref
->speculative
;
693 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
694 unsigned int spec_id
= ref
->speculative_id
;
696 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
697 ref2
->speculative
= speculative
;
698 ref2
->lto_stmt_uid
= stmt_uid
;
699 ref2
->speculative_id
= spec_id
;
703 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
706 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
708 bool speculative
= ref
->speculative
;
709 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
710 unsigned int spec_id
= ref
->speculative_id
;
713 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
714 ref2
->speculative
= speculative
;
715 ref2
->lto_stmt_uid
= stmt_uid
;
716 ref2
->speculative_id
= spec_id
;
720 /* Find the structure describing a reference to REFERRED_NODE
721 and associated with statement STMT. */
724 symtab_node::find_reference (symtab_node
*referred_node
,
725 gimple
*stmt
, unsigned int lto_stmt_uid
)
730 for (i
= 0; iterate_reference (i
, r
); i
++)
731 if (r
->referred
== referred_node
733 && ((stmt
&& r
->stmt
== stmt
)
734 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
735 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
740 /* Remove all references that are associated with statement STMT. */
743 symtab_node::remove_stmt_references (gimple
*stmt
)
748 while (iterate_reference (i
, r
))
750 r
->remove_reference ();
755 /* Remove all stmt references in non-speculative references in THIS
757 Those are not maintained during inlining & cloning.
758 The exception are speculative references that are updated along
759 with callgraph edges associated with them. */
762 symtab_node::clear_stmts_in_references (void)
767 for (i
= 0; iterate_reference (i
, r
); i
++)
772 r
->speculative_id
= 0;
774 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
778 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
779 cnode
->clear_stmts_in_references ();
783 /* Remove all references in ref list. */
786 symtab_node::remove_all_references (void)
788 while (vec_safe_length (ref_list
.references
))
789 ref_list
.references
->last ().remove_reference ();
790 vec_free (ref_list
.references
);
793 /* Remove all referring items in ref list. */
796 symtab_node::remove_all_referring (void)
798 while (ref_list
.referring
.length ())
799 ref_list
.referring
.last ()->remove_reference ();
800 ref_list
.referring
.release ();
803 /* Dump references in ref list to FILE. */
806 symtab_node::dump_references (FILE *file
)
810 for (i
= 0; iterate_reference (i
, ref
); i
++)
812 fprintf (file
, "%s (%s) ", ref
->referred
->dump_asm_name (),
813 ipa_ref_use_name
[ref
->use
]);
814 if (ref
->speculative
)
815 fprintf (file
, "(speculative) ");
817 fprintf (file
, "\n");
820 /* Dump referring in list to FILE. */
823 symtab_node::dump_referring (FILE *file
)
827 for (i
= 0; iterate_referring(i
, ref
); i
++)
829 fprintf (file
, "%s (%s) ", ref
->referring
->dump_asm_name (),
830 ipa_ref_use_name
[ref
->use
]);
831 if (ref
->speculative
)
832 fprintf (file
, "(speculative) ");
834 fprintf (file
, "\n");
837 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
839 /* Dump the visibility of the symbol. */
842 symtab_node::get_visibility_string () const
844 static const char * const visibility_types
[]
845 = { "default", "protected", "hidden", "internal" };
846 return visibility_types
[DECL_VISIBILITY (decl
)];
849 /* Dump the type_name of the symbol. */
851 symtab_node::get_symtab_type_string () const
853 return symtab_type_names
[type
];
856 /* Dump base fields of symtab nodes to F. Not to be used directly. */
859 symtab_node::dump_base (FILE *f
)
861 static const char * const visibility_types
[] = {
862 "default", "protected", "hidden", "internal"
865 fprintf (f
, "%s (%s)", dump_asm_name (), name ());
866 dump_addr (f
, " @", (void *)this);
867 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
870 fprintf (f
, " definition");
872 fprintf (f
, " analyzed");
874 fprintf (f
, " alias");
875 if (transparent_alias
)
876 fprintf (f
, " transparent_alias");
878 fprintf (f
, " weakref");
880 fprintf (f
, " symver");
881 if (cpp_implicit_alias
)
882 fprintf (f
, " cpp_implicit_alias");
884 fprintf (f
, " target:%s",
885 DECL_P (alias_target
)
886 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
888 : IDENTIFIER_POINTER (alias_target
));
890 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
891 fprintf (f
, "\n Visibility:");
892 if (in_other_partition
)
893 fprintf (f
, " in_other_partition");
894 if (used_from_other_partition
)
895 fprintf (f
, " used_from_other_partition");
897 fprintf (f
, " force_output");
899 fprintf (f
, " forced_by_abi");
900 if (externally_visible
)
901 fprintf (f
, " externally_visible");
903 fprintf (f
, " no_reorder");
904 if (resolution
!= LDPR_UNKNOWN
)
906 ld_plugin_symbol_resolution_names
[(int)resolution
]);
907 if (TREE_ASM_WRITTEN (decl
))
908 fprintf (f
, " asm_written");
909 if (DECL_EXTERNAL (decl
))
910 fprintf (f
, " external");
911 if (TREE_PUBLIC (decl
))
912 fprintf (f
, " public");
913 if (DECL_COMMON (decl
))
914 fprintf (f
, " common");
915 if (DECL_WEAK (decl
))
916 fprintf (f
, " weak");
917 if (DECL_DLLIMPORT_P (decl
))
918 fprintf (f
, " dll_import");
919 if (DECL_COMDAT (decl
))
920 fprintf (f
, " comdat");
921 if (get_comdat_group ())
922 fprintf (f
, " comdat_group:%s",
923 IDENTIFIER_POINTER (get_comdat_group_id ()));
924 if (DECL_ONE_ONLY (decl
))
925 fprintf (f
, " one_only");
927 fprintf (f
, " section:%s",
929 if (implicit_section
)
930 fprintf (f
," (implicit_section)");
931 if (DECL_VISIBILITY_SPECIFIED (decl
))
932 fprintf (f
, " visibility_specified");
933 if (DECL_VISIBILITY (decl
))
934 fprintf (f
, " visibility:%s",
935 visibility_types
[DECL_VISIBILITY (decl
)]);
936 if (DECL_VIRTUAL_P (decl
))
937 fprintf (f
, " virtual");
938 if (DECL_ARTIFICIAL (decl
))
939 fprintf (f
, " artificial");
940 if (TREE_CODE (decl
) == FUNCTION_DECL
)
942 if (DECL_STATIC_CONSTRUCTOR (decl
))
943 fprintf (f
, " constructor");
944 if (DECL_STATIC_DESTRUCTOR (decl
))
945 fprintf (f
, " destructor");
948 fprintf (f
, " ifunc_resolver");
951 if (same_comdat_group
)
952 fprintf (f
, " Same comdat group as: %s\n",
953 same_comdat_group
->dump_asm_name ());
954 if (next_sharing_asm_name
)
955 fprintf (f
, " next sharing asm name: %i\n",
956 next_sharing_asm_name
->order
);
957 if (previous_sharing_asm_name
)
958 fprintf (f
, " previous sharing asm name: %i\n",
959 previous_sharing_asm_name
->order
);
962 fprintf (f
, " Address is taken.\n");
965 fprintf (f
, " Aux:");
966 dump_addr (f
, " @", (void *)aux
);
970 fprintf (f
, " References: ");
972 fprintf (f
, " Referring: ");
975 fprintf (f
, " Read from file: %s\n",
976 lto_file_data
->file_name
);
979 /* Dump symtab node to F. */
982 symtab_node::dump (FILE *f
)
984 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
986 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
991 symtab_node::dump_graphviz (FILE *f
)
993 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
994 cnode
->dump_graphviz (f
);
998 symbol_table::dump (FILE *f
)
1001 fprintf (f
, "Symbol table:\n\n");
1002 FOR_EACH_SYMBOL (node
)
1007 symbol_table::dump_graphviz (FILE *f
)
1010 fprintf (f
, "digraph symtab {\n");
1011 FOR_EACH_SYMBOL (node
)
1012 node
->dump_graphviz (f
);
1017 symbol_table::debug (void)
1022 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1023 Return NULL if there's no such node. */
1026 symtab_node::get_for_asmname (const_tree asmname
)
1030 symtab
->symtab_initialize_asm_name_hash ();
1031 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
1033 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
1044 /* Dump symtab node NODE to stderr. */
1047 symtab_node::debug (void)
1052 /* Verify common part of symtab nodes. */
1055 /* Disable warnings about missing quoting in GCC diagnostics for
1056 the verification errors. Their format strings don't follow GCC
1057 diagnostic conventions and the calls are ultimately followed by
1058 one to internal_error. */
1059 # pragma GCC diagnostic push
1060 # pragma GCC diagnostic ignored "-Wformat-diag"
1064 symtab_node::verify_base (void)
1066 bool error_found
= false;
1067 symtab_node
*hashed_node
;
1069 if (is_a
<cgraph_node
*> (this))
1071 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1073 error ("function symbol is not function");
1076 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
))
1078 != dyn_cast
<cgraph_node
*> (this)->ifunc_resolver
)
1080 error ("inconsistent %<ifunc%> attribute");
1084 else if (is_a
<varpool_node
*> (this))
1088 error ("variable symbol is not variable");
1094 error ("node has unknown type");
1097 if (order
< 0 || order
>= symtab
->order
)
1099 error ("node has invalid order %i", order
);
1103 if (symtab
->state
!= LTO_STREAMING
)
1105 hashed_node
= symtab_node::get (decl
);
1108 error ("node not found node->decl->decl_with_vis.symtab_node");
1111 if (hashed_node
!= this
1112 && (!is_a
<cgraph_node
*> (this)
1113 || !dyn_cast
<cgraph_node
*> (this)->clone_of
1114 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1116 error ("node differs from node->decl->decl_with_vis.symtab_node");
1120 if (symtab
->assembler_name_hash
)
1122 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1125 if (hashed_node
->previous_sharing_asm_name
)
1127 error ("assembler name hash list corrupted");
1130 else if (previous_sharing_asm_name
== NULL
)
1132 if (hashed_node
!= this)
1134 error ("assembler name hash list corrupted");
1138 else if (!(is_a
<varpool_node
*> (this) && DECL_HARD_REGISTER (decl
)))
1140 if (!asmname_hasher::equal (previous_sharing_asm_name
,
1141 DECL_ASSEMBLER_NAME (decl
)))
1143 error ("node not found in symtab assembler name hash");
1149 if (previous_sharing_asm_name
1150 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1152 error ("double linked list of assembler names corrupted");
1155 if (body_removed
&& definition
)
1157 error ("node has body_removed but is definition");
1160 if (analyzed
&& !definition
)
1162 error ("node is analyzed but it is not a definition");
1165 if (cpp_implicit_alias
&& !alias
)
1167 error ("node is alias but not implicit alias");
1170 if (alias
&& !definition
&& !weakref
)
1172 error ("node is alias but not definition");
1175 if (weakref
&& !transparent_alias
)
1177 error ("node is weakref but not an transparent_alias");
1180 if (transparent_alias
&& !alias
)
1182 error ("node is transparent_alias but not an alias");
1185 if (symver
&& !alias
)
1187 error ("node is symver but not alias");
1190 /* Limitation of gas requires us to output targets of symver aliases as
1191 global symbols. This is binutils PR 25295. */
1193 && (!TREE_PUBLIC (get_alias_target ()->decl
)
1194 || DECL_VISIBILITY (get_alias_target ()->decl
) != VISIBILITY_DEFAULT
))
1196 error ("symver target is not exported with default visibility");
1200 && (!TREE_PUBLIC (decl
)
1201 || DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
))
1203 error ("symver is not exported with default visibility");
1206 if (same_comdat_group
)
1208 symtab_node
*n
= same_comdat_group
;
1210 if (!n
->get_comdat_group ())
1212 error ("node is in same_comdat_group list but has no comdat_group");
1215 if (n
->get_comdat_group () != get_comdat_group ())
1217 error ("same_comdat_group list across different groups");
1220 if (n
->type
!= type
)
1222 error ("mixing different types of symbol in same comdat groups is not supported");
1227 error ("node is alone in a comdat group");
1232 if (!n
->same_comdat_group
)
1234 error ("same_comdat_group is not a circular list");
1238 n
= n
->same_comdat_group
;
1241 if (comdat_local_p ())
1243 ipa_ref
*ref
= NULL
;
1245 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1247 if (!in_same_comdat_group_p (ref
->referring
))
1249 error ("comdat-local symbol referred to by %s outside its "
1251 identifier_to_locale (ref
->referring
->name()));
1257 if (implicit_section
&& !get_section ())
1259 error ("implicit_section flag is set but section isn%'t");
1262 if (get_section () && get_comdat_group ()
1263 && !implicit_section
1264 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1266 error ("Both section and comdat group is set");
1269 /* TODO: Add string table for sections, so we do not keep holding duplicated
1271 if (alias
&& definition
1272 && get_section () != get_alias_target ()->get_section ()
1274 || !get_alias_target ()->get_section ()
1275 || strcmp (get_section(),
1276 get_alias_target ()->get_section ())))
1278 error ("Alias and target%'s section differs");
1279 get_alias_target ()->dump (stderr
);
1282 if (alias
&& definition
1283 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1285 error ("Alias and target%'s comdat groups differs");
1286 get_alias_target ()->dump (stderr
);
1289 if (transparent_alias
&& definition
&& !weakref
)
1291 symtab_node
*to
= get_alias_target ();
1293 = IDENTIFIER_POINTER (
1294 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1296 = IDENTIFIER_POINTER (
1297 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1298 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1300 error ("Transparent alias and target%'s assembler names differs");
1301 get_alias_target ()->dump (stderr
);
1305 if (transparent_alias
&& definition
1306 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1308 error ("Chained transparent aliases");
1309 get_alias_target ()->dump (stderr
);
1316 /* Verify consistency of NODE. */
1319 symtab_node::verify (void)
1324 timevar_push (TV_CGRAPH_VERIFY
);
1325 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1326 node
->verify_node ();
1331 internal_error ("symtab_node::verify failed");
1333 timevar_pop (TV_CGRAPH_VERIFY
);
1336 /* Verify symbol table for internal consistency. */
1339 symtab_node::verify_symtab_nodes (void)
1342 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1345 for (anode
= symtab
->first_asm_symbol (); anode
; anode
= anode
->next
)
1346 if (anode
->order
< 0 || anode
->order
>= symtab
->order
)
1348 error ("invalid order in asm node %i", anode
->order
);
1349 internal_error ("symtab_node::verify failed");
1352 FOR_EACH_SYMBOL (node
)
1355 if (node
->get_comdat_group ())
1357 symtab_node
**entry
, *s
;
1360 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1364 else if (!DECL_EXTERNAL (node
->decl
))
1366 for (s
= (*entry
)->same_comdat_group
;
1367 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1368 s
= s
->same_comdat_group
)
1370 if (!s
|| s
== *entry
)
1372 error ("Two symbols with same comdat_group are not linked by "
1373 "the same_comdat_group list.");
1376 internal_error ("symtab_node::verify failed");
1384 # pragma GCC diagnostic pop
1387 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1388 but other code such as notice_global_symbol generates rtl. */
1391 symtab_node::make_decl_local (void)
1398 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1399 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1400 symtab
->change_decl_assembler_name
1401 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1402 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1403 DECL_ATTRIBUTES (decl
));
1405 /* Avoid clearing comdat_groups on comdat-local decls. */
1406 else if (TREE_PUBLIC (decl
) == 0)
1409 /* Localizing a symbol also make all its transparent aliases local. */
1411 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1413 struct symtab_node
*alias
= ref
->referring
;
1414 if (alias
->transparent_alias
)
1415 alias
->make_decl_local ();
1420 DECL_COMMON (decl
) = 0;
1421 /* ADDRESSABLE flag is not defined for public symbols. */
1422 TREE_ADDRESSABLE (decl
) = 1;
1423 TREE_STATIC (decl
) = 1;
1426 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1428 DECL_COMDAT (decl
) = 0;
1429 DECL_WEAK (decl
) = 0;
1430 DECL_EXTERNAL (decl
) = 0;
1431 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1432 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1433 TREE_PUBLIC (decl
) = 0;
1434 DECL_DLLIMPORT_P (decl
) = 0;
1435 if (!DECL_RTL_SET_P (decl
))
1438 /* Update rtl flags. */
1439 make_decl_rtl (decl
);
1441 rtl
= DECL_RTL (decl
);
1445 symbol
= XEXP (rtl
, 0);
1446 if (GET_CODE (symbol
) != SYMBOL_REF
)
1449 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1452 /* Copy visibility from N.
1453 This is useful when THIS becomes a transparent alias of N. */
1456 symtab_node::copy_visibility_from (symtab_node
*n
)
1458 gcc_checking_assert (n
->weakref
== weakref
);
1461 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1463 struct symtab_node
*alias
= ref
->referring
;
1464 if (alias
->transparent_alias
)
1465 alias
->copy_visibility_from (n
);
1470 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1471 /* ADDRESSABLE flag is not defined for public symbols. */
1472 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1473 TREE_ADDRESSABLE (decl
) = 1;
1474 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1476 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1478 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1479 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1480 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1481 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1482 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1483 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1484 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1485 resolution
= n
->resolution
;
1486 set_comdat_group (n
->get_comdat_group ());
1487 call_for_symbol_and_aliases (symtab_node::set_section
,
1488 const_cast<char *>(n
->get_section ()), true);
1489 externally_visible
= n
->externally_visible
;
1490 if (!DECL_RTL_SET_P (decl
))
1493 /* Update rtl flags. */
1494 make_decl_rtl (decl
);
1496 rtx rtl
= DECL_RTL (decl
);
1500 rtx symbol
= XEXP (rtl
, 0);
1501 if (GET_CODE (symbol
) != SYMBOL_REF
)
1504 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1507 /* Walk the alias chain to return the symbol NODE is alias of.
1508 If NODE is not an alias, return NODE.
1509 Assumes NODE is known to be alias. */
1512 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1515 bool transparent_p
= false;
1517 /* To determine visibility of the target, we follow ELF semantic of aliases.
1518 Here alias is an alternative assembler name of a given definition. Its
1519 availability prevails the availability of its target (i.e. static alias of
1520 weak definition is available.
1522 Transparent alias is just alternative name of a given symbol used within
1523 one compilation unit and is translated prior hitting the object file. It
1524 inherits the visibility of its target.
1525 Weakref is a different animal (and noweak definition is weak).
1527 If we ever get into supporting targets with different semantics, a target
1528 hook will be needed here. */
1532 transparent_p
= transparent_alias
;
1534 *availability
= get_availability (ref
);
1536 *availability
= AVAIL_NOT_AVAILABLE
;
1539 symtab_node
*node
= this;
1542 if (node
->alias
&& node
->analyzed
)
1543 node
= node
->get_alias_target ();
1546 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1548 else if (node
->analyzed
&& !node
->transparent_alias
)
1549 *availability
= node
->get_availability (ref
);
1551 *availability
= AVAIL_NOT_AVAILABLE
;
1554 if (node
&& availability
&& transparent_p
1555 && node
->transparent_alias
)
1557 *availability
= node
->get_availability (ref
);
1558 transparent_p
= false;
1562 *availability
= AVAIL_NOT_AVAILABLE
;
1566 /* C++ FE sometimes change linkage flags after producing same body aliases.
1568 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1569 are obviously equivalent. The way it is doing so is however somewhat
1570 kludgy and interferes with the visibility code. As a result we need to
1571 copy the visibility from the target to get things right. */
1574 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1576 if (is_a
<cgraph_node
*> (this))
1578 DECL_DECLARED_INLINE_P (decl
)
1579 = DECL_DECLARED_INLINE_P (target
->decl
);
1580 DECL_DISREGARD_INLINE_LIMITS (decl
)
1581 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1583 /* FIXME: It is not really clear why those flags should not be copied for
1587 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1588 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1589 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1591 if (TREE_PUBLIC (decl
))
1595 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1596 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1597 group
= target
->get_comdat_group ();
1598 set_comdat_group (group
);
1599 if (group
&& !same_comdat_group
)
1600 add_to_same_comdat_group (target
);
1602 externally_visible
= target
->externally_visible
;
1605 /* Set section, do not recurse into aliases.
1606 When one wants to change section of a symbol and its aliases,
1610 symtab_node::set_section_for_node (const char *section
)
1612 const char *current
= get_section ();
1613 section_hash_entry
**slot
;
1615 if (current
== section
1616 || (current
&& section
1617 && !strcmp (current
, section
)))
1622 x_section
->ref_count
--;
1623 if (!x_section
->ref_count
)
1625 hashval_t hash
= htab_hash_string (x_section
->name
);
1626 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1628 ggc_free (x_section
);
1629 symtab
->section_hash
->clear_slot (slot
);
1635 implicit_section
= false;
1638 if (!symtab
->section_hash
)
1639 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1640 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1641 htab_hash_string (section
),
1644 x_section
= (section_hash_entry
*)*slot
;
1647 int len
= strlen (section
);
1648 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1649 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1650 memcpy (x_section
->name
, section
, len
+ 1);
1652 x_section
->ref_count
++;
1655 /* Worker for set_section. */
1658 symtab_node::set_section (symtab_node
*n
, void *s
)
1660 n
->set_section_for_node ((char *)s
);
1664 /* Set section of symbol and its aliases. */
1667 symtab_node::set_section (const char *section
)
1669 gcc_assert (!this->alias
|| !this->analyzed
);
1670 call_for_symbol_and_aliases
1671 (symtab_node::set_section
, const_cast<char *>(section
), true);
1674 /* Return the initialization priority. */
1677 symtab_node::get_init_priority ()
1679 if (!this->in_init_priority_hash
)
1680 return DEFAULT_INIT_PRIORITY
;
1682 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1683 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1686 /* Return the finalization priority. */
1689 cgraph_node::get_fini_priority ()
1691 if (!this->in_init_priority_hash
)
1692 return DEFAULT_INIT_PRIORITY
;
1693 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1694 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1697 /* Return the initialization and finalization priority information for
1698 DECL. If there is no previous priority information, a freshly
1699 allocated structure is returned. */
1701 symbol_priority_map
*
1702 symtab_node::priority_info (void)
1704 if (!symtab
->init_priority_hash
)
1705 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1708 symbol_priority_map
*h
1709 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1712 h
->init
= DEFAULT_INIT_PRIORITY
;
1713 h
->fini
= DEFAULT_INIT_PRIORITY
;
1714 in_init_priority_hash
= true;
1720 /* Set initialization priority to PRIORITY. */
1723 symtab_node::set_init_priority (priority_type priority
)
1725 symbol_priority_map
*h
;
1727 if (is_a
<cgraph_node
*> (this))
1728 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1730 if (priority
== DEFAULT_INIT_PRIORITY
)
1732 gcc_assert (get_init_priority() == priority
);
1735 h
= priority_info ();
1739 /* Set finalization priority to PRIORITY. */
1742 cgraph_node::set_fini_priority (priority_type priority
)
1744 symbol_priority_map
*h
;
1746 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1748 if (priority
== DEFAULT_INIT_PRIORITY
)
1750 gcc_assert (get_fini_priority() == priority
);
1753 h
= priority_info ();
1757 /* Worker for symtab_resolve_alias. */
1760 symtab_node::set_implicit_section (symtab_node
*n
,
1761 void *data ATTRIBUTE_UNUSED
)
1763 n
->implicit_section
= true;
1767 /* Add reference recording that symtab node is alias of TARGET.
1768 The function can fail in the case of aliasing cycles; in this case
1769 it returns false. */
1772 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1776 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1778 /* Never let cycles to creep into the symbol table alias references;
1779 those will make alias walkers to be infinite. */
1780 for (n
= target
; n
&& n
->alias
;
1781 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1784 if (is_a
<cgraph_node
*> (this))
1785 error ("function %q+D part of alias cycle", decl
);
1786 else if (is_a
<varpool_node
*> (this))
1787 error ("variable %q+D part of alias cycle", decl
);
1794 /* "analyze" the node - i.e. mark the reference. */
1798 transparent
|= transparent_alias
;
1799 transparent_alias
= transparent
;
1801 while (target
->transparent_alias
&& target
->analyzed
)
1802 target
= target
->get_alias_target ();
1803 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1805 /* Add alias into the comdat group of its target unless it is already there. */
1806 if (same_comdat_group
)
1807 remove_from_same_comdat_group ();
1808 set_comdat_group (NULL
);
1809 if (target
->get_comdat_group ())
1810 add_to_same_comdat_group (target
);
1812 if ((get_section () != target
->get_section ()
1813 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1815 error ("section of alias %q+D must match section of its target", decl
);
1817 call_for_symbol_and_aliases (symtab_node::set_section
,
1818 const_cast<char *>(target
->get_section ()), true);
1819 if (target
->implicit_section
)
1820 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1822 /* Alias targets become redundant after alias is resolved into an reference.
1823 We do not want to keep it around or we would have to mind updating them
1824 when renaming symbols. */
1825 alias_target
= NULL
;
1827 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1828 fixup_same_cpp_alias_visibility (target
);
1830 /* If alias has address taken, so does the target. */
1832 target
->ultimate_alias_target ()->address_taken
= true;
1834 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1835 If alias is transparent, also all transparent aliases of THIS are now
1837 Also merge same comdat group lists. */
1839 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1841 struct symtab_node
*alias_alias
= ref
->referring
;
1842 if (alias_alias
->get_comdat_group ())
1844 alias_alias
->remove_from_same_comdat_group ();
1845 alias_alias
->set_comdat_group (NULL
);
1846 if (target
->get_comdat_group ())
1847 alias_alias
->add_to_same_comdat_group (target
);
1849 if ((!alias_alias
->transparent_alias
1850 && !alias_alias
->symver
)
1853 alias_alias
->remove_all_references ();
1854 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1861 /* Worker searching noninterposable alias. */
1864 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1866 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1868 symtab_node
*fn
= node
->ultimate_alias_target ();
1870 /* Ensure that the alias is well formed this may not be the case
1871 of user defined aliases and currently it is not always the case
1872 of C++ same body aliases (that is a bug). */
1873 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1874 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1875 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1876 && flags_from_decl_or_type (node
->decl
)
1877 != flags_from_decl_or_type (fn
->decl
))
1878 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1880 *(symtab_node
**)data
= node
;
1886 /* If node cannot be overwriten by static or dynamic linker to point to
1887 different definition, return NODE. Otherwise look for alias with such
1888 property and if none exists, introduce new one. */
1891 symtab_node::noninterposable_alias (void)
1894 symtab_node
*new_node
= NULL
;
1896 /* First try to look up existing alias or base object
1897 (if that is already non-overwritable). */
1898 symtab_node
*node
= ultimate_alias_target ();
1899 gcc_assert (!node
->alias
&& !node
->weakref
);
1900 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1901 (void *)&new_node
, true);
1905 /* If aliases aren't supported by the assembler, fail. */
1906 if (!TARGET_SUPPORTS_ALIASES
)
1909 /* Otherwise create a new one. */
1910 new_decl
= copy_node (node
->decl
);
1911 DECL_DLLIMPORT_P (new_decl
) = 0;
1912 tree name
= clone_function_name (node
->decl
, "localalias");
1915 unsigned long num
= 0;
1916 /* In the rare case we already have a localalias, but the above
1917 node->call_for_symbol_and_aliases call didn't find any suitable,
1918 iterate until we find one not used yet. */
1919 while (symtab_node::get_for_asmname (name
))
1920 name
= clone_function_name (node
->decl
, "localalias", num
++);
1922 DECL_NAME (new_decl
) = name
;
1923 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1924 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1925 DECL_INITIAL (new_decl
) = NULL
;
1926 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1927 SET_DECL_RTL (new_decl
, NULL
);
1929 /* Update the properties. */
1930 DECL_EXTERNAL (new_decl
) = 0;
1931 TREE_PUBLIC (new_decl
) = 0;
1932 DECL_COMDAT (new_decl
) = 0;
1933 DECL_WEAK (new_decl
) = 0;
1935 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1936 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1937 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1939 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1940 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1941 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1943 cgraph_node
*new_cnode
= dyn_cast
<cgraph_node
*> (new_node
),
1944 *cnode
= dyn_cast
<cgraph_node
*> (node
);
1946 new_cnode
->unit_id
= cnode
->unit_id
;
1947 new_cnode
->merged_comdat
= cnode
->merged_comdat
;
1948 new_cnode
->merged_extern_inline
= cnode
->merged_extern_inline
;
1952 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1953 DECL_INITIAL (new_decl
) = error_mark_node
;
1954 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1956 new_node
->resolve_alias (node
);
1957 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1958 && targetm
.binds_local_p (new_decl
));
1962 /* Return true if symtab node and TARGET represents
1963 semantically equivalent symbols. */
1966 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1968 enum availability avail
;
1972 /* Equivalent functions are equivalent. */
1973 if (decl
== target
->decl
)
1976 /* If symbol is not overwritable by different implementation,
1977 walk to the base object it defines. */
1978 ba
= ultimate_alias_target (&avail
);
1979 if (avail
>= AVAIL_AVAILABLE
)
1986 bb
= target
->ultimate_alias_target (&avail
);
1987 if (avail
>= AVAIL_AVAILABLE
)
1997 /* Classify symbol symtab node for partitioning. */
1999 enum symbol_partitioning_class
2000 symtab_node::get_partitioning_class (void)
2002 /* Inline clones are always duplicated.
2003 This include external declarations. */
2004 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2006 if (DECL_ABSTRACT_P (decl
))
2007 return SYMBOL_EXTERNAL
;
2009 if (cnode
&& (cnode
->inlined_to
|| cnode
->declare_variant_alt
))
2010 return SYMBOL_DUPLICATE
;
2012 /* Transparent aliases are always duplicated. */
2013 if (transparent_alias
)
2014 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
2016 /* External declarations are external. */
2017 if (DECL_EXTERNAL (decl
))
2018 return SYMBOL_EXTERNAL
;
2020 /* Even static aliases of external functions as external. Those can happen
2021 when COMDAT got resolved to non-IL implementation. */
2022 if (alias
&& DECL_EXTERNAL (ultimate_alias_target ()->decl
))
2023 return SYMBOL_EXTERNAL
;
2025 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
2027 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
2028 return SYMBOL_EXTERNAL
;
2029 /* Constant pool references use local symbol names that cannot
2030 be promoted global. We should never put into a constant pool
2031 objects that cannot be duplicated across partitions. */
2032 if (DECL_IN_CONSTANT_POOL (decl
))
2033 return SYMBOL_DUPLICATE
;
2034 if (DECL_HARD_REGISTER (decl
))
2035 return SYMBOL_DUPLICATE
;
2036 gcc_checking_assert (vnode
->definition
);
2038 /* Functions that are cloned may stay in callgraph even if they are unused.
2039 Handle them as external; compute_ltrans_boundary take care to make
2040 proper things to happen (i.e. to make them appear in the boundary but
2041 with body streamed, so clone can me materialized). */
2042 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
2043 return SYMBOL_EXTERNAL
;
2045 /* Linker discardable symbols are duplicated to every use unless they are
2047 if (DECL_ONE_ONLY (decl
)
2050 && !used_from_object_file_p ())
2051 return SYMBOL_DUPLICATE
;
2053 return SYMBOL_PARTITION
;
2056 /* Return true when symbol is known to be non-zero. */
2059 symtab_node::nonzero_address ()
2061 /* Weakrefs may be NULL when their target is not defined. */
2062 if (alias
&& weakref
)
2066 symtab_node
*target
= ultimate_alias_target ();
2068 if (target
->alias
&& target
->weakref
)
2070 /* We cannot recurse to target::nonzero. It is possible that the
2071 target is used only via the alias.
2072 We may walk references and look for strong use, but we do not know
2073 if this strong use will survive to final binary, so be
2075 ??? Maybe we could do the lookup during late optimization that
2076 could be useful to eliminate the NULL pointer checks in LTO
2078 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
2080 if (target
->resolution
!= LDPR_UNKNOWN
2081 && target
->resolution
!= LDPR_UNDEF
2082 && !target
->can_be_discarded_p ()
2083 && flag_delete_null_pointer_checks
)
2091 /* With !flag_delete_null_pointer_checks we assume that symbols may
2092 bind to NULL. This is on by default on embedded targets only.
2094 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2095 linking fails. Important case of WEAK we want to do well are comdats,
2096 which also must be defined somewhere.
2098 When parsing, beware the cases when WEAK attribute is added later. */
2099 if ((!DECL_WEAK (decl
) || DECL_COMDAT (decl
))
2100 && flag_delete_null_pointer_checks
)
2102 refuse_visibility_changes
= true;
2106 /* If target is defined and not extern, we know it will be
2107 output and thus it will bind to non-NULL.
2108 Play safe for flag_delete_null_pointer_checks where weak definition may
2109 be re-defined by NULL. */
2110 if (definition
&& !DECL_EXTERNAL (decl
)
2111 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
2113 if (!DECL_WEAK (decl
))
2114 refuse_visibility_changes
= true;
2118 /* As the last resort, check the resolution info. */
2119 if (resolution
!= LDPR_UNKNOWN
2120 && resolution
!= LDPR_UNDEF
2121 && !can_be_discarded_p ()
2122 && flag_delete_null_pointer_checks
)
2127 /* Return 0 if symbol is known to have different address than S2,
2128 Return 1 if symbol is known to have same address as S2,
2129 return -1 otherwise.
2131 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2132 and S2 is going to be accessed. This eliminates the situations when
2133 either THIS or S2 is NULL and is useful for comparing bases when deciding
2134 about memory aliasing. */
2136 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
2138 enum availability avail1
, avail2
;
2140 /* A Shortcut: equivalent symbols are always equivalent. */
2144 /* Unwind transparent aliases first; those are always equal to their
2146 if (this->transparent_alias
&& this->analyzed
)
2147 return this->get_alias_target ()->equal_address_to (s2
);
2148 while (s2
->transparent_alias
&& s2
->analyzed
)
2149 s2
= s2
->get_alias_target();
2154 /* For non-interposable aliases, lookup and compare their actual definitions.
2155 Also check if the symbol needs to bind to given definition. */
2156 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
2157 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
2158 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
2159 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
2160 bool really_binds_local1
= binds_local1
;
2161 bool really_binds_local2
= binds_local2
;
2163 /* Addresses of vtables and virtual functions cannot be used by user
2164 code and are used only within speculation. In this case we may make
2165 symbol equivalent to its alias even if interposition may break this
2166 rule. Doing so will allow us to turn speculative inlining into
2167 non-speculative more aggressively. */
2168 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
2169 binds_local1
= true;
2170 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
2171 binds_local2
= true;
2173 /* If both definitions are available we know that even if they are bound
2174 to other unit they must be defined same way and therefore we can use
2175 equivalence test. */
2176 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
2177 binds_local1
= binds_local2
= true;
2179 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2181 /* We made use of the fact that alias is not weak. */
2183 refuse_visibility_changes
= true;
2185 s2
->refuse_visibility_changes
= true;
2189 /* If both symbols may resolve to NULL, we cannot really prove them
2191 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2194 /* Except for NULL, functions and variables never overlap. */
2195 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2198 /* If one of the symbols is unresolved alias, punt. */
2199 if (rs1
->alias
|| rs2
->alias
)
2202 /* If we have a non-interposale definition of at least one of the symbols
2203 and the other symbol is different, we know other unit cannot interpose
2204 it to the first symbol; all aliases of the definition needs to be
2205 present in the current unit. */
2206 if (((really_binds_local1
|| really_binds_local2
)
2207 /* If we have both definitions and they are different, we know they
2208 will be different even in units they binds to. */
2209 || (binds_local1
&& binds_local2
))
2212 /* We make use of the fact that one symbol is not alias of the other
2213 and that the definition is non-interposable. */
2214 refuse_visibility_changes
= true;
2215 s2
->refuse_visibility_changes
= true;
2216 rs1
->refuse_visibility_changes
= true;
2217 rs2
->refuse_visibility_changes
= true;
2221 /* TODO: Alias oracle basically assume that addresses of global variables
2222 are different unless they are declared as alias of one to another while
2223 the code folding comparisons doesn't.
2224 We probably should be consistent and use this fact here, too, but for
2225 the moment return false only when we are called from the alias oracle. */
2227 return memory_accessed
&& rs1
!= rs2
? 0 : -1;
2230 /* Worker for call_for_symbol_and_aliases. */
2233 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2236 bool include_overwritable
)
2239 FOR_EACH_ALIAS (this, ref
)
2241 symtab_node
*alias
= ref
->referring
;
2242 if (include_overwritable
2243 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2244 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2245 include_overwritable
))
2251 /* Return true if address of N is possibly compared. */
2254 address_matters_1 (symtab_node
*n
, void *)
2256 struct ipa_ref
*ref
;
2258 if (!n
->address_can_be_compared_p ())
2260 if (n
->externally_visible
|| n
->force_output
)
2263 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2264 if (ref
->address_matters_p ())
2269 /* Return true if symbol's address may possibly be compared to other
2270 symbol's address. */
2273 symtab_node::address_matters_p ()
2275 gcc_assert (!alias
);
2276 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2279 /* Return true if symbol's alignment may be increased. */
2282 symtab_node::can_increase_alignment_p (void)
2284 symtab_node
*target
= ultimate_alias_target ();
2286 /* For now support only variables. */
2290 /* With -fno-toplevel-reorder we may have already output the constant. */
2291 if (TREE_ASM_WRITTEN (target
->decl
))
2294 /* If target is already placed in an anchor, we cannot touch its
2296 if (DECL_RTL_SET_P (target
->decl
)
2297 && MEM_P (DECL_RTL (target
->decl
))
2298 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2301 /* Constant pool entries may be shared. */
2302 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2305 /* We cannot change alignment of symbols that may bind to symbols
2306 in other translation unit that may contain a definition with lower
2308 if (!decl_binds_to_current_def_p (decl
))
2311 /* When compiling partition, be sure the symbol is not output by other
2314 && (target
->in_other_partition
2315 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2318 /* Do not override the alignment as specified by the ABI when the used
2319 attribute is set. */
2320 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2323 /* Do not override explicit alignment set by the user when an explicit
2324 section name is also used. This is a common idiom used by many
2325 software projects. */
2326 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2332 /* Worker for symtab_node::increase_alignment. */
2335 increase_alignment_1 (symtab_node
*n
, void *v
)
2337 unsigned int align
= (size_t)v
;
2338 if (DECL_ALIGN (n
->decl
) < align
2339 && n
->can_increase_alignment_p ())
2341 SET_DECL_ALIGN (n
->decl
, align
);
2342 DECL_USER_ALIGN (n
->decl
) = 1;
2347 /* Increase alignment of THIS to ALIGN. */
2350 symtab_node::increase_alignment (unsigned int align
)
2352 gcc_assert (can_increase_alignment_p () && align
<= MAX_OFILE_ALIGNMENT
);
2353 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2354 (void *)(size_t) align
,
2356 gcc_assert (DECL_ALIGN (decl
) >= align
);
2359 /* Helper for symtab_node::definition_alignment. */
2362 get_alignment_1 (symtab_node
*n
, void *v
)
2364 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2368 /* Return desired alignment of the definition. This is NOT alignment useful
2369 to access THIS, because THIS may be interposable and DECL_ALIGN should
2370 be used instead. It however must be guaranteed when output definition
2374 symtab_node::definition_alignment ()
2376 unsigned int align
= 0;
2377 gcc_assert (!alias
);
2378 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2382 /* Return symbol used to separate symbol name from suffix. */
2385 symbol_table::symbol_suffix_separator ()
2387 #ifndef NO_DOT_IN_LABEL
2389 #elif !defined NO_DOLLAR_IN_LABEL
2396 /* Return true when references to this symbol from REF must bind to current
2397 definition in final executable. */
2400 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2402 if (!definition
&& !in_other_partition
)
2404 if (transparent_alias
)
2406 && get_alias_target()->binds_to_current_def_p (ref
);
2407 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2408 if (cnode
&& cnode
->ifunc_resolver
)
2410 if (decl_binds_to_current_def_p (decl
))
2413 /* Inline clones always binds locally. */
2414 if (cnode
&& cnode
->inlined_to
)
2417 if (DECL_EXTERNAL (decl
))
2420 gcc_assert (externally_visible
);
2424 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2426 ref
= cref
->inlined_to
;
2429 /* If this is a reference from symbol itself and there are no aliases, we
2430 may be sure that the symbol was not interposed by something else because
2431 the symbol itself would be unreachable otherwise. This is important
2432 to optimize recursive functions well.
2434 This assumption may be broken by inlining: if symbol is interposable
2435 but the body is available (i.e. declared inline), inliner may make
2436 the body reachable even with interposition. */
2437 if (this == ref
&& !has_aliases_p ()
2439 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2440 || get_availability () >= AVAIL_INTERPOSABLE
))
2444 /* References within one comdat group are always bound in a group. */
2446 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2447 && get_comdat_group ()
2448 && get_comdat_group () == ref
->get_comdat_group ())
2454 /* Return true if symbol should be output to the symbol table. */
2457 symtab_node::output_to_lto_symbol_table_p (void)
2459 /* Only externally visible symbols matter. */
2460 if (!TREE_PUBLIC (decl
))
2462 if (!real_symbol_p ())
2464 /* FIXME: variables probably should not be considered as real symbols at
2466 if (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
2468 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !definition
2469 && fndecl_built_in_p (decl
))
2471 /* Builtins like those for most math functions have actual implementations
2472 in libraries so make sure to output references into the symbol table to
2473 make those libraries referenced. Note this is incomplete handling for
2474 now and only covers math functions. */
2475 if (builtin_with_linkage_p (decl
))
2481 /* We have real symbol that should be in symbol table. However try to trim
2482 down the references to libraries bit more because linker will otherwise
2483 bring unnecessary object files into the final link.
2484 FIXME: The following checks can easily be confused i.e. by self recursive
2485 function or self-referring variable. */
2487 /* We keep external functions in symtab for sake of inlining
2488 and devirtualization. We do not want to see them in symbol table as
2489 references unless they are really used. */
2490 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2491 if (cnode
&& (!definition
|| DECL_EXTERNAL (decl
))
2495 /* Ignore all references from external vars initializers - they are not really
2496 part of the compilation unit until they are used by folding. Some symbols,
2497 like references to external construction vtables cannot be referred to at
2498 all. We decide this at can_refer_decl_in_current_unit_p. */
2499 if (!definition
|| DECL_EXTERNAL (decl
))
2502 struct ipa_ref
*ref
;
2503 for (i
= 0; iterate_referring (i
, ref
); i
++)
2505 if (ref
->use
== IPA_REF_ALIAS
)
2507 if (is_a
<cgraph_node
*> (ref
->referring
))
2509 if (!DECL_EXTERNAL (ref
->referring
->decl
))