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.
412 INFO is a clone info to attach to new root of clone tree (if any). */
415 symtab_node::unregister (clone_info
*info
)
417 remove_all_references ();
418 remove_all_referring ();
420 /* Remove reference to section. */
421 set_section_for_node (NULL
);
423 remove_from_same_comdat_group ();
425 symtab
->unregister (this);
427 /* During LTO symtab merging we temporarily corrupt decl to symtab node
429 gcc_assert (decl
->decl_with_vis
.symtab_node
|| in_lto_p
);
430 if (decl
->decl_with_vis
.symtab_node
== this)
432 symtab_node
*replacement_node
= NULL
;
433 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
434 replacement_node
= cnode
->find_replacement (info
);
435 decl
->decl_with_vis
.symtab_node
= replacement_node
;
437 if (!is_a
<varpool_node
*> (this) || !DECL_HARD_REGISTER (decl
))
438 symtab
->unlink_from_assembler_name_hash (this, false);
439 if (in_init_priority_hash
)
440 symtab
->init_priority_hash
->remove (this);
444 /* Remove symbol from symbol table. */
447 symtab_node::remove (void)
449 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
451 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
455 /* Add NEW_ to the same comdat group that OLD is in. */
458 symtab_node::add_to_same_comdat_group (symtab_node
*old_node
)
460 gcc_assert (old_node
->get_comdat_group ());
461 gcc_assert (!same_comdat_group
);
462 gcc_assert (this != old_node
);
464 set_comdat_group (old_node
->get_comdat_group ());
465 same_comdat_group
= old_node
;
466 if (!old_node
->same_comdat_group
)
467 old_node
->same_comdat_group
= this;
471 for (n
= old_node
->same_comdat_group
;
472 n
->same_comdat_group
!= old_node
;
473 n
= n
->same_comdat_group
)
475 n
->same_comdat_group
= this;
479 if (comdat_local_p ()
480 && (n
= dyn_cast
<cgraph_node
*> (this)) != NULL
)
482 for (cgraph_edge
*e
= n
->callers
; e
; e
= e
->next_caller
)
483 if (e
->caller
->inlined_to
)
484 e
->caller
->inlined_to
->calls_comdat_local
= true;
486 e
->caller
->calls_comdat_local
= true;
490 /* Dissolve the same_comdat_group list in which NODE resides. */
493 symtab_node::dissolve_same_comdat_group_list (void)
495 symtab_node
*n
= this;
498 if (!same_comdat_group
)
502 next
= n
->same_comdat_group
;
503 n
->same_comdat_group
= NULL
;
504 if (dyn_cast
<cgraph_node
*> (n
))
505 dyn_cast
<cgraph_node
*> (n
)->calls_comdat_local
= false;
506 /* Clear comdat_group for comdat locals, since
507 make_decl_local doesn't. */
508 if (!TREE_PUBLIC (n
->decl
))
509 n
->set_comdat_group (NULL
);
515 /* Return printable assembler name of NODE.
516 This function is used only for debugging. When assembler name
517 is unknown go with identifier name. */
520 symtab_node::asm_name () const
522 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
524 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
527 /* Return printable identifier name. */
530 symtab_node::name () const
532 if (!DECL_NAME (decl
))
534 if (DECL_ASSEMBLER_NAME_SET_P (decl
))
539 return lang_hooks
.decl_printable_name (decl
, 2);
543 symtab_node::get_dump_name (bool asm_name_p
) const
546 const char *fname
= asm_name_p
? asm_name () : name ();
547 unsigned l
= strlen (fname
);
549 char *s
= (char *)ggc_internal_cleared_alloc (l
+ EXTRA
);
550 snprintf (s
, l
+ EXTRA
, "%s/%d", fname
, order
);
556 symtab_node::dump_name () const
558 return get_dump_name (false);
562 symtab_node::dump_asm_name () const
564 return get_dump_name (true);
567 /* Return ipa reference from this symtab_node to
568 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
572 symtab_node::create_reference (symtab_node
*referred_node
,
573 enum ipa_ref_use use_type
)
575 return create_reference (referred_node
, use_type
, NULL
);
579 /* Return ipa reference from this symtab_node to
580 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
581 of the use and STMT the statement (if it exists). */
584 symtab_node::create_reference (symtab_node
*referred_node
,
585 enum ipa_ref_use use_type
, gimple
*stmt
)
587 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
588 ipa_ref_list
*list
, *list2
;
589 ipa_ref_t
*old_references
;
591 gcc_checking_assert (!stmt
|| is_a
<cgraph_node
*> (this));
592 gcc_checking_assert (use_type
!= IPA_REF_ALIAS
|| !stmt
);
595 old_references
= vec_safe_address (list
->references
);
596 vec_safe_grow (list
->references
, vec_safe_length (list
->references
) + 1,
598 ref
= &list
->references
->last ();
600 list2
= &referred_node
->ref_list
;
602 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
603 if(use_type
== IPA_REF_ALIAS
)
605 list2
->referring
.safe_insert (0, ref
);
606 ref
->referred_index
= 0;
608 for (unsigned int i
= 1; i
< list2
->referring
.length (); i
++)
609 list2
->referring
[i
]->referred_index
= i
;
613 list2
->referring
.safe_push (ref
);
614 ref
->referred_index
= list2
->referring
.length () - 1;
617 ref
->referring
= this;
618 ref
->referred
= referred_node
;
620 ref
->lto_stmt_uid
= 0;
621 ref
->speculative_id
= 0;
623 ref
->speculative
= 0;
625 /* If vector was moved in memory, update pointers. */
626 if (old_references
!= list
->references
->address ())
629 for (i
= 0; iterate_reference(i
, ref2
); i
++)
630 ref2
->referred_ref_list ()->referring
[ref2
->referred_index
] = ref2
;
636 symtab_node::maybe_create_reference (tree val
, gimple
*stmt
)
639 ipa_ref_use use_type
;
641 switch (TREE_CODE (val
))
644 use_type
= IPA_REF_LOAD
;
647 use_type
= IPA_REF_ADDR
;
650 gcc_assert (!handled_component_p (val
));
654 val
= get_base_var (val
);
655 if (val
&& VAR_OR_FUNCTION_DECL_P (val
))
657 symtab_node
*referred
= symtab_node::get (val
);
658 gcc_checking_assert (referred
);
659 return create_reference (referred
, use_type
, stmt
);
664 /* Clone all references from symtab NODE to this symtab_node. */
667 symtab_node::clone_references (symtab_node
*node
)
669 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
671 for (i
= 0; node
->iterate_reference (i
, ref
); i
++)
673 bool speculative
= ref
->speculative
;
674 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
675 unsigned int spec_id
= ref
->speculative_id
;
677 ref2
= create_reference (ref
->referred
, ref
->use
, ref
->stmt
);
678 ref2
->speculative
= speculative
;
679 ref2
->lto_stmt_uid
= stmt_uid
;
680 ref2
->speculative_id
= spec_id
;
684 /* Clone all referring from symtab NODE to this symtab_node. */
687 symtab_node::clone_referring (symtab_node
*node
)
689 ipa_ref
*ref
= NULL
, *ref2
= NULL
;
691 for (i
= 0; node
->iterate_referring(i
, ref
); i
++)
693 bool speculative
= ref
->speculative
;
694 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
695 unsigned int spec_id
= ref
->speculative_id
;
697 ref2
= ref
->referring
->create_reference (this, ref
->use
, ref
->stmt
);
698 ref2
->speculative
= speculative
;
699 ref2
->lto_stmt_uid
= stmt_uid
;
700 ref2
->speculative_id
= spec_id
;
704 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
707 symtab_node::clone_reference (ipa_ref
*ref
, gimple
*stmt
)
709 bool speculative
= ref
->speculative
;
710 unsigned int stmt_uid
= ref
->lto_stmt_uid
;
711 unsigned int spec_id
= ref
->speculative_id
;
714 ref2
= create_reference (ref
->referred
, ref
->use
, stmt
);
715 ref2
->speculative
= speculative
;
716 ref2
->lto_stmt_uid
= stmt_uid
;
717 ref2
->speculative_id
= spec_id
;
721 /* Find the structure describing a reference to REFERRED_NODE
722 and associated with statement STMT. */
725 symtab_node::find_reference (symtab_node
*referred_node
,
726 gimple
*stmt
, unsigned int lto_stmt_uid
)
731 for (i
= 0; iterate_reference (i
, r
); i
++)
732 if (r
->referred
== referred_node
734 && ((stmt
&& r
->stmt
== stmt
)
735 || (lto_stmt_uid
&& r
->lto_stmt_uid
== lto_stmt_uid
)
736 || (!stmt
&& !lto_stmt_uid
&& !r
->stmt
&& !r
->lto_stmt_uid
)))
741 /* Remove all references that are associated with statement STMT. */
744 symtab_node::remove_stmt_references (gimple
*stmt
)
749 while (iterate_reference (i
, r
))
751 r
->remove_reference ();
756 /* Remove all stmt references in non-speculative references in THIS
758 Those are not maintained during inlining & cloning.
759 The exception are speculative references that are updated along
760 with callgraph edges associated with them. */
763 symtab_node::clear_stmts_in_references (void)
768 for (i
= 0; iterate_reference (i
, r
); i
++)
773 r
->speculative_id
= 0;
775 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
779 for (cnode
= cnode
->clones
; cnode
; cnode
= cnode
->next_sibling_clone
)
780 cnode
->clear_stmts_in_references ();
784 /* Remove all references in ref list. */
787 symtab_node::remove_all_references (void)
789 while (vec_safe_length (ref_list
.references
))
790 ref_list
.references
->last ().remove_reference ();
791 vec_free (ref_list
.references
);
794 /* Remove all referring items in ref list. */
797 symtab_node::remove_all_referring (void)
799 while (ref_list
.referring
.length ())
800 ref_list
.referring
.last ()->remove_reference ();
801 ref_list
.referring
.release ();
804 /* Dump references in ref list to FILE. */
807 symtab_node::dump_references (FILE *file
)
811 for (i
= 0; iterate_reference (i
, ref
); i
++)
813 fprintf (file
, "%s (%s) ", ref
->referred
->dump_asm_name (),
814 ipa_ref_use_name
[ref
->use
]);
815 if (ref
->speculative
)
816 fprintf (file
, "(speculative) ");
818 fprintf (file
, "\n");
821 /* Dump referring in list to FILE. */
824 symtab_node::dump_referring (FILE *file
)
828 for (i
= 0; iterate_referring(i
, ref
); i
++)
830 fprintf (file
, "%s (%s) ", ref
->referring
->dump_asm_name (),
831 ipa_ref_use_name
[ref
->use
]);
832 if (ref
->speculative
)
833 fprintf (file
, "(speculative) ");
835 fprintf (file
, "\n");
838 static const char * const symtab_type_names
[] = {"symbol", "function", "variable"};
840 /* Dump the visibility of the symbol. */
843 symtab_node::get_visibility_string () const
845 static const char * const visibility_types
[]
846 = { "default", "protected", "hidden", "internal" };
847 return visibility_types
[DECL_VISIBILITY (decl
)];
850 /* Dump the type_name of the symbol. */
852 symtab_node::get_symtab_type_string () const
854 return symtab_type_names
[type
];
857 /* Dump base fields of symtab nodes to F. Not to be used directly. */
860 symtab_node::dump_base (FILE *f
)
862 static const char * const visibility_types
[] = {
863 "default", "protected", "hidden", "internal"
866 fprintf (f
, "%s (%s)", dump_asm_name (), name ());
867 dump_addr (f
, " @", (void *)this);
868 fprintf (f
, "\n Type: %s", symtab_type_names
[type
]);
871 fprintf (f
, " definition");
873 fprintf (f
, " analyzed");
875 fprintf (f
, " alias");
876 if (transparent_alias
)
877 fprintf (f
, " transparent_alias");
879 fprintf (f
, " weakref");
881 fprintf (f
, " symver");
882 if (cpp_implicit_alias
)
883 fprintf (f
, " cpp_implicit_alias");
885 fprintf (f
, " target:%s",
886 DECL_P (alias_target
)
887 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
889 : IDENTIFIER_POINTER (alias_target
));
891 fprintf (f
, "\n Body removed by symtab_remove_unreachable_nodes");
892 fprintf (f
, "\n Visibility:");
893 if (in_other_partition
)
894 fprintf (f
, " in_other_partition");
895 if (used_from_other_partition
)
896 fprintf (f
, " used_from_other_partition");
898 fprintf (f
, " force_output");
900 fprintf (f
, " forced_by_abi");
901 if (externally_visible
)
902 fprintf (f
, " externally_visible");
904 fprintf (f
, " no_reorder");
905 if (resolution
!= LDPR_UNKNOWN
)
907 ld_plugin_symbol_resolution_names
[(int)resolution
]);
908 if (TREE_ASM_WRITTEN (decl
))
909 fprintf (f
, " asm_written");
910 if (DECL_EXTERNAL (decl
))
911 fprintf (f
, " external");
912 if (TREE_PUBLIC (decl
))
913 fprintf (f
, " public");
914 if (DECL_COMMON (decl
))
915 fprintf (f
, " common");
916 if (DECL_WEAK (decl
))
917 fprintf (f
, " weak");
918 if (DECL_DLLIMPORT_P (decl
))
919 fprintf (f
, " dll_import");
920 if (DECL_COMDAT (decl
))
921 fprintf (f
, " comdat");
922 if (get_comdat_group ())
923 fprintf (f
, " comdat_group:%s",
924 IDENTIFIER_POINTER (get_comdat_group_id ()));
925 if (DECL_ONE_ONLY (decl
))
926 fprintf (f
, " one_only");
928 fprintf (f
, " section:%s",
930 if (implicit_section
)
931 fprintf (f
," (implicit_section)");
932 if (DECL_VISIBILITY_SPECIFIED (decl
))
933 fprintf (f
, " visibility_specified");
934 if (DECL_VISIBILITY (decl
))
935 fprintf (f
, " visibility:%s",
936 visibility_types
[DECL_VISIBILITY (decl
)]);
937 if (DECL_VIRTUAL_P (decl
))
938 fprintf (f
, " virtual");
939 if (DECL_ARTIFICIAL (decl
))
940 fprintf (f
, " artificial");
941 if (TREE_CODE (decl
) == FUNCTION_DECL
)
943 if (DECL_STATIC_CONSTRUCTOR (decl
))
944 fprintf (f
, " constructor");
945 if (DECL_STATIC_DESTRUCTOR (decl
))
946 fprintf (f
, " destructor");
949 fprintf (f
, " ifunc_resolver");
952 if (same_comdat_group
)
953 fprintf (f
, " Same comdat group as: %s\n",
954 same_comdat_group
->dump_asm_name ());
955 if (next_sharing_asm_name
)
956 fprintf (f
, " next sharing asm name: %i\n",
957 next_sharing_asm_name
->order
);
958 if (previous_sharing_asm_name
)
959 fprintf (f
, " previous sharing asm name: %i\n",
960 previous_sharing_asm_name
->order
);
963 fprintf (f
, " Address is taken.\n");
966 fprintf (f
, " Aux:");
967 dump_addr (f
, " @", (void *)aux
);
971 fprintf (f
, " References: ");
973 fprintf (f
, " Referring: ");
976 fprintf (f
, " Read from file: %s\n",
977 lto_file_data
->file_name
);
980 /* Dump symtab node to F. */
983 symtab_node::dump (FILE *f
)
985 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
987 else if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
992 symtab_node::dump_graphviz (FILE *f
)
994 if (cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this))
995 cnode
->dump_graphviz (f
);
999 symbol_table::dump (FILE *f
)
1002 fprintf (f
, "Symbol table:\n\n");
1003 FOR_EACH_SYMBOL (node
)
1008 symbol_table::dump_graphviz (FILE *f
)
1011 fprintf (f
, "digraph symtab {\n");
1012 FOR_EACH_SYMBOL (node
)
1013 node
->dump_graphviz (f
);
1018 symbol_table::debug (void)
1023 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
1024 Return NULL if there's no such node. */
1027 symtab_node::get_for_asmname (const_tree asmname
)
1031 symtab
->symtab_initialize_asm_name_hash ();
1032 hashval_t hash
= symtab
->decl_assembler_name_hash (asmname
);
1034 = symtab
->assembler_name_hash
->find_slot_with_hash (asmname
, hash
,
1045 /* Dump symtab node NODE to stderr. */
1048 symtab_node::debug (void)
1053 /* Verify common part of symtab nodes. */
1056 /* Disable warnings about missing quoting in GCC diagnostics for
1057 the verification errors. Their format strings don't follow GCC
1058 diagnostic conventions and the calls are ultimately followed by
1059 one to internal_error. */
1060 # pragma GCC diagnostic push
1061 # pragma GCC diagnostic ignored "-Wformat-diag"
1065 symtab_node::verify_base (void)
1067 bool error_found
= false;
1068 symtab_node
*hashed_node
;
1070 if (is_a
<cgraph_node
*> (this))
1072 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1074 error ("function symbol is not function");
1077 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl
))
1079 != dyn_cast
<cgraph_node
*> (this)->ifunc_resolver
)
1081 error ("inconsistent %<ifunc%> attribute");
1085 else if (is_a
<varpool_node
*> (this))
1089 error ("variable symbol is not variable");
1095 error ("node has unknown type");
1098 if (order
< 0 || order
>= symtab
->order
)
1100 error ("node has invalid order %i", order
);
1104 if (symtab
->state
!= LTO_STREAMING
)
1106 hashed_node
= symtab_node::get (decl
);
1109 error ("node not found node->decl->decl_with_vis.symtab_node");
1112 if (hashed_node
!= this
1113 && (!is_a
<cgraph_node
*> (this)
1114 || !dyn_cast
<cgraph_node
*> (this)->clone_of
1115 || dyn_cast
<cgraph_node
*> (this)->clone_of
->decl
!= decl
))
1117 error ("node differs from node->decl->decl_with_vis.symtab_node");
1121 if (symtab
->assembler_name_hash
)
1123 hashed_node
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));
1126 if (hashed_node
->previous_sharing_asm_name
)
1128 error ("assembler name hash list corrupted");
1131 else if (previous_sharing_asm_name
== NULL
)
1133 if (hashed_node
!= this)
1135 error ("assembler name hash list corrupted");
1139 else if (!(is_a
<varpool_node
*> (this) && DECL_HARD_REGISTER (decl
)))
1141 if (!asmname_hasher::equal (previous_sharing_asm_name
,
1142 DECL_ASSEMBLER_NAME (decl
)))
1144 error ("node not found in symtab assembler name hash");
1150 if (previous_sharing_asm_name
1151 && previous_sharing_asm_name
->next_sharing_asm_name
!= this)
1153 error ("double linked list of assembler names corrupted");
1156 if (body_removed
&& definition
)
1158 error ("node has body_removed but is definition");
1161 if (analyzed
&& !definition
)
1163 error ("node is analyzed but it is not a definition");
1166 if (cpp_implicit_alias
&& !alias
)
1168 error ("node is alias but not implicit alias");
1171 if (alias
&& !definition
&& !weakref
)
1173 error ("node is alias but not definition");
1176 if (weakref
&& !transparent_alias
)
1178 error ("node is weakref but not an transparent_alias");
1181 if (transparent_alias
&& !alias
)
1183 error ("node is transparent_alias but not an alias");
1186 if (symver
&& !alias
)
1188 error ("node is symver but not alias");
1191 /* Limitation of gas requires us to output targets of symver aliases as
1192 global symbols. This is binutils PR 25295. */
1194 && (!TREE_PUBLIC (get_alias_target ()->decl
)
1195 || DECL_VISIBILITY (get_alias_target ()->decl
) != VISIBILITY_DEFAULT
))
1197 error ("symver target is not exported with default visibility");
1201 && (!TREE_PUBLIC (decl
)
1202 || DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
))
1204 error ("symver is not exported with default visibility");
1207 if (same_comdat_group
)
1209 symtab_node
*n
= same_comdat_group
;
1211 if (!n
->get_comdat_group ())
1213 error ("node is in same_comdat_group list but has no comdat_group");
1216 if (n
->get_comdat_group () != get_comdat_group ())
1218 error ("same_comdat_group list across different groups");
1221 if (n
->type
!= type
)
1223 error ("mixing different types of symbol in same comdat groups is not supported");
1228 error ("node is alone in a comdat group");
1233 if (!n
->same_comdat_group
)
1235 error ("same_comdat_group is not a circular list");
1239 n
= n
->same_comdat_group
;
1242 if (comdat_local_p ())
1244 ipa_ref
*ref
= NULL
;
1246 for (int i
= 0; iterate_referring (i
, ref
); ++i
)
1248 if (!in_same_comdat_group_p (ref
->referring
))
1250 error ("comdat-local symbol referred to by %s outside its "
1252 identifier_to_locale (ref
->referring
->name()));
1258 if (implicit_section
&& !get_section ())
1260 error ("implicit_section flag is set but section isn%'t");
1263 if (get_section () && get_comdat_group ()
1264 && !implicit_section
1265 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl
)))
1267 error ("Both section and comdat group is set");
1270 /* TODO: Add string table for sections, so we do not keep holding duplicated
1272 if (alias
&& definition
1273 && get_section () != get_alias_target ()->get_section ()
1275 || !get_alias_target ()->get_section ()
1276 || strcmp (get_section(),
1277 get_alias_target ()->get_section ())))
1279 error ("Alias and target%'s section differs");
1280 get_alias_target ()->dump (stderr
);
1283 if (alias
&& definition
1284 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
1286 error ("Alias and target%'s comdat groups differs");
1287 get_alias_target ()->dump (stderr
);
1290 if (transparent_alias
&& definition
&& !weakref
)
1292 symtab_node
*to
= get_alias_target ();
1294 = IDENTIFIER_POINTER (
1295 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl
)));
1297 = IDENTIFIER_POINTER (
1298 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to
->decl
)));
1299 if (!symbol_table::assembler_names_equal_p (name1
, name2
))
1301 error ("Transparent alias and target%'s assembler names differs");
1302 get_alias_target ()->dump (stderr
);
1306 if (transparent_alias
&& definition
1307 && get_alias_target()->transparent_alias
&& get_alias_target()->analyzed
)
1309 error ("Chained transparent aliases");
1310 get_alias_target ()->dump (stderr
);
1317 /* Verify consistency of NODE. */
1320 symtab_node::verify (void)
1325 timevar_push (TV_CGRAPH_VERIFY
);
1326 if (cgraph_node
*node
= dyn_cast
<cgraph_node
*> (this))
1327 node
->verify_node ();
1332 internal_error ("symtab_node::verify failed");
1334 timevar_pop (TV_CGRAPH_VERIFY
);
1337 /* Verify symbol table for internal consistency. */
1340 symtab_node::verify_symtab_nodes (void)
1343 hash_map
<tree
, symtab_node
*> comdat_head_map (251);
1346 for (anode
= symtab
->first_asm_symbol (); anode
; anode
= anode
->next
)
1347 if (anode
->order
< 0 || anode
->order
>= symtab
->order
)
1349 error ("invalid order in asm node %i", anode
->order
);
1350 internal_error ("symtab_node::verify failed");
1353 FOR_EACH_SYMBOL (node
)
1356 if (node
->get_comdat_group ())
1358 symtab_node
**entry
, *s
;
1361 entry
= &comdat_head_map
.get_or_insert (node
->get_comdat_group (),
1365 else if (!DECL_EXTERNAL (node
->decl
))
1367 for (s
= (*entry
)->same_comdat_group
;
1368 s
!= NULL
&& s
!= node
&& s
!= *entry
;
1369 s
= s
->same_comdat_group
)
1371 if (!s
|| s
== *entry
)
1373 error ("Two symbols with same comdat_group are not linked by "
1374 "the same_comdat_group list.");
1377 internal_error ("symtab_node::verify failed");
1385 # pragma GCC diagnostic pop
1388 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
1389 but other code such as notice_global_symbol generates rtl. */
1392 symtab_node::make_decl_local (void)
1399 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl
)) = 0;
1400 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl
)) = NULL_TREE
;
1401 symtab
->change_decl_assembler_name
1402 (decl
, DECL_ASSEMBLER_NAME (get_alias_target ()->decl
));
1403 DECL_ATTRIBUTES (decl
) = remove_attribute ("weakref",
1404 DECL_ATTRIBUTES (decl
));
1406 /* Avoid clearing comdat_groups on comdat-local decls. */
1407 else if (TREE_PUBLIC (decl
) == 0)
1410 /* Localizing a symbol also make all its transparent aliases local. */
1412 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1414 struct symtab_node
*alias
= ref
->referring
;
1415 if (alias
->transparent_alias
)
1416 alias
->make_decl_local ();
1421 DECL_COMMON (decl
) = 0;
1422 /* ADDRESSABLE flag is not defined for public symbols. */
1423 TREE_ADDRESSABLE (decl
) = 1;
1424 TREE_STATIC (decl
) = 1;
1427 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1429 DECL_COMDAT (decl
) = 0;
1430 DECL_WEAK (decl
) = 0;
1431 DECL_EXTERNAL (decl
) = 0;
1432 DECL_VISIBILITY_SPECIFIED (decl
) = 0;
1433 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
1434 TREE_PUBLIC (decl
) = 0;
1435 DECL_DLLIMPORT_P (decl
) = 0;
1436 if (!DECL_RTL_SET_P (decl
))
1439 /* Update rtl flags. */
1440 make_decl_rtl (decl
);
1442 rtl
= DECL_RTL (decl
);
1446 symbol
= XEXP (rtl
, 0);
1447 if (GET_CODE (symbol
) != SYMBOL_REF
)
1450 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1453 /* Copy visibility from N.
1454 This is useful when THIS becomes a transparent alias of N. */
1457 symtab_node::copy_visibility_from (symtab_node
*n
)
1459 gcc_checking_assert (n
->weakref
== weakref
);
1462 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
); i
++)
1464 struct symtab_node
*alias
= ref
->referring
;
1465 if (alias
->transparent_alias
)
1466 alias
->copy_visibility_from (n
);
1471 DECL_COMMON (decl
) = DECL_COMMON (n
->decl
);
1472 /* ADDRESSABLE flag is not defined for public symbols. */
1473 if (TREE_PUBLIC (decl
) && !TREE_PUBLIC (n
->decl
))
1474 TREE_ADDRESSABLE (decl
) = 1;
1475 TREE_STATIC (decl
) = TREE_STATIC (n
->decl
);
1477 else gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
1479 DECL_COMDAT (decl
) = DECL_COMDAT (n
->decl
);
1480 DECL_WEAK (decl
) = DECL_WEAK (n
->decl
);
1481 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (n
->decl
);
1482 DECL_VISIBILITY_SPECIFIED (decl
) = DECL_VISIBILITY_SPECIFIED (n
->decl
);
1483 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (n
->decl
);
1484 TREE_PUBLIC (decl
) = TREE_PUBLIC (n
->decl
);
1485 DECL_DLLIMPORT_P (decl
) = DECL_DLLIMPORT_P (n
->decl
);
1486 resolution
= n
->resolution
;
1487 set_comdat_group (n
->get_comdat_group ());
1488 call_for_symbol_and_aliases (symtab_node::set_section
,
1489 const_cast<char *>(n
->get_section ()), true);
1490 externally_visible
= n
->externally_visible
;
1491 if (!DECL_RTL_SET_P (decl
))
1494 /* Update rtl flags. */
1495 make_decl_rtl (decl
);
1497 rtx rtl
= DECL_RTL (decl
);
1501 rtx symbol
= XEXP (rtl
, 0);
1502 if (GET_CODE (symbol
) != SYMBOL_REF
)
1505 SYMBOL_REF_WEAK (symbol
) = DECL_WEAK (decl
);
1508 /* Walk the alias chain to return the symbol NODE is alias of.
1509 If NODE is not an alias, return NODE.
1510 Assumes NODE is known to be alias. */
1513 symtab_node::ultimate_alias_target_1 (enum availability
*availability
,
1516 bool transparent_p
= false;
1518 /* To determine visibility of the target, we follow ELF semantic of aliases.
1519 Here alias is an alternative assembler name of a given definition. Its
1520 availability prevails the availability of its target (i.e. static alias of
1521 weak definition is available.
1523 Transparent alias is just alternative name of a given symbol used within
1524 one compilation unit and is translated prior hitting the object file. It
1525 inherits the visibility of its target.
1526 Weakref is a different animal (and noweak definition is weak).
1528 If we ever get into supporting targets with different semantics, a target
1529 hook will be needed here. */
1533 transparent_p
= transparent_alias
;
1535 *availability
= get_availability (ref
);
1537 *availability
= AVAIL_NOT_AVAILABLE
;
1540 symtab_node
*node
= this;
1543 if (node
->alias
&& node
->analyzed
)
1544 node
= node
->get_alias_target ();
1547 if (!availability
|| (!transparent_p
&& node
->analyzed
))
1549 else if (node
->analyzed
&& !node
->transparent_alias
)
1550 *availability
= node
->get_availability (ref
);
1552 *availability
= AVAIL_NOT_AVAILABLE
;
1555 if (node
&& availability
&& transparent_p
1556 && node
->transparent_alias
)
1558 *availability
= node
->get_availability (ref
);
1559 transparent_p
= false;
1563 *availability
= AVAIL_NOT_AVAILABLE
;
1567 /* C++ FE sometimes change linkage flags after producing same body aliases.
1569 FIXME: C++ produce implicit aliases for virtual functions and vtables that
1570 are obviously equivalent. The way it is doing so is however somewhat
1571 kludgy and interferes with the visibility code. As a result we need to
1572 copy the visibility from the target to get things right. */
1575 symtab_node::fixup_same_cpp_alias_visibility (symtab_node
*target
)
1577 if (is_a
<cgraph_node
*> (this))
1579 DECL_DECLARED_INLINE_P (decl
)
1580 = DECL_DECLARED_INLINE_P (target
->decl
);
1581 DECL_DISREGARD_INLINE_LIMITS (decl
)
1582 = DECL_DISREGARD_INLINE_LIMITS (target
->decl
);
1584 /* FIXME: It is not really clear why those flags should not be copied for
1588 DECL_WEAK (decl
) = DECL_WEAK (target
->decl
);
1589 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1590 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (target
->decl
);
1592 if (TREE_PUBLIC (decl
))
1596 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (target
->decl
);
1597 DECL_COMDAT (decl
) = DECL_COMDAT (target
->decl
);
1598 group
= target
->get_comdat_group ();
1599 set_comdat_group (group
);
1600 if (group
&& !same_comdat_group
)
1601 add_to_same_comdat_group (target
);
1603 externally_visible
= target
->externally_visible
;
1606 /* Set section, do not recurse into aliases.
1607 When one wants to change section of a symbol and its aliases,
1611 symtab_node::set_section_for_node (const char *section
)
1613 const char *current
= get_section ();
1614 section_hash_entry
**slot
;
1616 if (current
== section
1617 || (current
&& section
1618 && !strcmp (current
, section
)))
1623 x_section
->ref_count
--;
1624 if (!x_section
->ref_count
)
1626 hashval_t hash
= htab_hash_string (x_section
->name
);
1627 slot
= symtab
->section_hash
->find_slot_with_hash (x_section
->name
,
1629 ggc_free (x_section
);
1630 symtab
->section_hash
->clear_slot (slot
);
1636 implicit_section
= false;
1639 if (!symtab
->section_hash
)
1640 symtab
->section_hash
= hash_table
<section_name_hasher
>::create_ggc (10);
1641 slot
= symtab
->section_hash
->find_slot_with_hash (section
,
1642 htab_hash_string (section
),
1645 x_section
= (section_hash_entry
*)*slot
;
1648 int len
= strlen (section
);
1649 *slot
= x_section
= ggc_cleared_alloc
<section_hash_entry
> ();
1650 x_section
->name
= ggc_vec_alloc
<char> (len
+ 1);
1651 memcpy (x_section
->name
, section
, len
+ 1);
1653 x_section
->ref_count
++;
1656 /* Worker for set_section. */
1659 symtab_node::set_section (symtab_node
*n
, void *s
)
1661 n
->set_section_for_node ((char *)s
);
1665 /* Set section of symbol and its aliases. */
1668 symtab_node::set_section (const char *section
)
1670 gcc_assert (!this->alias
|| !this->analyzed
);
1671 call_for_symbol_and_aliases
1672 (symtab_node::set_section
, const_cast<char *>(section
), true);
1675 /* Return the initialization priority. */
1678 symtab_node::get_init_priority ()
1680 if (!this->in_init_priority_hash
)
1681 return DEFAULT_INIT_PRIORITY
;
1683 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1684 return h
? h
->init
: DEFAULT_INIT_PRIORITY
;
1687 /* Return the finalization priority. */
1690 cgraph_node::get_fini_priority ()
1692 if (!this->in_init_priority_hash
)
1693 return DEFAULT_INIT_PRIORITY
;
1694 symbol_priority_map
*h
= symtab
->init_priority_hash
->get (this);
1695 return h
? h
->fini
: DEFAULT_INIT_PRIORITY
;
1698 /* Return the initialization and finalization priority information for
1699 DECL. If there is no previous priority information, a freshly
1700 allocated structure is returned. */
1702 symbol_priority_map
*
1703 symtab_node::priority_info (void)
1705 if (!symtab
->init_priority_hash
)
1706 symtab
->init_priority_hash
= hash_map
<symtab_node
*, symbol_priority_map
>::create_ggc (13);
1709 symbol_priority_map
*h
1710 = &symtab
->init_priority_hash
->get_or_insert (this, &existed
);
1713 h
->init
= DEFAULT_INIT_PRIORITY
;
1714 h
->fini
= DEFAULT_INIT_PRIORITY
;
1715 in_init_priority_hash
= true;
1721 /* Set initialization priority to PRIORITY. */
1724 symtab_node::set_init_priority (priority_type priority
)
1726 symbol_priority_map
*h
;
1728 if (is_a
<cgraph_node
*> (this))
1729 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl
));
1731 if (priority
== DEFAULT_INIT_PRIORITY
)
1733 gcc_assert (get_init_priority() == priority
);
1736 h
= priority_info ();
1740 /* Set finalization priority to PRIORITY. */
1743 cgraph_node::set_fini_priority (priority_type priority
)
1745 symbol_priority_map
*h
;
1747 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl
));
1749 if (priority
== DEFAULT_INIT_PRIORITY
)
1751 gcc_assert (get_fini_priority() == priority
);
1754 h
= priority_info ();
1758 /* Worker for symtab_resolve_alias. */
1761 symtab_node::set_implicit_section (symtab_node
*n
,
1762 void *data ATTRIBUTE_UNUSED
)
1764 n
->implicit_section
= true;
1768 /* Add reference recording that symtab node is alias of TARGET.
1769 The function can fail in the case of aliasing cycles; in this case
1770 it returns false. */
1773 symtab_node::resolve_alias (symtab_node
*target
, bool transparent
)
1777 gcc_assert (!analyzed
&& !vec_safe_length (ref_list
.references
));
1779 /* Never let cycles to creep into the symbol table alias references;
1780 those will make alias walkers to be infinite. */
1781 for (n
= target
; n
&& n
->alias
;
1782 n
= n
->analyzed
? n
->get_alias_target () : NULL
)
1785 if (is_a
<cgraph_node
*> (this))
1786 error ("function %q+D part of alias cycle", decl
);
1787 else if (is_a
<varpool_node
*> (this))
1788 error ("variable %q+D part of alias cycle", decl
);
1795 /* "analyze" the node - i.e. mark the reference. */
1799 transparent
|= transparent_alias
;
1800 transparent_alias
= transparent
;
1802 while (target
->transparent_alias
&& target
->analyzed
)
1803 target
= target
->get_alias_target ();
1804 create_reference (target
, IPA_REF_ALIAS
, NULL
);
1806 /* Add alias into the comdat group of its target unless it is already there. */
1807 if (same_comdat_group
)
1808 remove_from_same_comdat_group ();
1809 set_comdat_group (NULL
);
1810 if (target
->get_comdat_group ())
1811 add_to_same_comdat_group (target
);
1813 if ((get_section () != target
->get_section ()
1814 || target
->get_comdat_group ()) && get_section () && !implicit_section
)
1816 error ("section of alias %q+D must match section of its target", decl
);
1818 call_for_symbol_and_aliases (symtab_node::set_section
,
1819 const_cast<char *>(target
->get_section ()), true);
1820 if (target
->implicit_section
)
1821 call_for_symbol_and_aliases (set_implicit_section
, NULL
, true);
1823 /* Alias targets become redundant after alias is resolved into an reference.
1824 We do not want to keep it around or we would have to mind updating them
1825 when renaming symbols. */
1826 alias_target
= NULL
;
1828 if (!transparent
&& cpp_implicit_alias
&& symtab
->state
>= CONSTRUCTION
)
1829 fixup_same_cpp_alias_visibility (target
);
1831 /* If alias has address taken, so does the target. */
1833 target
->ultimate_alias_target ()->address_taken
= true;
1835 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
1836 If alias is transparent, also all transparent aliases of THIS are now
1838 Also merge same comdat group lists. */
1840 for (unsigned i
= 0; iterate_direct_aliases (i
, ref
);)
1842 struct symtab_node
*alias_alias
= ref
->referring
;
1843 if (alias_alias
->get_comdat_group ())
1845 alias_alias
->remove_from_same_comdat_group ();
1846 alias_alias
->set_comdat_group (NULL
);
1847 if (target
->get_comdat_group ())
1848 alias_alias
->add_to_same_comdat_group (target
);
1850 if ((!alias_alias
->transparent_alias
1851 && !alias_alias
->symver
)
1854 alias_alias
->remove_all_references ();
1855 alias_alias
->create_reference (target
, IPA_REF_ALIAS
, NULL
);
1862 /* Worker searching noninterposable alias. */
1865 symtab_node::noninterposable_alias (symtab_node
*node
, void *data
)
1867 if (!node
->transparent_alias
&& decl_binds_to_current_def_p (node
->decl
))
1869 symtab_node
*fn
= node
->ultimate_alias_target ();
1871 /* Ensure that the alias is well formed this may not be the case
1872 of user defined aliases and currently it is not always the case
1873 of C++ same body aliases (that is a bug). */
1874 if (TREE_TYPE (node
->decl
) != TREE_TYPE (fn
->decl
)
1875 || DECL_CONTEXT (node
->decl
) != DECL_CONTEXT (fn
->decl
)
1876 || (TREE_CODE (node
->decl
) == FUNCTION_DECL
1877 && flags_from_decl_or_type (node
->decl
)
1878 != flags_from_decl_or_type (fn
->decl
))
1879 || DECL_ATTRIBUTES (node
->decl
) != DECL_ATTRIBUTES (fn
->decl
))
1881 *(symtab_node
**)data
= node
;
1887 /* If node cannot be overwriten by static or dynamic linker to point to
1888 different definition, return NODE. Otherwise look for alias with such
1889 property and if none exists, introduce new one. */
1892 symtab_node::noninterposable_alias (void)
1895 symtab_node
*new_node
= NULL
;
1897 /* First try to look up existing alias or base object
1898 (if that is already non-overwritable). */
1899 symtab_node
*node
= ultimate_alias_target ();
1900 gcc_assert (!node
->alias
&& !node
->weakref
);
1901 node
->call_for_symbol_and_aliases (symtab_node::noninterposable_alias
,
1902 (void *)&new_node
, true);
1906 /* If aliases aren't supported by the assembler, fail. */
1907 if (!TARGET_SUPPORTS_ALIASES
)
1910 /* Otherwise create a new one. */
1911 new_decl
= copy_node (node
->decl
);
1912 DECL_DLLIMPORT_P (new_decl
) = 0;
1913 tree name
= clone_function_name (node
->decl
, "localalias");
1916 unsigned long num
= 0;
1917 /* In the rare case we already have a localalias, but the above
1918 node->call_for_symbol_and_aliases call didn't find any suitable,
1919 iterate until we find one not used yet. */
1920 while (symtab_node::get_for_asmname (name
))
1921 name
= clone_function_name (node
->decl
, "localalias", num
++);
1923 DECL_NAME (new_decl
) = name
;
1924 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1925 DECL_STRUCT_FUNCTION (new_decl
) = NULL
;
1926 DECL_INITIAL (new_decl
) = NULL
;
1927 SET_DECL_ASSEMBLER_NAME (new_decl
, DECL_NAME (new_decl
));
1928 SET_DECL_RTL (new_decl
, NULL
);
1930 /* Update the properties. */
1931 DECL_EXTERNAL (new_decl
) = 0;
1932 TREE_PUBLIC (new_decl
) = 0;
1933 DECL_COMDAT (new_decl
) = 0;
1934 DECL_WEAK (new_decl
) = 0;
1936 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
1937 DECL_VIRTUAL_P (new_decl
) = DECL_VIRTUAL_P (node
->decl
);
1938 if (TREE_CODE (new_decl
) == FUNCTION_DECL
)
1940 DECL_STATIC_CONSTRUCTOR (new_decl
) = 0;
1941 DECL_STATIC_DESTRUCTOR (new_decl
) = 0;
1942 new_node
= cgraph_node::create_alias (new_decl
, node
->decl
);
1944 cgraph_node
*new_cnode
= dyn_cast
<cgraph_node
*> (new_node
),
1945 *cnode
= dyn_cast
<cgraph_node
*> (node
);
1947 new_cnode
->unit_id
= cnode
->unit_id
;
1948 new_cnode
->merged_comdat
= cnode
->merged_comdat
;
1949 new_cnode
->merged_extern_inline
= cnode
->merged_extern_inline
;
1953 TREE_READONLY (new_decl
) = TREE_READONLY (node
->decl
);
1954 DECL_INITIAL (new_decl
) = error_mark_node
;
1955 new_node
= varpool_node::create_alias (new_decl
, node
->decl
);
1957 new_node
->resolve_alias (node
);
1958 gcc_assert (decl_binds_to_current_def_p (new_decl
)
1959 && targetm
.binds_local_p (new_decl
));
1963 /* Return true if symtab node and TARGET represents
1964 semantically equivalent symbols. */
1967 symtab_node::semantically_equivalent_p (symtab_node
*target
)
1969 enum availability avail
;
1973 /* Equivalent functions are equivalent. */
1974 if (decl
== target
->decl
)
1977 /* If symbol is not overwritable by different implementation,
1978 walk to the base object it defines. */
1979 ba
= ultimate_alias_target (&avail
);
1980 if (avail
>= AVAIL_AVAILABLE
)
1987 bb
= target
->ultimate_alias_target (&avail
);
1988 if (avail
>= AVAIL_AVAILABLE
)
1998 /* Classify symbol symtab node for partitioning. */
2000 enum symbol_partitioning_class
2001 symtab_node::get_partitioning_class (void)
2003 /* Inline clones are always duplicated.
2004 This include external declarations. */
2005 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2007 if (DECL_ABSTRACT_P (decl
))
2008 return SYMBOL_EXTERNAL
;
2010 if (cnode
&& (cnode
->inlined_to
|| cnode
->declare_variant_alt
))
2011 return SYMBOL_DUPLICATE
;
2013 /* Transparent aliases are always duplicated. */
2014 if (transparent_alias
)
2015 return definition
? SYMBOL_DUPLICATE
: SYMBOL_EXTERNAL
;
2017 /* External declarations are external. */
2018 if (DECL_EXTERNAL (decl
))
2019 return SYMBOL_EXTERNAL
;
2021 /* Even static aliases of external functions as external. Those can happen
2022 when COMDAT got resolved to non-IL implementation. */
2023 if (alias
&& DECL_EXTERNAL (ultimate_alias_target ()->decl
))
2024 return SYMBOL_EXTERNAL
;
2026 if (varpool_node
*vnode
= dyn_cast
<varpool_node
*> (this))
2028 if (alias
&& definition
&& !ultimate_alias_target ()->definition
)
2029 return SYMBOL_EXTERNAL
;
2030 /* Constant pool references use local symbol names that cannot
2031 be promoted global. We should never put into a constant pool
2032 objects that cannot be duplicated across partitions. */
2033 if (DECL_IN_CONSTANT_POOL (decl
))
2034 return SYMBOL_DUPLICATE
;
2035 if (DECL_HARD_REGISTER (decl
))
2036 return SYMBOL_DUPLICATE
;
2037 gcc_checking_assert (vnode
->definition
);
2039 /* Functions that are cloned may stay in callgraph even if they are unused.
2040 Handle them as external; compute_ltrans_boundary take care to make
2041 proper things to happen (i.e. to make them appear in the boundary but
2042 with body streamed, so clone can me materialized). */
2043 else if (!dyn_cast
<cgraph_node
*> (this)->function_symbol ()->definition
)
2044 return SYMBOL_EXTERNAL
;
2046 /* Linker discardable symbols are duplicated to every use unless they are
2048 if (DECL_ONE_ONLY (decl
)
2051 && !used_from_object_file_p ())
2052 return SYMBOL_DUPLICATE
;
2054 return SYMBOL_PARTITION
;
2057 /* Return true when symbol is known to be non-zero. */
2060 symtab_node::nonzero_address ()
2062 /* Weakrefs may be NULL when their target is not defined. */
2063 if (alias
&& weakref
)
2067 symtab_node
*target
= ultimate_alias_target ();
2069 if (target
->alias
&& target
->weakref
)
2071 /* We cannot recurse to target::nonzero. It is possible that the
2072 target is used only via the alias.
2073 We may walk references and look for strong use, but we do not know
2074 if this strong use will survive to final binary, so be
2076 ??? Maybe we could do the lookup during late optimization that
2077 could be useful to eliminate the NULL pointer checks in LTO
2079 if (target
->definition
&& !DECL_EXTERNAL (target
->decl
))
2081 if (target
->resolution
!= LDPR_UNKNOWN
2082 && target
->resolution
!= LDPR_UNDEF
2083 && !target
->can_be_discarded_p ()
2084 && flag_delete_null_pointer_checks
)
2092 /* With !flag_delete_null_pointer_checks we assume that symbols may
2093 bind to NULL. This is on by default on embedded targets only.
2095 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
2096 linking fails. Important case of WEAK we want to do well are comdats,
2097 which also must be defined somewhere.
2099 When parsing, beware the cases when WEAK attribute is added later. */
2100 if ((!DECL_WEAK (decl
) || DECL_COMDAT (decl
))
2101 && flag_delete_null_pointer_checks
)
2103 refuse_visibility_changes
= true;
2107 /* If target is defined and not extern, we know it will be
2108 output and thus it will bind to non-NULL.
2109 Play safe for flag_delete_null_pointer_checks where weak definition may
2110 be re-defined by NULL. */
2111 if (definition
&& !DECL_EXTERNAL (decl
)
2112 && (flag_delete_null_pointer_checks
|| !DECL_WEAK (decl
)))
2114 if (!DECL_WEAK (decl
))
2115 refuse_visibility_changes
= true;
2119 /* As the last resort, check the resolution info. */
2120 if (resolution
!= LDPR_UNKNOWN
2121 && resolution
!= LDPR_UNDEF
2122 && !can_be_discarded_p ()
2123 && flag_delete_null_pointer_checks
)
2128 /* Return 0 if symbol is known to have different address than S2,
2129 Return 1 if symbol is known to have same address as S2,
2130 return -1 otherwise.
2132 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
2133 and S2 is going to be accessed. This eliminates the situations when
2134 either THIS or S2 is NULL and is useful for comparing bases when deciding
2135 about memory aliasing. */
2137 symtab_node::equal_address_to (symtab_node
*s2
, bool memory_accessed
)
2139 enum availability avail1
, avail2
;
2141 /* A Shortcut: equivalent symbols are always equivalent. */
2145 /* Unwind transparent aliases first; those are always equal to their
2147 if (this->transparent_alias
&& this->analyzed
)
2148 return this->get_alias_target ()->equal_address_to (s2
);
2149 while (s2
->transparent_alias
&& s2
->analyzed
)
2150 s2
= s2
->get_alias_target();
2155 /* For non-interposable aliases, lookup and compare their actual definitions.
2156 Also check if the symbol needs to bind to given definition. */
2157 symtab_node
*rs1
= ultimate_alias_target (&avail1
);
2158 symtab_node
*rs2
= s2
->ultimate_alias_target (&avail2
);
2159 bool binds_local1
= rs1
->analyzed
&& decl_binds_to_current_def_p (this->decl
);
2160 bool binds_local2
= rs2
->analyzed
&& decl_binds_to_current_def_p (s2
->decl
);
2161 bool really_binds_local1
= binds_local1
;
2162 bool really_binds_local2
= binds_local2
;
2164 /* Addresses of vtables and virtual functions cannot be used by user
2165 code and are used only within speculation. In this case we may make
2166 symbol equivalent to its alias even if interposition may break this
2167 rule. Doing so will allow us to turn speculative inlining into
2168 non-speculative more aggressively. */
2169 if (DECL_VIRTUAL_P (this->decl
) && avail1
>= AVAIL_AVAILABLE
)
2170 binds_local1
= true;
2171 if (DECL_VIRTUAL_P (s2
->decl
) && avail2
>= AVAIL_AVAILABLE
)
2172 binds_local2
= true;
2174 /* If both definitions are available we know that even if they are bound
2175 to other unit they must be defined same way and therefore we can use
2176 equivalence test. */
2177 if (rs1
!= rs2
&& avail1
>= AVAIL_AVAILABLE
&& avail2
>= AVAIL_AVAILABLE
)
2178 binds_local1
= binds_local2
= true;
2180 if (binds_local1
&& binds_local2
&& rs1
== rs2
)
2182 /* We made use of the fact that alias is not weak. */
2184 refuse_visibility_changes
= true;
2186 s2
->refuse_visibility_changes
= true;
2190 /* If both symbols may resolve to NULL, we cannot really prove them
2192 if (!memory_accessed
&& !nonzero_address () && !s2
->nonzero_address ())
2195 /* Except for NULL, functions and variables never overlap. */
2196 if (TREE_CODE (decl
) != TREE_CODE (s2
->decl
))
2199 /* If one of the symbols is unresolved alias, punt. */
2200 if (rs1
->alias
|| rs2
->alias
)
2203 /* If we have a non-interposale definition of at least one of the symbols
2204 and the other symbol is different, we know other unit cannot interpose
2205 it to the first symbol; all aliases of the definition needs to be
2206 present in the current unit. */
2207 if (((really_binds_local1
|| really_binds_local2
)
2208 /* If we have both definitions and they are different, we know they
2209 will be different even in units they binds to. */
2210 || (binds_local1
&& binds_local2
))
2213 /* We make use of the fact that one symbol is not alias of the other
2214 and that the definition is non-interposable. */
2215 refuse_visibility_changes
= true;
2216 s2
->refuse_visibility_changes
= true;
2217 rs1
->refuse_visibility_changes
= true;
2218 rs2
->refuse_visibility_changes
= true;
2222 /* TODO: Alias oracle basically assume that addresses of global variables
2223 are different unless they are declared as alias of one to another while
2224 the code folding comparisons doesn't.
2225 We probably should be consistent and use this fact here, too, but for
2226 the moment return false only when we are called from the alias oracle. */
2228 return memory_accessed
&& rs1
!= rs2
? 0 : -1;
2231 /* Worker for call_for_symbol_and_aliases. */
2234 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback
) (symtab_node
*,
2237 bool include_overwritable
)
2240 FOR_EACH_ALIAS (this, ref
)
2242 symtab_node
*alias
= ref
->referring
;
2243 if (include_overwritable
2244 || alias
->get_availability () > AVAIL_INTERPOSABLE
)
2245 if (alias
->call_for_symbol_and_aliases (callback
, data
,
2246 include_overwritable
))
2252 /* Return true if address of N is possibly compared. */
2255 address_matters_1 (symtab_node
*n
, void *)
2257 struct ipa_ref
*ref
;
2259 if (!n
->address_can_be_compared_p ())
2261 if (n
->externally_visible
|| n
->force_output
)
2264 for (unsigned int i
= 0; n
->iterate_referring (i
, ref
); i
++)
2265 if (ref
->address_matters_p ())
2270 /* Return true if symbol's address may possibly be compared to other
2271 symbol's address. */
2274 symtab_node::address_matters_p ()
2276 gcc_assert (!alias
);
2277 return call_for_symbol_and_aliases (address_matters_1
, NULL
, true);
2280 /* Return true if symbol's alignment may be increased. */
2283 symtab_node::can_increase_alignment_p (void)
2285 symtab_node
*target
= ultimate_alias_target ();
2287 /* For now support only variables. */
2291 /* With -fno-toplevel-reorder we may have already output the constant. */
2292 if (TREE_ASM_WRITTEN (target
->decl
))
2295 /* If target is already placed in an anchor, we cannot touch its
2297 if (DECL_RTL_SET_P (target
->decl
)
2298 && MEM_P (DECL_RTL (target
->decl
))
2299 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target
->decl
), 0)))
2302 /* Constant pool entries may be shared. */
2303 if (DECL_IN_CONSTANT_POOL (target
->decl
))
2306 /* We cannot change alignment of symbols that may bind to symbols
2307 in other translation unit that may contain a definition with lower
2309 if (!decl_binds_to_current_def_p (decl
))
2312 /* When compiling partition, be sure the symbol is not output by other
2315 && (target
->in_other_partition
2316 || target
->get_partitioning_class () == SYMBOL_DUPLICATE
))
2319 /* Do not override the alignment as specified by the ABI when the used
2320 attribute is set. */
2321 if (DECL_PRESERVE_P (decl
) || DECL_PRESERVE_P (target
->decl
))
2324 /* Do not override explicit alignment set by the user when an explicit
2325 section name is also used. This is a common idiom used by many
2326 software projects. */
2327 if (DECL_SECTION_NAME (target
->decl
) != NULL
&& !target
->implicit_section
)
2333 /* Worker for symtab_node::increase_alignment. */
2336 increase_alignment_1 (symtab_node
*n
, void *v
)
2338 unsigned int align
= (size_t)v
;
2339 if (DECL_ALIGN (n
->decl
) < align
2340 && n
->can_increase_alignment_p ())
2342 SET_DECL_ALIGN (n
->decl
, align
);
2343 DECL_USER_ALIGN (n
->decl
) = 1;
2348 /* Increase alignment of THIS to ALIGN. */
2351 symtab_node::increase_alignment (unsigned int align
)
2353 gcc_assert (can_increase_alignment_p () && align
<= MAX_OFILE_ALIGNMENT
);
2354 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1
,
2355 (void *)(size_t) align
,
2357 gcc_assert (DECL_ALIGN (decl
) >= align
);
2360 /* Helper for symtab_node::definition_alignment. */
2363 get_alignment_1 (symtab_node
*n
, void *v
)
2365 *((unsigned int *)v
) = MAX (*((unsigned int *)v
), DECL_ALIGN (n
->decl
));
2369 /* Return desired alignment of the definition. This is NOT alignment useful
2370 to access THIS, because THIS may be interposable and DECL_ALIGN should
2371 be used instead. It however must be guaranteed when output definition
2375 symtab_node::definition_alignment ()
2377 unsigned int align
= 0;
2378 gcc_assert (!alias
);
2379 call_for_symbol_and_aliases (get_alignment_1
, &align
, true);
2383 /* Return symbol used to separate symbol name from suffix. */
2386 symbol_table::symbol_suffix_separator ()
2388 #ifndef NO_DOT_IN_LABEL
2390 #elif !defined NO_DOLLAR_IN_LABEL
2397 /* Return true when references to this symbol from REF must bind to current
2398 definition in final executable. */
2401 symtab_node::binds_to_current_def_p (symtab_node
*ref
)
2403 if (!definition
&& !in_other_partition
)
2405 if (transparent_alias
)
2407 && get_alias_target()->binds_to_current_def_p (ref
);
2408 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2409 if (cnode
&& cnode
->ifunc_resolver
)
2411 if (decl_binds_to_current_def_p (decl
))
2414 /* Inline clones always binds locally. */
2415 if (cnode
&& cnode
->inlined_to
)
2418 if (DECL_EXTERNAL (decl
))
2421 gcc_assert (externally_visible
);
2425 cgraph_node
*cref
= dyn_cast
<cgraph_node
*> (ref
);
2427 ref
= cref
->inlined_to
;
2430 /* If this is a reference from symbol itself and there are no aliases, we
2431 may be sure that the symbol was not interposed by something else because
2432 the symbol itself would be unreachable otherwise. This is important
2433 to optimize recursive functions well.
2435 This assumption may be broken by inlining: if symbol is interposable
2436 but the body is available (i.e. declared inline), inliner may make
2437 the body reachable even with interposition. */
2438 if (this == ref
&& !has_aliases_p ()
2440 || symtab
->state
>= IPA_SSA_AFTER_INLINING
2441 || get_availability () >= AVAIL_INTERPOSABLE
))
2445 /* References within one comdat group are always bound in a group. */
2447 && symtab
->state
>= IPA_SSA_AFTER_INLINING
2448 && get_comdat_group ()
2449 && get_comdat_group () == ref
->get_comdat_group ())
2455 /* Return true if symbol should be output to the symbol table. */
2458 symtab_node::output_to_lto_symbol_table_p (void)
2460 /* Only externally visible symbols matter. */
2461 if (!TREE_PUBLIC (decl
))
2463 if (!real_symbol_p ())
2465 /* FIXME: variables probably should not be considered as real symbols at
2467 if (VAR_P (decl
) && DECL_HARD_REGISTER (decl
))
2469 if (TREE_CODE (decl
) == FUNCTION_DECL
&& !definition
2470 && fndecl_built_in_p (decl
))
2472 /* Builtins like those for most math functions have actual implementations
2473 in libraries so make sure to output references into the symbol table to
2474 make those libraries referenced. Note this is incomplete handling for
2475 now and only covers math functions. */
2476 if (builtin_with_linkage_p (decl
))
2482 /* We have real symbol that should be in symbol table. However try to trim
2483 down the references to libraries bit more because linker will otherwise
2484 bring unnecessary object files into the final link.
2485 FIXME: The following checks can easily be confused i.e. by self recursive
2486 function or self-referring variable. */
2488 /* We keep external functions in symtab for sake of inlining
2489 and devirtualization. We do not want to see them in symbol table as
2490 references unless they are really used. */
2491 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (this);
2492 if (cnode
&& (!definition
|| DECL_EXTERNAL (decl
))
2496 /* Ignore all references from external vars initializers - they are not really
2497 part of the compilation unit until they are used by folding. Some symbols,
2498 like references to external construction vtables cannot be referred to at
2499 all. We decide this at can_refer_decl_in_current_unit_p. */
2500 if (!definition
|| DECL_EXTERNAL (decl
))
2503 struct ipa_ref
*ref
;
2504 for (i
= 0; iterate_referring (i
, ref
); i
++)
2506 if (ref
->use
== IPA_REF_ALIAS
)
2508 if (is_a
<cgraph_node
*> (ref
->referring
))
2510 if (!DECL_EXTERNAL (ref
->referring
->decl
))