2 Copyright 2009 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
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"
24 #include "diagnostic-core.h"
29 #include "lambda.h" /* gcd */
31 #include "plugin-api.h"
32 #include "lto-streamer.h"
34 /* Vector to keep track of external variables we've seen so far. */
35 VEC(tree,gc) *lto_global_var_decls;
37 /* Symbol table entry. */
39 struct GTY(()) lto_symtab_entry_def
41 /* The symbol table entry key, an IDENTIFIER. */
43 /* The symbol table entry, a DECL. */
45 /* The cgraph node if decl is a function decl. Filled in during the
47 struct cgraph_node *node;
48 /* The varpool node if decl is a variable decl. Filled in during the
50 struct varpool_node *vnode;
51 /* LTO file-data and symbol resolution for this decl. */
52 struct lto_file_decl_data * GTY((skip (""))) file_data;
53 enum ld_plugin_symbol_resolution resolution;
54 /* Pointer to the next entry with the same key. Before decl merging
55 this links all symbols from the different TUs. After decl merging
56 this links merged but incompatible decls, thus all prevailing ones
58 struct lto_symtab_entry_def *next;
60 typedef struct lto_symtab_entry_def *lto_symtab_entry_t;
62 /* A poor man's symbol table. This hashes identifier to prevailing DECL
65 static GTY ((if_marked ("lto_symtab_entry_marked_p"),
66 param_is (struct lto_symtab_entry_def)))
67 htab_t lto_symtab_identifiers;
69 /* Free symtab hashtable. */
72 lto_symtab_free (void)
74 htab_delete (lto_symtab_identifiers);
75 lto_symtab_identifiers = NULL;
78 /* Return the hash value of an lto_symtab_entry_t object pointed to by P. */
81 lto_symtab_entry_hash (const void *p)
83 const struct lto_symtab_entry_def *base =
84 (const struct lto_symtab_entry_def *) p;
85 return IDENTIFIER_HASH_VALUE (base->id);
88 /* Return non-zero if P1 and P2 points to lto_symtab_entry_def structs
89 corresponding to the same symbol. */
92 lto_symtab_entry_eq (const void *p1, const void *p2)
94 const struct lto_symtab_entry_def *base1 =
95 (const struct lto_symtab_entry_def *) p1;
96 const struct lto_symtab_entry_def *base2 =
97 (const struct lto_symtab_entry_def *) p2;
98 return (base1->id == base2->id);
101 /* Returns non-zero if P points to an lto_symtab_entry_def struct that needs
102 to be marked for GC. */
105 lto_symtab_entry_marked_p (const void *p)
107 const struct lto_symtab_entry_def *base =
108 (const struct lto_symtab_entry_def *) p;
110 /* Keep this only if the common IDENTIFIER_NODE of the symtab chain
111 is marked which it will be if at least one of the DECLs in the
113 return ggc_marked_p (base->id);
116 /* Lazily initialize resolution hash tables. */
119 lto_symtab_maybe_init_hash_table (void)
121 if (lto_symtab_identifiers)
124 lto_symtab_identifiers =
125 htab_create_ggc (1021, lto_symtab_entry_hash,
126 lto_symtab_entry_eq, NULL);
129 /* Registers DECL with the LTO symbol table as having resolution RESOLUTION
130 and read from FILE_DATA. */
133 lto_symtab_register_decl (tree decl,
134 ld_plugin_symbol_resolution_t resolution,
135 struct lto_file_decl_data *file_data)
137 lto_symtab_entry_t new_entry;
140 /* Check that declarations reaching this function do not have
141 properties inconsistent with having external linkage. If any of
142 these asertions fail, then the object file reader has failed to
143 detect these cases and issue appropriate error messages. */
145 && TREE_PUBLIC (decl)
146 && (TREE_CODE (decl) == VAR_DECL
147 || TREE_CODE (decl) == FUNCTION_DECL)
148 && DECL_ASSEMBLER_NAME_SET_P (decl));
149 if (TREE_CODE (decl) == VAR_DECL
150 && DECL_INITIAL (decl))
151 gcc_assert (!DECL_EXTERNAL (decl)
152 || (TREE_STATIC (decl) && TREE_READONLY (decl)));
153 if (TREE_CODE (decl) == FUNCTION_DECL)
154 gcc_assert (!DECL_ABSTRACT (decl));
156 new_entry = ggc_alloc_cleared_lto_symtab_entry_def ();
157 new_entry->id = DECL_ASSEMBLER_NAME (decl);
158 new_entry->decl = decl;
159 new_entry->resolution = resolution;
160 new_entry->file_data = file_data;
162 lto_symtab_maybe_init_hash_table ();
163 slot = htab_find_slot (lto_symtab_identifiers, new_entry, INSERT);
164 new_entry->next = (lto_symtab_entry_t) *slot;
168 /* Get the lto_symtab_entry_def struct associated with ID
171 static lto_symtab_entry_t
172 lto_symtab_get (tree id)
174 struct lto_symtab_entry_def temp;
177 lto_symtab_maybe_init_hash_table ();
179 slot = htab_find_slot (lto_symtab_identifiers, &temp, NO_INSERT);
180 return slot ? (lto_symtab_entry_t) *slot : NULL;
183 /* Get the linker resolution for DECL. */
185 enum ld_plugin_symbol_resolution
186 lto_symtab_get_resolution (tree decl)
188 lto_symtab_entry_t e;
190 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
192 e = lto_symtab_get (DECL_ASSEMBLER_NAME (decl));
193 while (e && e->decl != decl)
198 return e->resolution;
202 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
203 all edges and removing the old node. */
206 lto_cgraph_replace_node (struct cgraph_node *node,
207 struct cgraph_node *prevailing_node)
209 struct cgraph_edge *e, *next;
210 bool no_aliases_please = false;
212 if (cgraph_dump_file)
214 fprintf (cgraph_dump_file, "Replacing cgraph node %s/%i by %s/%i"
216 cgraph_node_name (node), node->uid,
217 cgraph_node_name (prevailing_node),
218 prevailing_node->uid,
219 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)));
222 if (prevailing_node->same_body_alias)
224 if (prevailing_node->thunk.thunk_p)
225 no_aliases_please = true;
226 prevailing_node = prevailing_node->same_body;
229 /* Merge node flags. */
231 cgraph_mark_needed_node (prevailing_node);
233 cgraph_mark_reachable_node (prevailing_node);
234 if (node->address_taken)
236 gcc_assert (!prevailing_node->global.inlined_to);
237 cgraph_mark_address_taken_node (prevailing_node);
240 /* Redirect all incoming edges. */
241 for (e = node->callers; e; e = next)
243 next = e->next_caller;
244 cgraph_redirect_edge_callee (e, prevailing_node);
246 /* Redirect incomming references. */
247 ipa_clone_refering (prevailing_node, NULL, &node->ref_list);
249 /* If we have aliases, redirect them to the prevailing node. */
250 if (!node->same_body_alias && node->same_body)
252 struct cgraph_node *alias, *last;
253 /* We prevail aliases/tunks by a thunk. This is doable but
254 would need thunk combination. Hopefully no ABI changes will
255 every be crazy enough. */
256 gcc_assert (!no_aliases_please);
258 for (alias = node->same_body; alias; alias = alias->next)
261 gcc_assert (alias->same_body_alias);
262 alias->same_body = prevailing_node;
263 alias->thunk.alias = prevailing_node->decl;
265 last->next = prevailing_node->same_body;
266 /* Node with aliases is prevailed by alias.
267 We could handle this, but combining thunks together will be tricky.
268 Hopefully this does not happen. */
269 if (prevailing_node->same_body)
270 prevailing_node->same_body->previous = last;
271 prevailing_node->same_body = node->same_body;
272 node->same_body = NULL;
275 /* Finally remove the replaced node. */
276 if (node->same_body_alias)
277 cgraph_remove_same_body_alias (node);
279 cgraph_remove_node (node);
282 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
283 all edges and removing the old node. */
286 lto_varpool_replace_node (struct varpool_node *vnode,
287 struct varpool_node *prevailing_node)
289 /* Merge node flags. */
292 gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
293 varpool_mark_needed_node (prevailing_node);
295 /* Relink aliases. */
296 if (vnode->extra_name && !vnode->alias)
298 struct varpool_node *alias, *last;
299 for (alias = vnode->extra_name;
300 alias; alias = alias->next)
303 alias->extra_name = prevailing_node;
306 if (prevailing_node->extra_name)
308 last->next = prevailing_node->extra_name;
309 prevailing_node->extra_name->prev = last;
311 prevailing_node->extra_name = vnode->extra_name;
312 vnode->extra_name = NULL;
314 gcc_assert (!vnode->finalized || prevailing_node->finalized);
315 gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
317 /* When replacing by an alias, the references goes to the original
319 if (prevailing_node->alias && prevailing_node->extra_name)
320 prevailing_node = prevailing_node->extra_name;
321 ipa_clone_refering (NULL, prevailing_node, &vnode->ref_list);
323 /* Be sure we can garbage collect the initializer. */
324 if (DECL_INITIAL (vnode->decl))
325 DECL_INITIAL (vnode->decl) = error_mark_node;
326 /* Finally remove the replaced node. */
327 varpool_remove_node (vnode);
330 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
331 Return false if the symbols are not fully compatible and a diagnostic
332 should be emitted. */
335 lto_symtab_merge (lto_symtab_entry_t prevailing, lto_symtab_entry_t entry)
337 tree prevailing_decl = prevailing->decl;
338 tree decl = entry->decl;
339 tree prevailing_type, type;
341 /* Merge decl state in both directions, we may still end up using
343 TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);
344 TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);
346 /* The linker may ask us to combine two incompatible symbols.
347 Detect this case and notify the caller of required diagnostics. */
349 if (TREE_CODE (decl) == FUNCTION_DECL)
351 if (!gimple_types_compatible_p (TREE_TYPE (prevailing_decl),
352 TREE_TYPE (decl), false))
353 /* If we don't have a merged type yet...sigh. The linker
354 wouldn't complain if the types were mismatched, so we
355 probably shouldn't either. Just use the type from
356 whichever decl appears to be associated with the
357 definition. If for some odd reason neither decl is, the
364 /* Now we exclusively deal with VAR_DECLs. */
366 /* Sharing a global symbol is a strong hint that two types are
367 compatible. We could use this information to complete
368 incomplete pointed-to types more aggressively here, ignoring
369 mismatches in both field and tag names. It's difficult though
370 to guarantee that this does not have side-effects on merging
371 more compatible types from other translation units though. */
373 /* We can tolerate differences in type qualification, the
374 qualification of the prevailing definition will prevail.
375 ??? In principle we might want to only warn for structurally
376 incompatible types here, but unless we have protective measures
377 for TBAA in place that would hide useful information. */
378 prevailing_type = TYPE_MAIN_VARIANT (TREE_TYPE (prevailing_decl));
379 type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
381 /* We have to register and fetch canonical types here as the global
382 fixup process didn't yet run. */
383 prevailing_type = gimple_register_type (prevailing_type);
384 type = gimple_register_type (type);
385 if (!gimple_types_compatible_p (prevailing_type, type, false))
387 if (COMPLETE_TYPE_P (type))
390 /* If type is incomplete then avoid warnings in the cases
391 that TBAA handles just fine. */
393 if (TREE_CODE (prevailing_type) != TREE_CODE (type))
396 if (TREE_CODE (prevailing_type) == ARRAY_TYPE)
398 tree tem1 = TREE_TYPE (prevailing_type);
399 tree tem2 = TREE_TYPE (type);
400 while (TREE_CODE (tem1) == ARRAY_TYPE
401 && TREE_CODE (tem2) == ARRAY_TYPE)
403 tem1 = TREE_TYPE (tem1);
404 tem2 = TREE_TYPE (tem2);
407 if (TREE_CODE (tem1) != TREE_CODE (tem2))
410 if (!gimple_types_compatible_p (gimple_register_type (tem1),
411 gimple_register_type (tem2), false))
415 /* Fallthru. Compatible enough. */
418 /* ??? We might want to emit a warning here if type qualification
419 differences were spotted. Do not do this unconditionally though. */
421 /* There is no point in comparing too many details of the decls here.
422 The type compatibility checks or the completing of types has properly
423 dealt with most issues. */
425 /* The following should all not invoke fatal errors as in non-LTO
426 mode the linker wouldn't complain either. Just emit warnings. */
428 /* Report a warning if user-specified alignments do not match. */
429 if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))
430 && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))
436 /* Return true if the symtab entry E can be replaced by another symtab
440 lto_symtab_resolve_replaceable_p (lto_symtab_entry_t e)
442 if (DECL_EXTERNAL (e->decl)
443 || DECL_COMDAT (e->decl)
444 || DECL_WEAK (e->decl))
447 if (TREE_CODE (e->decl) == VAR_DECL)
448 return (DECL_COMMON (e->decl)
449 || (!flag_no_common && !DECL_INITIAL (e->decl)));
454 /* Return true if the symtab entry E can be the prevailing one. */
457 lto_symtab_resolve_can_prevail_p (lto_symtab_entry_t e)
459 /* The C++ frontend ends up neither setting TREE_STATIC nor
460 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
461 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
462 if (DECL_EXTERNAL (e->decl))
465 /* For functions we need a non-discarded body. */
466 if (TREE_CODE (e->decl) == FUNCTION_DECL)
468 && (e->node->analyzed
469 || (e->node->same_body_alias && e->node->same_body->analyzed)));
471 /* A variable should have a size. */
472 else if (TREE_CODE (e->decl) == VAR_DECL)
476 if (e->vnode->finalized)
478 return e->vnode->alias && e->vnode->extra_name->finalized;
484 /* Resolve the symbol with the candidates in the chain *SLOT and store
485 their resolutions. */
488 lto_symtab_resolve_symbols (void **slot)
490 lto_symtab_entry_t e;
491 lto_symtab_entry_t prevailing = NULL;
493 /* Always set e->node so that edges are updated to reflect decl merging. */
494 for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
496 if (TREE_CODE (e->decl) == FUNCTION_DECL)
497 e->node = cgraph_get_node_or_alias (e->decl);
498 else if (TREE_CODE (e->decl) == VAR_DECL)
499 e->vnode = varpool_get_node (e->decl);
502 e = (lto_symtab_entry_t) *slot;
504 /* If the chain is already resolved there is nothing else to do. */
505 if (e->resolution != LDPR_UNKNOWN)
508 /* Find the single non-replaceable prevailing symbol and
509 diagnose ODR violations. */
510 for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
512 if (!lto_symtab_resolve_can_prevail_p (e))
514 e->resolution = LDPR_RESOLVED_IR;
518 /* Set a default resolution - the final prevailing one will get
520 e->resolution = LDPR_PREEMPTED_IR;
521 if (!lto_symtab_resolve_replaceable_p (e))
525 error_at (DECL_SOURCE_LOCATION (e->decl),
526 "%qD has already been defined", e->decl);
527 inform (DECL_SOURCE_LOCATION (prevailing->decl),
528 "previously defined here");
536 /* Do a second round choosing one from the replaceable prevailing decls. */
537 for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
539 if (e->resolution != LDPR_PREEMPTED_IR)
542 /* Choose the first function that can prevail as prevailing. */
543 if (TREE_CODE (e->decl) == FUNCTION_DECL)
549 /* From variables that can prevail choose the largest one. */
551 || tree_int_cst_lt (DECL_SIZE (prevailing->decl),
552 DECL_SIZE (e->decl)))
560 /* If current lto files represent the whole program,
561 it is correct to use LDPR_PREVALING_DEF_IRONLY.
562 If current lto files are part of whole program, internal
563 resolver doesn't know if it is LDPR_PREVAILING_DEF
564 or LDPR_PREVAILING_DEF_IRONLY. Use IRONLY conforms to
565 using -fwhole-program. Otherwise, it doesn't
566 matter using either LDPR_PREVAILING_DEF or
567 LDPR_PREVAILING_DEF_IRONLY
569 FIXME: above workaround due to gold plugin makes some
570 variables IRONLY, which are indeed PREVAILING_DEF in
571 resolution file. These variables still need manual
572 externally_visible attribute. */
573 prevailing->resolution = LDPR_PREVAILING_DEF_IRONLY;
576 /* Merge all decls in the symbol table chain to the prevailing decl and
577 issue diagnostics about type mismatches. */
580 lto_symtab_merge_decls_2 (void **slot)
582 lto_symtab_entry_t prevailing, e;
583 VEC(tree, heap) *mismatches = NULL;
586 bool diagnosed_p = false;
588 /* Nothing to do for a single entry. */
589 prevailing = (lto_symtab_entry_t) *slot;
590 if (!prevailing->next)
593 /* Try to merge each entry with the prevailing one. */
594 for (e = prevailing->next; e; e = e->next)
596 if (!lto_symtab_merge (prevailing, e))
597 VEC_safe_push (tree, heap, mismatches, e->decl);
599 if (VEC_empty (tree, mismatches))
602 /* Diagnose all mismatched re-declarations. */
603 for (i = 0; VEC_iterate (tree, mismatches, i, decl); ++i)
605 if (!gimple_types_compatible_p (TREE_TYPE (prevailing->decl),
606 TREE_TYPE (decl), false))
607 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
608 "type of %qD does not match original "
609 "declaration", decl);
611 else if ((DECL_USER_ALIGN (prevailing->decl) && DECL_USER_ALIGN (decl))
612 && DECL_ALIGN (prevailing->decl) < DECL_ALIGN (decl))
614 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl), 0,
615 "alignment of %qD is bigger than "
616 "original declaration", decl);
620 inform (DECL_SOURCE_LOCATION (prevailing->decl),
621 "previously declared here");
623 VEC_free (tree, heap, mismatches);
626 /* Helper to process the decl chain for the symbol table entry *SLOT. */
629 lto_symtab_merge_decls_1 (void **slot, void *data ATTRIBUTE_UNUSED)
631 lto_symtab_entry_t e, prevailing;
632 bool diagnosed_p = false;
634 /* Compute the symbol resolutions. This is a no-op when using the
636 lto_symtab_resolve_symbols (slot);
638 /* Find the prevailing decl. */
639 for (prevailing = (lto_symtab_entry_t) *slot;
641 && prevailing->resolution != LDPR_PREVAILING_DEF_IRONLY
642 && prevailing->resolution != LDPR_PREVAILING_DEF;
643 prevailing = prevailing->next)
646 /* Assert it's the only one. */
648 for (e = prevailing->next; e; e = e->next)
650 if (e->resolution == LDPR_PREVAILING_DEF_IRONLY
651 || e->resolution == LDPR_PREVAILING_DEF)
652 fatal_error ("multiple prevailing defs for %qE",
653 DECL_NAME (prevailing->decl));
656 /* If there's not a prevailing symbol yet it's an external reference.
657 Happens a lot during ltrans. Choose the first symbol with a
658 cgraph or a varpool node. */
661 prevailing = (lto_symtab_entry_t) *slot;
662 /* For functions choose one with a cgraph node. */
663 if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
664 while (!prevailing->node
666 prevailing = prevailing->next;
667 /* For variables chose with a priority variant with vnode
668 attached (i.e. from unit where external declaration of
669 variable is actually used).
670 When there are multiple variants, chose one with size.
671 This is needed for C++ typeinfos, for example in
672 lto/20081204-1 there are typeifos in both units, just
673 one of them do have size. */
674 if (TREE_CODE (prevailing->decl) == VAR_DECL)
676 for (e = prevailing->next; e; e = e->next)
677 if ((!prevailing->vnode && e->vnode)
678 || ((prevailing->vnode != NULL) == (e->vnode != NULL)
679 && !COMPLETE_TYPE_P (TREE_TYPE (prevailing->decl))
680 && COMPLETE_TYPE_P (TREE_TYPE (e->decl))))
685 /* Move it first in the list. */
686 if ((lto_symtab_entry_t) *slot != prevailing)
688 for (e = (lto_symtab_entry_t) *slot; e->next != prevailing; e = e->next)
690 e->next = prevailing->next;
691 prevailing->next = (lto_symtab_entry_t) *slot;
692 *slot = (void *) prevailing;
695 /* Record the prevailing variable. */
696 if (TREE_CODE (prevailing->decl) == VAR_DECL)
697 VEC_safe_push (tree, gc, lto_global_var_decls, prevailing->decl);
699 /* Diagnose mismatched objects. */
700 for (e = prevailing->next; e; e = e->next)
702 if (TREE_CODE (prevailing->decl) == TREE_CODE (e->decl))
705 switch (TREE_CODE (prevailing->decl))
708 gcc_assert (TREE_CODE (e->decl) == FUNCTION_DECL);
709 error_at (DECL_SOURCE_LOCATION (e->decl),
710 "variable %qD redeclared as function", prevailing->decl);
714 gcc_assert (TREE_CODE (e->decl) == VAR_DECL);
715 error_at (DECL_SOURCE_LOCATION (e->decl),
716 "function %qD redeclared as variable", prevailing->decl);
726 inform (DECL_SOURCE_LOCATION (prevailing->decl),
727 "previously declared here");
729 /* Register and adjust types of the entries. */
730 for (e = (lto_symtab_entry_t) *slot; e; e = e->next)
731 TREE_TYPE (e->decl) = gimple_register_type (TREE_TYPE (e->decl));
733 /* Merge the chain to the single prevailing decl and diagnose
735 lto_symtab_merge_decls_2 (slot);
737 /* Drop all but the prevailing decl from the symtab. */
738 if (TREE_CODE (prevailing->decl) != FUNCTION_DECL
739 && TREE_CODE (prevailing->decl) != VAR_DECL)
740 prevailing->next = NULL;
742 /* Set used_from_object_file flags. */
743 if (prevailing->resolution == LDPR_PREVAILING_DEF
744 || prevailing->resolution == LDPR_PREEMPTED_REG
745 || prevailing->resolution == LDPR_RESOLVED_EXEC
746 || prevailing->resolution == LDPR_RESOLVED_DYN)
748 if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
750 if (prevailing->node->same_body_alias)
751 prevailing->node->same_body->local.used_from_object_file = true;
753 prevailing->node->local.used_from_object_file = true;
757 if (prevailing->vnode->alias)
758 prevailing->vnode->extra_name->used_from_object_file = true;
760 prevailing->vnode->used_from_object_file = true;
766 /* Resolve and merge all symbol table chains to a prevailing decl. */
769 lto_symtab_merge_decls (void)
771 lto_symtab_maybe_init_hash_table ();
772 htab_traverse (lto_symtab_identifiers, lto_symtab_merge_decls_1, NULL);
775 /* Helper to process the decl chain for the symbol table entry *SLOT. */
778 lto_symtab_merge_cgraph_nodes_1 (void **slot, void *data ATTRIBUTE_UNUSED)
780 lto_symtab_entry_t e, prevailing = (lto_symtab_entry_t) *slot;
782 if (!prevailing->next)
785 /* Replace the cgraph node of each entry with the prevailing one. */
786 for (e = prevailing->next; e; e = e->next)
789 lto_cgraph_replace_node (e->node, prevailing->node);
790 if (e->vnode != NULL)
791 lto_varpool_replace_node (e->vnode, prevailing->vnode);
794 /* Drop all but the prevailing decl from the symtab. */
795 prevailing->next = NULL;
800 /* Merge cgraph nodes according to the symbol merging done by
801 lto_symtab_merge_decls. */
804 lto_symtab_merge_cgraph_nodes (void)
806 lto_symtab_maybe_init_hash_table ();
807 htab_traverse (lto_symtab_identifiers, lto_symtab_merge_cgraph_nodes_1, NULL);
810 /* Given the decl DECL, return the prevailing decl with the same name. */
813 lto_symtab_prevailing_decl (tree decl)
815 lto_symtab_entry_t ret;
817 /* Builtins and local symbols are their own prevailing decl. */
818 if (!TREE_PUBLIC (decl) || is_builtin_fn (decl))
821 /* DECL_ABSTRACTs are their own prevailng decl. */
822 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_ABSTRACT (decl))
825 /* Ensure DECL_ASSEMBLER_NAME will not set assembler name. */
826 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
828 /* Walk through the list of candidates and return the one we merged to. */
829 ret = lto_symtab_get (DECL_ASSEMBLER_NAME (decl));
836 #include "gt-lto-symtab.h"