2 Copyright (C) 2009-2015 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 "fold-const.h"
32 #include "hard-reg-set.h"
34 #include "basic-block.h"
35 #include "tree-ssa-alias.h"
36 #include "internal-fn.h"
37 #include "gimple-expr.h"
40 #include "lto-streamer.h"
41 #include "ipa-utils.h"
42 #include "alloc-pool.h"
43 #include "symbol-summary.h"
45 #include "ipa-inline.h"
47 #include "print-tree.h"
49 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
50 all edges and removing the old node. */
53 lto_cgraph_replace_node (struct cgraph_node
*node
,
54 struct cgraph_node
*prevailing_node
)
56 struct cgraph_edge
*e
, *next
;
59 if (symtab
->dump_file
)
61 fprintf (symtab
->dump_file
, "Replacing cgraph node %s/%i by %s/%i"
63 node
->name (), node
->order
,
64 prevailing_node
->name (),
65 prevailing_node
->order
,
66 IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
)
67 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
)))));
70 /* Merge node flags. */
71 if (node
->force_output
)
72 prevailing_node
->mark_force_output ();
73 if (node
->forced_by_abi
)
74 prevailing_node
->forced_by_abi
= true;
75 if (node
->address_taken
)
77 gcc_assert (!prevailing_node
->global
.inlined_to
);
78 prevailing_node
->mark_address_taken ();
80 if (node
->definition
&& prevailing_node
->definition
)
81 prevailing_node
->merged
= true;
83 /* Redirect all incoming edges. */
85 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node
->decl
)),
86 TREE_TYPE (TREE_TYPE (node
->decl
)));
87 for (e
= node
->callers
; e
; e
= next
)
89 next
= e
->next_caller
;
90 e
->redirect_callee (prevailing_node
);
91 /* If there is a mismatch between the supposed callee return type and
92 the real one do not attempt to inline this function.
93 ??? We really need a way to match function signatures for ABI
94 compatibility and perform related promotions at inlining time. */
96 e
->call_stmt_cannot_inline_p
= 1;
98 /* Redirect incomming references. */
99 prevailing_node
->clone_referring (node
);
101 /* Fix instrumentation references. */
102 if (node
->instrumented_version
)
104 gcc_assert (node
->instrumentation_clone
105 == prevailing_node
->instrumentation_clone
);
106 node
->instrumented_version
->instrumented_version
= prevailing_node
;
107 if (!prevailing_node
->instrumented_version
)
108 prevailing_node
->instrumented_version
= node
->instrumented_version
;
109 /* Need to reset node->instrumented_version to NULL,
110 otherwise node removal code would reset
111 node->instrumented_version->instrumented_version. */
112 node
->instrumented_version
= NULL
;
115 ipa_merge_profiles (prevailing_node
, node
);
116 lto_free_function_in_decl_state_for_node (node
);
118 if (node
->decl
!= prevailing_node
->decl
)
119 node
->release_body ();
121 /* Finally remove the replaced node. */
125 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
126 all edges and removing the old node. */
129 lto_varpool_replace_node (varpool_node
*vnode
,
130 varpool_node
*prevailing_node
)
132 gcc_assert (!vnode
->definition
|| prevailing_node
->definition
);
133 gcc_assert (!vnode
->analyzed
|| prevailing_node
->analyzed
);
135 prevailing_node
->clone_referring (vnode
);
136 if (vnode
->force_output
)
137 prevailing_node
->force_output
= true;
138 if (vnode
->forced_by_abi
)
139 prevailing_node
->forced_by_abi
= true;
141 /* Be sure we can garbage collect the initializer. */
142 if (DECL_INITIAL (vnode
->decl
)
143 && vnode
->decl
!= prevailing_node
->decl
)
144 DECL_INITIAL (vnode
->decl
) = error_mark_node
;
146 /* Check and report ODR violations on virtual tables. */
147 if (DECL_VIRTUAL_P (vnode
->decl
) || DECL_VIRTUAL_P (prevailing_node
->decl
))
148 compare_virtual_tables (prevailing_node
, vnode
);
150 if (vnode
->tls_model
!= prevailing_node
->tls_model
)
154 /* Non-TLS and TLS never mix together. Also emulated model is not
155 compatible with anything else. */
156 if (prevailing_node
->tls_model
== TLS_MODEL_NONE
157 || prevailing_node
->tls_model
== TLS_MODEL_EMULATED
158 || vnode
->tls_model
== TLS_MODEL_NONE
159 || vnode
->tls_model
== TLS_MODEL_EMULATED
)
161 /* Linked is silently supporting transitions
162 GD -> IE, GD -> LE, LD -> LE, IE -> LE, LD -> IE.
163 Do the same transitions and error out on others. */
164 else if ((prevailing_node
->tls_model
== TLS_MODEL_REAL
165 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
166 && (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
167 || vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
168 prevailing_node
->tls_model
= vnode
->tls_model
;
169 else if ((vnode
->tls_model
== TLS_MODEL_REAL
170 || vnode
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
171 && (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
172 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
174 else if (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
175 && vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
176 prevailing_node
->tls_model
= vnode
->tls_model
;
177 else if (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
178 && prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
184 error_at (DECL_SOURCE_LOCATION (vnode
->decl
),
185 "%qD is defined with tls model %s", vnode
->decl
, tls_model_names
[vnode
->tls_model
]);
186 inform (DECL_SOURCE_LOCATION (prevailing_node
->decl
),
187 "previously defined here as %s",
188 tls_model_names
[prevailing_node
->tls_model
]);
191 /* Finally remove the replaced node. */
195 /* Return non-zero if we want to output waring about T1 and T2.
196 Return value is a bitmask of reasons of violation:
197 Bit 0 indicates that types are not compatible of memory layout.
198 Bot 1 indicates that types are not compatible because of C++ ODR rule. */
201 warn_type_compatibility_p (tree prevailing_type
, tree type
)
204 /* C++ provide a robust way to check for type compatibility via the ODR
206 if (odr_or_derived_type_p (prevailing_type
) && odr_or_derived_type_p (type
)
207 && !odr_types_equivalent_p (prevailing_type
, type
))
210 /* Function types needs special care, because types_compatible_p never
211 thinks prototype is compatible to non-prototype. */
212 if ((TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
213 && TREE_CODE (type
) == TREE_CODE (prevailing_type
))
215 lev
|= warn_type_compatibility_p (TREE_TYPE (prevailing_type
),
217 if (TREE_CODE (type
) == METHOD_TYPE
)
218 lev
|= warn_type_compatibility_p (TYPE_METHOD_BASETYPE (prevailing_type
),
219 TYPE_METHOD_BASETYPE (type
));
220 if (prototype_p (prevailing_type
) && prototype_p (type
)
221 && TYPE_ARG_TYPES (prevailing_type
) != TYPE_ARG_TYPES (type
))
224 for (parm1
= TYPE_ARG_TYPES (prevailing_type
),
225 parm2
= TYPE_ARG_TYPES (type
);
227 parm1
= TREE_CHAIN (prevailing_type
),
228 parm2
= TREE_CHAIN (type
))
229 lev
|= warn_type_compatibility_p (TREE_VALUE (parm1
),
234 if (comp_type_attributes (prevailing_type
, type
) == 0)
238 /* Sharing a global symbol is a strong hint that two types are
239 compatible. We could use this information to complete
240 incomplete pointed-to types more aggressively here, ignoring
241 mismatches in both field and tag names. It's difficult though
242 to guarantee that this does not have side-effects on merging
243 more compatible types from other translation units though. */
245 /* We can tolerate differences in type qualification, the
246 qualification of the prevailing definition will prevail.
247 ??? In principle we might want to only warn for structurally
248 incompatible types here, but unless we have protective measures
249 for TBAA in place that would hide useful information. */
250 prevailing_type
= TYPE_MAIN_VARIANT (prevailing_type
);
251 type
= TYPE_MAIN_VARIANT (type
);
253 if (!types_compatible_p (prevailing_type
, type
))
255 if (TREE_CODE (prevailing_type
) == FUNCTION_TYPE
256 || TREE_CODE (type
) == METHOD_TYPE
)
258 if (COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (prevailing_type
))
261 /* If type is incomplete then avoid warnings in the cases
262 that TBAA handles just fine. */
264 if (TREE_CODE (prevailing_type
) != TREE_CODE (type
))
267 if (TREE_CODE (prevailing_type
) == ARRAY_TYPE
)
269 tree tem1
= TREE_TYPE (prevailing_type
);
270 tree tem2
= TREE_TYPE (type
);
271 while (TREE_CODE (tem1
) == ARRAY_TYPE
272 && TREE_CODE (tem2
) == ARRAY_TYPE
)
274 tem1
= TREE_TYPE (tem1
);
275 tem2
= TREE_TYPE (tem2
);
278 if (TREE_CODE (tem1
) != TREE_CODE (tem2
))
281 if (!types_compatible_p (tem1
, tem2
))
285 /* Fallthru. Compatible enough. */
288 /* ??? We might want to emit a warning here if type qualification
289 differences were spotted. Do not do this unconditionally though. */
294 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
295 Return false if the symbols are not fully compatible and a diagnostic
296 should be emitted. */
299 lto_symtab_merge (symtab_node
*prevailing
, symtab_node
*entry
)
301 tree prevailing_decl
= prevailing
->decl
;
302 tree decl
= entry
->decl
;
304 if (prevailing_decl
== decl
)
307 /* Merge decl state in both directions, we may still end up using
309 TREE_ADDRESSABLE (prevailing_decl
) |= TREE_ADDRESSABLE (decl
);
310 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (prevailing_decl
);
312 /* The linker may ask us to combine two incompatible symbols.
313 Detect this case and notify the caller of required diagnostics. */
315 if (TREE_CODE (decl
) == FUNCTION_DECL
)
317 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
324 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
328 /* There is no point in comparing too many details of the decls here.
329 The type compatibility checks or the completing of types has properly
330 dealt with most issues. */
332 /* The following should all not invoke fatal errors as in non-LTO
333 mode the linker wouldn't complain either. Just emit warnings. */
335 /* Report a warning if user-specified alignments do not match. */
336 if ((DECL_USER_ALIGN (prevailing_decl
) && DECL_USER_ALIGN (decl
))
337 && DECL_ALIGN (prevailing_decl
) < DECL_ALIGN (decl
))
343 /* Return true if the symtab entry E can be replaced by another symtab
347 lto_symtab_resolve_replaceable_p (symtab_node
*e
)
349 if (DECL_EXTERNAL (e
->decl
)
350 || DECL_COMDAT (e
->decl
)
351 || DECL_ONE_ONLY (e
->decl
)
352 || DECL_WEAK (e
->decl
))
355 if (TREE_CODE (e
->decl
) == VAR_DECL
)
356 return (DECL_COMMON (e
->decl
)
357 || (!flag_no_common
&& !DECL_INITIAL (e
->decl
)));
362 /* Return true, if the symbol E should be resolved by lto-symtab.
363 Those are all external symbols and all real symbols that are not static (we
364 handle renaming of static later in partitioning). */
367 lto_symtab_symbol_p (symtab_node
*e
)
369 if (!TREE_PUBLIC (e
->decl
) && !DECL_EXTERNAL (e
->decl
))
371 return e
->real_symbol_p ();
374 /* Return true if the symtab entry E can be the prevailing one. */
377 lto_symtab_resolve_can_prevail_p (symtab_node
*e
)
379 if (!lto_symtab_symbol_p (e
))
382 /* The C++ frontend ends up neither setting TREE_STATIC nor
383 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
384 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
385 if (DECL_EXTERNAL (e
->decl
))
388 return e
->definition
;
391 /* Resolve the symbol with the candidates in the chain *SLOT and store
392 their resolutions. */
395 lto_symtab_resolve_symbols (symtab_node
*first
)
398 symtab_node
*prevailing
= NULL
;
400 /* Always set e->node so that edges are updated to reflect decl merging. */
401 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
402 if (lto_symtab_symbol_p (e
)
403 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
404 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
405 || e
->resolution
== LDPR_PREVAILING_DEF
))
411 /* If the chain is already resolved there is nothing else to do. */
414 /* Assert it's the only one. */
415 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= e
->next_sharing_asm_name
)
416 if (lto_symtab_symbol_p (e
)
417 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
418 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
419 || e
->resolution
== LDPR_PREVAILING_DEF
))
420 fatal_error (input_location
, "multiple prevailing defs for %qE",
421 DECL_NAME (prevailing
->decl
));
425 /* Find the single non-replaceable prevailing symbol and
426 diagnose ODR violations. */
427 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
429 if (!lto_symtab_resolve_can_prevail_p (e
))
432 /* If we have a non-replaceable definition it prevails. */
433 if (!lto_symtab_resolve_replaceable_p (e
))
437 error_at (DECL_SOURCE_LOCATION (e
->decl
),
438 "%qD has already been defined", e
->decl
);
439 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
440 "previously defined here");
448 /* Do a second round choosing one from the replaceable prevailing decls. */
449 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
451 if (!lto_symtab_resolve_can_prevail_p (e
))
454 /* Choose the first function that can prevail as prevailing. */
455 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
)
461 /* From variables that can prevail choose the largest one. */
463 || tree_int_cst_lt (DECL_SIZE (prevailing
->decl
),
465 /* When variables are equivalent try to chose one that has useful
466 DECL_INITIAL. This makes sense for keyed vtables that are
467 DECL_EXTERNAL but initialized. In units that do not need them
468 we replace the initializer by error_mark_node to conserve
471 We know that the vtable is keyed outside the LTO unit - otherwise
472 the keyed instance would prevail. We still can preserve useful
473 info in the initializer. */
474 || (DECL_SIZE (prevailing
->decl
) == DECL_SIZE (e
->decl
)
475 && (DECL_INITIAL (e
->decl
)
476 && DECL_INITIAL (e
->decl
) != error_mark_node
)
477 && (!DECL_INITIAL (prevailing
->decl
)
478 || DECL_INITIAL (prevailing
->decl
) == error_mark_node
)))
485 /* Merge all decls in the symbol table chain to the prevailing decl and
486 issue diagnostics about type mismatches. If DIAGNOSED_P is true
487 do not issue further diagnostics.*/
490 lto_symtab_merge_decls_2 (symtab_node
*first
, bool diagnosed_p
)
492 symtab_node
*prevailing
;
494 vec
<tree
> mismatches
= vNULL
;
498 /* Nothing to do for a single entry. */
500 if (!prevailing
->next_sharing_asm_name
)
503 /* Try to merge each entry with the prevailing one. */
504 for (e
= prevailing
->next_sharing_asm_name
;
505 e
; e
= e
->next_sharing_asm_name
)
506 if (TREE_PUBLIC (e
->decl
))
508 if (!lto_symtab_merge (prevailing
, e
)
510 && !DECL_ARTIFICIAL (e
->decl
))
511 mismatches
.safe_push (e
->decl
);
513 if (mismatches
.is_empty ())
516 /* Diagnose all mismatched re-declarations. */
517 FOR_EACH_VEC_ELT (mismatches
, i
, decl
)
519 int level
= warn_type_compatibility_p (TREE_TYPE (prevailing
->decl
),
525 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
527 "%qD violates the C++ One Definition Rule ",
529 if (!diag
&& (level
& 1))
530 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
531 OPT_Wlto_type_mismatch
,
532 "type of %qD does not match original "
533 "declaration", decl
);
535 warn_types_mismatch (TREE_TYPE (prevailing
->decl
),
537 DECL_SOURCE_LOCATION (prevailing
->decl
),
538 DECL_SOURCE_LOCATION (decl
));
541 else if ((DECL_USER_ALIGN (prevailing
->decl
)
542 && DECL_USER_ALIGN (decl
))
543 && DECL_ALIGN (prevailing
->decl
) < DECL_ALIGN (decl
))
545 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
546 OPT_Wlto_type_mismatch
,
547 "alignment of %qD is bigger than "
548 "original declaration", decl
);
552 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
553 "%qD was previously declared here", prevailing
->decl
);
555 mismatches
.release ();
558 /* Helper to process the decl chain for the symbol table entry *SLOT. */
561 lto_symtab_merge_decls_1 (symtab_node
*first
)
564 symtab_node
*prevailing
;
565 bool diagnosed_p
= false;
567 if (symtab
->dump_file
)
569 fprintf (symtab
->dump_file
, "Merging nodes for %s. Candidates:\n",
571 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
572 if (TREE_PUBLIC (e
->decl
))
573 e
->dump (symtab
->dump_file
);
576 /* Compute the symbol resolutions. This is a no-op when using the
577 linker plugin and resolution was decided by the linker. */
578 prevailing
= lto_symtab_resolve_symbols (first
);
580 /* If there's not a prevailing symbol yet it's an external reference.
581 Happens a lot during ltrans. Choose the first symbol with a
582 cgraph or a varpool node. */
585 for (prevailing
= first
;
586 prevailing
; prevailing
= prevailing
->next_sharing_asm_name
)
587 if (lto_symtab_symbol_p (prevailing
))
591 /* For variables chose with a priority variant with vnode
592 attached (i.e. from unit where external declaration of
593 variable is actually used).
594 When there are multiple variants, chose one with size.
595 This is needed for C++ typeinfos, for example in
596 lto/20081204-1 there are typeifos in both units, just
597 one of them do have size. */
598 if (TREE_CODE (prevailing
->decl
) == VAR_DECL
)
600 for (e
= prevailing
->next_sharing_asm_name
;
601 e
; e
= e
->next_sharing_asm_name
)
602 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing
->decl
))
603 && COMPLETE_TYPE_P (TREE_TYPE (e
->decl
))
604 && lto_symtab_symbol_p (e
))
607 /* For variables prefer the non-builtin if one is available. */
608 else if (TREE_CODE (prevailing
->decl
) == FUNCTION_DECL
)
610 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
611 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
612 && !DECL_BUILT_IN (e
->decl
)
613 && lto_symtab_symbol_p (e
))
621 symtab
->symtab_prevail_in_asm_name_hash (prevailing
);
623 /* Diagnose mismatched objects. */
624 for (e
= prevailing
->next_sharing_asm_name
;
625 e
; e
= e
->next_sharing_asm_name
)
627 if (TREE_CODE (prevailing
->decl
)
628 == TREE_CODE (e
->decl
))
630 if (!lto_symtab_symbol_p (e
))
633 switch (TREE_CODE (prevailing
->decl
))
636 gcc_assert (TREE_CODE (e
->decl
) == FUNCTION_DECL
);
637 error_at (DECL_SOURCE_LOCATION (e
->decl
),
638 "variable %qD redeclared as function",
643 gcc_assert (TREE_CODE (e
->decl
) == VAR_DECL
);
644 error_at (DECL_SOURCE_LOCATION (e
->decl
),
645 "function %qD redeclared as variable",
656 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
657 "previously declared here");
659 /* Merge the chain to the single prevailing decl and diagnose
661 lto_symtab_merge_decls_2 (prevailing
, diagnosed_p
);
663 if (symtab
->dump_file
)
665 fprintf (symtab
->dump_file
, "After resolution:\n");
666 for (e
= prevailing
; e
; e
= e
->next_sharing_asm_name
)
667 e
->dump (symtab
->dump_file
);
671 /* Resolve and merge all symbol table chains to a prevailing decl. */
674 lto_symtab_merge_decls (void)
678 /* Populate assembler name hash. */
679 symtab
->symtab_initialize_asm_name_hash ();
681 FOR_EACH_SYMBOL (node
)
682 if (!node
->previous_sharing_asm_name
683 && node
->next_sharing_asm_name
)
684 lto_symtab_merge_decls_1 (node
);
687 /* Helper to process the decl chain for the symbol table entry *SLOT. */
690 lto_symtab_merge_symbols_1 (symtab_node
*prevailing
)
695 /* Replace the cgraph node of each entry with the prevailing one. */
696 for (e
= prevailing
->next_sharing_asm_name
; e
;
699 next
= e
->next_sharing_asm_name
;
701 if (!lto_symtab_symbol_p (e
))
703 cgraph_node
*ce
= dyn_cast
<cgraph_node
*> (e
);
704 if (ce
&& !DECL_BUILT_IN (e
->decl
))
705 lto_cgraph_replace_node (ce
, dyn_cast
<cgraph_node
*> (prevailing
));
706 if (varpool_node
*ve
= dyn_cast
<varpool_node
*> (e
))
707 lto_varpool_replace_node (ve
, dyn_cast
<varpool_node
*> (prevailing
));
713 /* Merge cgraph nodes according to the symbol merging done by
714 lto_symtab_merge_decls. */
717 lto_symtab_merge_symbols (void)
723 symtab
->symtab_initialize_asm_name_hash ();
725 /* Do the actual merging.
726 At this point we invalidate hash translating decls into symtab nodes
727 because after removing one of duplicate decls the hash is not correcly
728 updated to the ohter dupliate. */
729 FOR_EACH_SYMBOL (node
)
730 if (lto_symtab_symbol_p (node
)
731 && node
->next_sharing_asm_name
732 && !node
->previous_sharing_asm_name
)
733 lto_symtab_merge_symbols_1 (node
);
735 /* Resolve weakref aliases whose target are now in the compilation unit.
736 also re-populate the hash translating decls into symtab nodes*/
737 FOR_EACH_SYMBOL (node
)
739 cgraph_node
*cnode
, *cnode2
;
743 if (!node
->analyzed
&& node
->alias_target
)
745 symtab_node
*tgt
= symtab_node::get_for_asmname (node
->alias_target
);
746 gcc_assert (node
->weakref
);
748 node
->resolve_alias (tgt
);
752 if (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
754 || cnode
->clone_of
->decl
!= cnode
->decl
)
756 /* Builtins are not merged via decl merging. It is however
757 possible that tree merging unified the declaration. We
758 do not want duplicate entries in symbol table. */
759 if (cnode
&& DECL_BUILT_IN (node
->decl
)
760 && (cnode2
= cgraph_node::get (node
->decl
))
762 lto_cgraph_replace_node (cnode2
, cnode
);
764 /* The user defined assembler variables are also not unified by their
765 symbol name (since it is irrelevant), but we need to unify symbol
766 nodes if tree merging occured. */
767 if ((vnode
= dyn_cast
<varpool_node
*> (node
))
768 && DECL_HARD_REGISTER (vnode
->decl
)
769 && (node2
= symtab_node::get (vnode
->decl
))
771 lto_varpool_replace_node (dyn_cast
<varpool_node
*> (node2
),
775 /* Abstract functions may have duplicated cgraph nodes attached;
777 else if (cnode
&& DECL_ABSTRACT_P (cnode
->decl
)
778 && (cnode2
= cgraph_node::get (node
->decl
))
782 node
->decl
->decl_with_vis
.symtab_node
= node
;
788 /* Given the decl DECL, return the prevailing decl with the same name. */
791 lto_symtab_prevailing_decl (tree decl
)
795 /* Builtins and local symbols are their own prevailing decl. */
796 if ((!TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
)) || is_builtin_fn (decl
))
799 /* DECL_ABSTRACT_Ps are their own prevailing decl. */
800 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_ABSTRACT_P (decl
))
803 /* Likewise builtins are their own prevailing decl. This preserves
804 non-builtin vs. builtin uses from compile-time. */
805 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
808 /* Ensure DECL_ASSEMBLER_NAME will not set assembler name. */
809 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
811 /* Walk through the list of candidates and return the one we merged to. */
812 ret
= symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl
));