2 Copyright (C) 2009-2018 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"
26 #include "basic-block.h"
30 #include "lto-streamer.h"
31 #include "ipa-utils.h"
35 #include "lto-symtab.h"
36 #include "stringpool.h"
39 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
40 all edges and removing the old node. */
43 lto_cgraph_replace_node (struct cgraph_node
*node
,
44 struct cgraph_node
*prevailing_node
)
46 struct cgraph_edge
*e
, *next
;
51 fprintf (dump_file
, "Replacing cgraph node %s by %s"
54 prevailing_node
->dump_name (),
55 IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
)
56 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
)))));
59 /* Merge node flags. */
60 if (node
->force_output
)
61 prevailing_node
->mark_force_output ();
62 if (node
->forced_by_abi
)
63 prevailing_node
->forced_by_abi
= true;
64 if (node
->address_taken
)
66 gcc_assert (!prevailing_node
->global
.inlined_to
);
67 prevailing_node
->mark_address_taken ();
69 if (node
->definition
&& prevailing_node
->definition
70 && DECL_COMDAT (node
->decl
) && DECL_COMDAT (prevailing_node
->decl
))
71 prevailing_node
->merged_comdat
= true;
73 /* Redirect all incoming edges. */
75 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node
->decl
)),
76 TREE_TYPE (TREE_TYPE (node
->decl
)));
77 for (e
= node
->callers
; e
; e
= next
)
79 next
= e
->next_caller
;
80 e
->redirect_callee (prevailing_node
);
81 /* If there is a mismatch between the supposed callee return type and
82 the real one do not attempt to inline this function.
83 ??? We really need a way to match function signatures for ABI
84 compatibility and perform related promotions at inlining time. */
87 e
->inline_failed
= CIF_LTO_MISMATCHED_DECLARATIONS
;
88 e
->call_stmt_cannot_inline_p
= 1;
91 /* Redirect incomming references. */
92 prevailing_node
->clone_referring (node
);
93 lto_free_function_in_decl_state_for_node (node
);
95 if (node
->decl
!= prevailing_node
->decl
)
96 node
->release_body ();
98 /* Finally remove the replaced node. */
102 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
103 all edges and removing the old node. */
106 lto_varpool_replace_node (varpool_node
*vnode
,
107 varpool_node
*prevailing_node
)
109 gcc_assert (!vnode
->definition
|| prevailing_node
->definition
);
110 gcc_assert (!vnode
->analyzed
|| prevailing_node
->analyzed
);
112 prevailing_node
->clone_referring (vnode
);
113 if (vnode
->force_output
)
114 prevailing_node
->force_output
= true;
115 if (vnode
->forced_by_abi
)
116 prevailing_node
->forced_by_abi
= true;
118 /* Be sure we can garbage collect the initializer. */
119 if (DECL_INITIAL (vnode
->decl
)
120 && vnode
->decl
!= prevailing_node
->decl
)
121 DECL_INITIAL (vnode
->decl
) = error_mark_node
;
123 /* Check and report ODR violations on virtual tables. */
124 if (DECL_VIRTUAL_P (vnode
->decl
) || DECL_VIRTUAL_P (prevailing_node
->decl
))
125 compare_virtual_tables (prevailing_node
, vnode
);
127 if (vnode
->tls_model
!= prevailing_node
->tls_model
)
131 /* Non-TLS and TLS never mix together. Also emulated model is not
132 compatible with anything else. */
133 if (prevailing_node
->tls_model
== TLS_MODEL_NONE
134 || prevailing_node
->tls_model
== TLS_MODEL_EMULATED
135 || vnode
->tls_model
== TLS_MODEL_NONE
136 || vnode
->tls_model
== TLS_MODEL_EMULATED
)
138 /* Linked is silently supporting transitions
139 GD -> IE, GD -> LE, LD -> LE, IE -> LE, LD -> IE.
140 Do the same transitions and error out on others. */
141 else if ((prevailing_node
->tls_model
== TLS_MODEL_REAL
142 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
143 && (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
144 || vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
145 prevailing_node
->tls_model
= vnode
->tls_model
;
146 else if ((vnode
->tls_model
== TLS_MODEL_REAL
147 || vnode
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
148 && (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
149 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
151 else if (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
152 && vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
153 prevailing_node
->tls_model
= vnode
->tls_model
;
154 else if (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
155 && prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
161 error_at (DECL_SOURCE_LOCATION (vnode
->decl
),
162 "%qD is defined with tls model %s", vnode
->decl
, tls_model_names
[vnode
->tls_model
]);
163 inform (DECL_SOURCE_LOCATION (prevailing_node
->decl
),
164 "previously defined here as %s",
165 tls_model_names
[prevailing_node
->tls_model
]);
168 /* Finally remove the replaced node. */
172 /* Return non-zero if we want to output waring about T1 and T2.
173 Return value is a bitmask of reasons of violation:
174 Bit 0 indicates that types are not compatible.
175 Bit 1 indicates that types are not compatible because of C++ ODR rule.
176 If COMMON_OR_EXTERN is true, do not warn on size mismatches of arrays.
177 Bit 2 indicates that types are not ODR compatible
179 The interoperability rules are language specific. At present we do only
180 full checking for C++ ODR rule and for other languages we do basic check
181 that data structures are of same size and TBAA compatible. Our TBAA
182 implementation should be coarse enough so all valid type transitions
183 across different languages are allowed.
185 In partiucular we thus allow almost arbitrary type changes with
186 -fno-strict-aliasing which may be tough of as a feature rather than bug
187 as it allows to implement dodgy tricks in the language runtimes.
189 Naturally this code can be strenghtened significantly if we could track
190 down the language of origin. */
193 warn_type_compatibility_p (tree prevailing_type
, tree type
,
194 bool common_or_extern
)
197 bool odr_p
= odr_or_derived_type_p (prevailing_type
)
198 && odr_or_derived_type_p (type
);
200 if (prevailing_type
== type
)
203 /* C++ provide a robust way to check for type compatibility via the ODR
205 if (odr_p
&& !odr_types_equivalent_p (prevailing_type
, type
))
208 /* Function types needs special care, because types_compatible_p never
209 thinks prototype is compatible to non-prototype. */
210 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
212 if (TREE_CODE (type
) != TREE_CODE (prevailing_type
))
214 lev
|= warn_type_compatibility_p (TREE_TYPE (prevailing_type
),
215 TREE_TYPE (type
), false);
216 if (TREE_CODE (type
) == METHOD_TYPE
217 && TREE_CODE (prevailing_type
) == METHOD_TYPE
)
218 lev
|= warn_type_compatibility_p (TYPE_METHOD_BASETYPE (prevailing_type
),
219 TYPE_METHOD_BASETYPE (type
), false);
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 (parm1
),
228 parm2
= TREE_CHAIN (parm2
))
229 lev
|= warn_type_compatibility_p (TREE_VALUE (parm1
),
230 TREE_VALUE (parm2
), false);
232 lev
|= odr_p
? 3 : 1;
234 if (comp_type_attributes (prevailing_type
, type
) == 0)
239 /* Get complete type. */
240 prevailing_type
= TYPE_MAIN_VARIANT (prevailing_type
);
241 type
= TYPE_MAIN_VARIANT (type
);
243 /* We can not use types_compatible_p because we permit some changes
244 across types. For example unsigned size_t and "signed size_t" may be
245 compatible when merging C and Fortran types. */
246 if (COMPLETE_TYPE_P (prevailing_type
)
247 && COMPLETE_TYPE_P (type
)
248 /* While global declarations are never variadic, we can recurse here
249 for function parameter types. */
250 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
251 && TREE_CODE (TYPE_SIZE (prevailing_type
)) == INTEGER_CST
252 && !tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prevailing_type
)))
254 /* As a special case do not warn about merging
258 here the first declaration is COMMON or EXTERN
259 and sizeof(a) == sizeof (int). */
260 if (!common_or_extern
261 || TREE_CODE (type
) != ARRAY_TYPE
262 || TYPE_SIZE (type
) != TYPE_SIZE (TREE_TYPE (type
)))
266 /* Verify TBAA compatibility. Take care of alias set 0 and the fact that
267 we make ptr_type_node to TBAA compatible with every other type. */
268 if (type_with_alias_set_p (type
) && type_with_alias_set_p (prevailing_type
))
270 alias_set_type set1
= get_alias_set (type
);
271 alias_set_type set2
= get_alias_set (prevailing_type
);
273 if (set1
&& set2
&& set1
!= set2
)
275 tree t1
= type
, t2
= prevailing_type
;
277 /* Alias sets of arrays with aliased components are the same as alias
278 sets of the inner types. */
279 while (TREE_CODE (t1
) == ARRAY_TYPE
280 && !TYPE_NONALIASED_COMPONENT (t1
)
281 && TREE_CODE (t2
) == ARRAY_TYPE
282 && !TYPE_NONALIASED_COMPONENT (t2
))
287 if ((!POINTER_TYPE_P (t1
) || !POINTER_TYPE_P (t2
))
288 || (set1
!= TYPE_ALIAS_SET (ptr_type_node
)
289 && set2
!= TYPE_ALIAS_SET (ptr_type_node
)))
297 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
298 Return false if the symbols are not fully compatible and a diagnostic
299 should be emitted. */
302 lto_symtab_merge (symtab_node
*prevailing
, symtab_node
*entry
)
304 tree prevailing_decl
= prevailing
->decl
;
305 tree decl
= entry
->decl
;
307 if (prevailing_decl
== decl
)
310 if (TREE_CODE (decl
) != TREE_CODE (prevailing_decl
))
313 /* Merge decl state in both directions, we may still end up using
315 TREE_ADDRESSABLE (prevailing_decl
) |= TREE_ADDRESSABLE (decl
);
316 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (prevailing_decl
);
318 /* The linker may ask us to combine two incompatible symbols.
319 Detect this case and notify the caller of required diagnostics. */
321 if (TREE_CODE (decl
) == FUNCTION_DECL
)
323 /* Merge decl state in both directions, we may still end up using
325 DECL_POSSIBLY_INLINED (prevailing_decl
) |= DECL_POSSIBLY_INLINED (decl
);
326 DECL_POSSIBLY_INLINED (decl
) |= DECL_POSSIBLY_INLINED (prevailing_decl
);
328 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
331 || DECL_EXTERNAL (decl
)))
337 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
339 DECL_COMMON (decl
) || DECL_EXTERNAL (decl
)))
342 /* There is no point in comparing too many details of the decls here.
343 The type compatibility checks or the completing of types has properly
344 dealt with most issues. */
346 /* The following should all not invoke fatal errors as in non-LTO
347 mode the linker wouldn't complain either. Just emit warnings. */
349 /* Report a warning if user-specified alignments do not match. */
350 if ((DECL_USER_ALIGN (prevailing_decl
) && DECL_USER_ALIGN (decl
))
351 && DECL_ALIGN (prevailing_decl
) < DECL_ALIGN (decl
))
354 if (DECL_SIZE (decl
) && DECL_SIZE (prevailing_decl
)
355 && !tree_int_cst_equal (DECL_SIZE (decl
), DECL_SIZE (prevailing_decl
)))
357 if (!DECL_COMMON (decl
) && !DECL_EXTERNAL (decl
))
360 tree type
= TREE_TYPE (decl
);
362 /* For record type, check for array at the end of the structure. */
363 if (TREE_CODE (type
) == RECORD_TYPE
)
365 tree field
= TYPE_FIELDS (type
);
366 while (DECL_CHAIN (field
) != NULL_TREE
)
367 field
= DECL_CHAIN (field
);
369 return TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
;
371 /* As a special case do not warn about merging
375 here the first declaration is COMMON
376 and sizeof(a) == sizeof (int). */
377 else if (TREE_CODE (type
) == ARRAY_TYPE
)
378 return (TYPE_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (type
)));
384 /* Return true if the symtab entry E can be replaced by another symtab
388 lto_symtab_resolve_replaceable_p (symtab_node
*e
)
390 if (DECL_EXTERNAL (e
->decl
)
391 || DECL_COMDAT (e
->decl
)
392 || DECL_ONE_ONLY (e
->decl
)
393 || DECL_WEAK (e
->decl
))
396 if (TREE_CODE (e
->decl
) == VAR_DECL
)
397 return (DECL_COMMON (e
->decl
)
398 || (!flag_no_common
&& !DECL_INITIAL (e
->decl
)));
403 /* Return true, if the symbol E should be resolved by lto-symtab.
404 Those are all external symbols and all real symbols that are not static (we
405 handle renaming of static later in partitioning). */
408 lto_symtab_symbol_p (symtab_node
*e
)
410 if (!TREE_PUBLIC (e
->decl
) && !DECL_EXTERNAL (e
->decl
))
412 return e
->real_symbol_p ();
415 /* Return true if the symtab entry E can be the prevailing one. */
418 lto_symtab_resolve_can_prevail_p (symtab_node
*e
)
420 if (!lto_symtab_symbol_p (e
))
423 /* The C++ frontend ends up neither setting TREE_STATIC nor
424 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
425 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
426 if (DECL_EXTERNAL (e
->decl
))
429 return e
->definition
;
432 /* Resolve the symbol with the candidates in the chain *SLOT and store
433 their resolutions. */
436 lto_symtab_resolve_symbols (symtab_node
*first
)
439 symtab_node
*prevailing
= NULL
;
441 /* Always set e->node so that edges are updated to reflect decl merging. */
442 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
443 if (lto_symtab_symbol_p (e
)
444 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
445 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
446 || e
->resolution
== LDPR_PREVAILING_DEF
))
452 /* If the chain is already resolved there is nothing else to do. */
455 /* Assert it's the only one.
456 GCC should silence multiple PREVAILING_DEF_IRONLY defs error
457 on COMMON symbols since it isn't error.
458 See: https://sourceware.org/bugzilla/show_bug.cgi?id=23079. */
459 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= e
->next_sharing_asm_name
)
460 if (lto_symtab_symbol_p (e
)
461 && !DECL_COMMON (prevailing
->decl
)
462 && !DECL_COMMON (e
->decl
)
463 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
464 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
465 || e
->resolution
== LDPR_PREVAILING_DEF
))
466 fatal_error (input_location
, "multiple prevailing defs for %qE",
467 DECL_NAME (prevailing
->decl
));
471 /* Find the single non-replaceable prevailing symbol and
472 diagnose ODR violations. */
473 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
475 if (!lto_symtab_resolve_can_prevail_p (e
))
478 /* If we have a non-replaceable definition it prevails. */
479 if (!lto_symtab_resolve_replaceable_p (e
))
483 error_at (DECL_SOURCE_LOCATION (e
->decl
),
484 "%qD has already been defined", e
->decl
);
485 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
486 "previously defined here");
494 /* Do a second round choosing one from the replaceable prevailing decls. */
495 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
497 if (!lto_symtab_resolve_can_prevail_p (e
))
500 /* Choose the first function that can prevail as prevailing. */
501 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
)
507 /* From variables that can prevail choose the largest one. */
509 || tree_int_cst_lt (DECL_SIZE (prevailing
->decl
),
511 /* When variables are equivalent try to chose one that has useful
512 DECL_INITIAL. This makes sense for keyed vtables that are
513 DECL_EXTERNAL but initialized. In units that do not need them
514 we replace the initializer by error_mark_node to conserve
517 We know that the vtable is keyed outside the LTO unit - otherwise
518 the keyed instance would prevail. We still can preserve useful
519 info in the initializer. */
520 || (DECL_SIZE (prevailing
->decl
) == DECL_SIZE (e
->decl
)
521 && (DECL_INITIAL (e
->decl
)
522 && DECL_INITIAL (e
->decl
) != error_mark_node
)
523 && (!DECL_INITIAL (prevailing
->decl
)
524 || DECL_INITIAL (prevailing
->decl
) == error_mark_node
)))
531 /* Decide if it is OK to merge DECL into PREVAILING.
532 Because we wrap most of uses of declarations in MEM_REF, we can tolerate
533 some differences but other code may inspect directly the DECL. */
536 lto_symtab_merge_p (tree prevailing
, tree decl
)
538 if (TREE_CODE (prevailing
) != TREE_CODE (decl
))
541 fprintf (dump_file
, "Not merging decls; "
542 "TREE_CODE mismatch\n");
545 gcc_checking_assert (TREE_CHAIN (prevailing
) == TREE_CHAIN (decl
));
547 if (TREE_CODE (prevailing
) == FUNCTION_DECL
)
549 if (DECL_BUILT_IN (prevailing
) != DECL_BUILT_IN (decl
))
552 fprintf (dump_file
, "Not merging decls; "
553 "DECL_BUILT_IN mismatch\n");
556 if (DECL_BUILT_IN (prevailing
)
557 && (DECL_BUILT_IN_CLASS (prevailing
) != DECL_BUILT_IN_CLASS (decl
)
558 || DECL_FUNCTION_CODE (prevailing
) != DECL_FUNCTION_CODE (decl
)))
561 fprintf (dump_file
, "Not merging decls; "
562 "DECL_BUILT_IN_CLASS or CODE mismatch\n");
567 if (DECL_ATTRIBUTES (prevailing
) != DECL_ATTRIBUTES (decl
))
569 tree prev_attr
= lookup_attribute ("error", DECL_ATTRIBUTES (prevailing
));
570 tree attr
= lookup_attribute ("error", DECL_ATTRIBUTES (decl
));
571 if ((prev_attr
== NULL
) != (attr
== NULL
)
572 || (prev_attr
&& !attribute_value_equal (prev_attr
, attr
)))
575 fprintf (dump_file
, "Not merging decls; "
576 "error attribute mismatch\n");
580 prev_attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (prevailing
));
581 attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (decl
));
582 if ((prev_attr
== NULL
) != (attr
== NULL
)
583 || (prev_attr
&& !attribute_value_equal (prev_attr
, attr
)))
586 fprintf (dump_file
, "Not merging decls; "
587 "warning attribute mismatch\n");
591 prev_attr
= lookup_attribute ("noreturn", DECL_ATTRIBUTES (prevailing
));
592 attr
= lookup_attribute ("noreturn", DECL_ATTRIBUTES (decl
));
593 if ((prev_attr
== NULL
) != (attr
== NULL
))
596 fprintf (dump_file
, "Not merging decls; "
597 "noreturn attribute mismatch\n");
604 /* Merge all decls in the symbol table chain to the prevailing decl and
605 issue diagnostics about type mismatches. If DIAGNOSED_P is true
606 do not issue further diagnostics.*/
609 lto_symtab_merge_decls_2 (symtab_node
*first
, bool diagnosed_p
)
611 symtab_node
*prevailing
;
613 vec
<tree
> mismatches
= vNULL
;
618 /* Nothing to do for a single entry. */
620 if (!prevailing
->next_sharing_asm_name
)
623 /* Try to merge each entry with the prevailing one. */
624 symtab_node
*last_prevailing
= prevailing
, *next
;
625 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= next
)
627 next
= e
->next_sharing_asm_name
;
629 /* Skip non-LTO symbols and symbols whose declaration we already
631 if (lto_symtab_prevailing_decl (e
->decl
) != e
->decl
632 || !lto_symtab_symbol_p (e
)
633 || e
->decl
== prevailing
->decl
)
636 if (!lto_symtab_merge (prevailing
, e
)
638 && !DECL_ARTIFICIAL (e
->decl
))
639 mismatches
.safe_push (e
->decl
);
641 symtab_node
*this_prevailing
;
642 for (this_prevailing
= prevailing
; ;
643 this_prevailing
= this_prevailing
->next_sharing_asm_name
)
645 if (this_prevailing
->decl
!= e
->decl
646 && lto_symtab_merge_p (this_prevailing
->decl
, e
->decl
))
648 if (this_prevailing
== last_prevailing
)
650 this_prevailing
= NULL
;
656 lto_symtab_prevail_decl (this_prevailing
->decl
, e
->decl
);
657 /* Maintain LRU list: relink the new prevaililng symbol
658 just after previaling node in the chain and update last_prevailing.
659 Since the number of possible declarations of a given symbol is
660 small, this should be faster than building a hash. */
661 else if (e
== prevailing
->next_sharing_asm_name
)
665 if (e
->next_sharing_asm_name
)
666 e
->next_sharing_asm_name
->previous_sharing_asm_name
667 = e
->previous_sharing_asm_name
;
668 e
->previous_sharing_asm_name
->next_sharing_asm_name
669 = e
->next_sharing_asm_name
;
670 e
->previous_sharing_asm_name
= prevailing
;
671 e
->next_sharing_asm_name
= prevailing
->next_sharing_asm_name
;
672 prevailing
->next_sharing_asm_name
->previous_sharing_asm_name
= e
;
673 prevailing
->next_sharing_asm_name
= e
;
674 if (last_prevailing
== prevailing
)
678 if (mismatches
.is_empty ())
681 /* Diagnose all mismatched re-declarations. */
682 FOR_EACH_VEC_ELT (mismatches
, i
, decl
)
684 /* Do not diagnose two built-in declarations, there is no useful
685 location in that case. It also happens for AVR if two built-ins
686 use the same asm name because their libgcc assembler code is the
687 same, see PR78562. */
688 if (DECL_IS_BUILTIN (prevailing
->decl
)
689 && DECL_IS_BUILTIN (decl
))
692 int level
= warn_type_compatibility_p (TREE_TYPE (prevailing
->decl
),
699 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
701 "%qD violates the C++ One Definition Rule ",
703 if (!diag
&& (level
& 1))
704 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
705 OPT_Wlto_type_mismatch
,
706 "type of %qD does not match original "
707 "declaration", decl
);
710 warn_types_mismatch (TREE_TYPE (prevailing
->decl
),
712 DECL_SOURCE_LOCATION (prevailing
->decl
),
713 DECL_SOURCE_LOCATION (decl
));
715 && !TREE_READONLY (prevailing
->decl
))
720 else if ((DECL_USER_ALIGN (prevailing
->decl
)
721 && DECL_USER_ALIGN (decl
))
722 && DECL_ALIGN (prevailing
->decl
) < DECL_ALIGN (decl
))
724 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
725 OPT_Wlto_type_mismatch
,
726 "alignment of %qD is bigger than "
727 "original declaration", decl
);
730 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
731 OPT_Wlto_type_mismatch
,
732 "size of %qD differ from the size of "
733 "original declaration", decl
);
736 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
737 "%qD was previously declared here", prevailing
->decl
);
739 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
740 "code may be misoptimized unless "
741 "-fno-strict-aliasing is used");
743 mismatches
.release ();
746 /* Helper to process the decl chain for the symbol table entry *SLOT. */
749 lto_symtab_merge_decls_1 (symtab_node
*first
)
752 symtab_node
*prevailing
;
753 bool diagnosed_p
= false;
757 fprintf (dump_file
, "Merging nodes for %s. Candidates:\n",
759 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
760 if (TREE_PUBLIC (e
->decl
))
764 /* Compute the symbol resolutions. This is a no-op when using the
765 linker plugin and resolution was decided by the linker. */
766 prevailing
= lto_symtab_resolve_symbols (first
);
768 /* If there's not a prevailing symbol yet it's an external reference.
769 Happens a lot during ltrans. Choose the first symbol with a
770 cgraph or a varpool node. */
773 for (prevailing
= first
;
774 prevailing
; prevailing
= prevailing
->next_sharing_asm_name
)
775 if (lto_symtab_symbol_p (prevailing
))
779 /* For variables chose with a priority variant with vnode
780 attached (i.e. from unit where external declaration of
781 variable is actually used).
782 When there are multiple variants, chose one with size.
783 This is needed for C++ typeinfos, for example in
784 lto/20081204-1 there are typeifos in both units, just
785 one of them do have size. */
786 if (TREE_CODE (prevailing
->decl
) == VAR_DECL
)
788 for (e
= prevailing
->next_sharing_asm_name
;
789 e
; e
= e
->next_sharing_asm_name
)
790 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing
->decl
))
791 && COMPLETE_TYPE_P (TREE_TYPE (e
->decl
))
792 && lto_symtab_symbol_p (e
))
795 /* For functions prefer the non-builtin if one is available. */
796 else if (TREE_CODE (prevailing
->decl
) == FUNCTION_DECL
)
798 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
799 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
800 && !DECL_BUILT_IN (e
->decl
)
801 && lto_symtab_symbol_p (e
))
809 symtab
->symtab_prevail_in_asm_name_hash (prevailing
);
811 /* Diagnose mismatched objects. */
812 for (e
= prevailing
->next_sharing_asm_name
;
813 e
; e
= e
->next_sharing_asm_name
)
815 if (TREE_CODE (prevailing
->decl
)
816 == TREE_CODE (e
->decl
))
818 if (!lto_symtab_symbol_p (e
))
821 switch (TREE_CODE (prevailing
->decl
))
824 gcc_assert (TREE_CODE (e
->decl
) == FUNCTION_DECL
);
825 error_at (DECL_SOURCE_LOCATION (e
->decl
),
826 "variable %qD redeclared as function",
831 gcc_assert (TREE_CODE (e
->decl
) == VAR_DECL
);
832 error_at (DECL_SOURCE_LOCATION (e
->decl
),
833 "function %qD redeclared as variable",
844 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
845 "previously declared here");
847 /* Merge the chain to the single prevailing decl and diagnose
849 lto_symtab_merge_decls_2 (prevailing
, diagnosed_p
);
853 fprintf (dump_file
, "After resolution:\n");
854 for (e
= prevailing
; e
; e
= e
->next_sharing_asm_name
)
859 /* Resolve and merge all symbol table chains to a prevailing decl. */
862 lto_symtab_merge_decls (void)
866 gcc_assert (!dump_file
);
867 dump_file
= dump_begin (decl_merge_dump_id
, NULL
);
869 /* Populate assembler name hash. */
870 symtab
->symtab_initialize_asm_name_hash ();
872 FOR_EACH_SYMBOL (node
)
873 if (!node
->previous_sharing_asm_name
874 && node
->next_sharing_asm_name
)
875 lto_symtab_merge_decls_1 (node
);
878 dump_end (decl_merge_dump_id
, dump_file
);
882 /* Helper to process the decl chain for the symbol table entry *SLOT. */
885 lto_symtab_merge_symbols_1 (symtab_node
*prevailing
)
890 prevailing
->decl
->decl_with_vis
.symtab_node
= prevailing
;
892 /* Replace the cgraph node of each entry with the prevailing one. */
893 for (e
= prevailing
->next_sharing_asm_name
; e
;
896 next
= e
->next_sharing_asm_name
;
898 if (!lto_symtab_symbol_p (e
))
900 cgraph_node
*ce
= dyn_cast
<cgraph_node
*> (e
);
901 symtab_node
*to
= symtab_node::get (lto_symtab_prevailing_decl (e
->decl
));
903 /* No matter how we are going to deal with resolution, we will ultimately
904 use prevailing definition. */
906 ipa_merge_profiles (dyn_cast
<cgraph_node
*> (prevailing
),
907 dyn_cast
<cgraph_node
*> (e
));
909 /* If we decided to replace the node by TO, do it. */
913 lto_cgraph_replace_node (ce
, dyn_cast
<cgraph_node
*> (to
));
914 else if (varpool_node
*ve
= dyn_cast
<varpool_node
*> (e
))
915 lto_varpool_replace_node (ve
, dyn_cast
<varpool_node
*> (to
));
917 /* Watch out for duplicated symbols for a given declaration. */
918 else if (!e
->transparent_alias
919 || !e
->definition
|| e
->get_alias_target () != to
)
921 /* We got a new declaration we do not want to merge. In this case
922 get rid of the existing definition and create a transparent
926 lto_free_function_in_decl_state_for_node (ce
);
930 symtab
->call_cgraph_removal_hooks (ce
);
934 DECL_INITIAL (e
->decl
) = error_mark_node
;
935 if (e
->lto_file_data
)
937 lto_free_function_in_decl_state_for_node (e
);
938 e
->lto_file_data
= NULL
;
940 symtab
->call_varpool_removal_hooks (dyn_cast
<varpool_node
*> (e
));
942 e
->remove_all_references ();
943 e
->analyzed
= e
->body_removed
= false;
944 e
->resolve_alias (prevailing
, true);
945 gcc_assert (e
!= prevailing
);
952 /* Merge cgraph nodes according to the symbol merging done by
953 lto_symtab_merge_decls. */
956 lto_symtab_merge_symbols (void)
962 symtab
->symtab_initialize_asm_name_hash ();
964 /* Do the actual merging.
965 At this point we invalidate hash translating decls into symtab nodes
966 because after removing one of duplicate decls the hash is not correcly
967 updated to the ohter dupliate. */
968 FOR_EACH_SYMBOL (node
)
969 if (lto_symtab_symbol_p (node
)
970 && node
->next_sharing_asm_name
971 && !node
->previous_sharing_asm_name
)
972 lto_symtab_merge_symbols_1 (node
);
974 /* Resolve weakref aliases whose target are now in the compilation unit.
975 also re-populate the hash translating decls into symtab nodes*/
976 FOR_EACH_SYMBOL (node
)
978 cgraph_node
*cnode
, *cnode2
;
982 if (!node
->analyzed
&& node
->alias_target
)
984 symtab_node
*tgt
= symtab_node::get_for_asmname (node
->alias_target
);
985 gcc_assert (node
->weakref
);
987 node
->resolve_alias (tgt
, true);
989 /* If the symbol was preempted outside IR, see if we want to get rid
990 of the definition. */
992 && !DECL_EXTERNAL (node
->decl
)
993 && (node
->resolution
== LDPR_PREEMPTED_REG
994 || node
->resolution
== LDPR_RESOLVED_IR
995 || node
->resolution
== LDPR_RESOLVED_EXEC
996 || node
->resolution
== LDPR_RESOLVED_DYN
))
998 DECL_EXTERNAL (node
->decl
) = 1;
999 /* If alias to local symbol was preempted by external definition,
1000 we know it is not pointing to the local symbol. Remove it. */
1003 && !node
->transparent_alias
1004 && node
->get_alias_target ()->binds_to_current_def_p ())
1006 node
->alias
= false;
1007 node
->remove_all_references ();
1008 node
->definition
= false;
1009 node
->analyzed
= false;
1010 node
->cpp_implicit_alias
= false;
1012 else if (!node
->alias
1014 && node
->get_availability () <= AVAIL_INTERPOSABLE
)
1016 if ((cnode
= dyn_cast
<cgraph_node
*> (node
)) != NULL
)
1020 node
->analyzed
= node
->definition
= false;
1021 node
->remove_all_references ();
1026 if (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
1028 || cnode
->clone_of
->decl
!= cnode
->decl
)
1030 /* Builtins are not merged via decl merging. It is however
1031 possible that tree merging unified the declaration. We
1032 do not want duplicate entries in symbol table. */
1033 if (cnode
&& DECL_BUILT_IN (node
->decl
)
1034 && (cnode2
= cgraph_node::get (node
->decl
))
1036 lto_cgraph_replace_node (cnode2
, cnode
);
1038 /* The user defined assembler variables are also not unified by their
1039 symbol name (since it is irrelevant), but we need to unify symbol
1040 nodes if tree merging occurred. */
1041 if ((vnode
= dyn_cast
<varpool_node
*> (node
))
1042 && DECL_HARD_REGISTER (vnode
->decl
)
1043 && (node2
= symtab_node::get (vnode
->decl
))
1045 lto_varpool_replace_node (dyn_cast
<varpool_node
*> (node2
),
1049 /* Abstract functions may have duplicated cgraph nodes attached;
1051 else if (cnode
&& DECL_ABSTRACT_P (cnode
->decl
)
1052 && (cnode2
= cgraph_node::get (node
->decl
))
1056 node
->decl
->decl_with_vis
.symtab_node
= node
;
1062 /* Virtual tables may matter for code generation even if they are not
1063 directly refernced by the code because they may be used for devirtualizaiton.
1064 For this reason it is important to merge even virtual tables that have no
1065 associated symbol table entries. Without doing so we lose optimization
1066 oppurtunities by losing track of the vtable constructor.
1067 FIXME: we probably ought to introduce explicit symbol table entries for
1068 those before streaming. */
1071 lto_symtab_prevailing_virtual_decl (tree decl
)
1073 if (DECL_ABSTRACT_P (decl
))
1075 gcc_checking_assert (!type_in_anonymous_namespace_p (DECL_CONTEXT (decl
))
1076 && DECL_ASSEMBLER_NAME_SET_P (decl
));
1078 symtab_node
*n
= symtab_node::get_for_asmname
1079 (DECL_ASSEMBLER_NAME (decl
));
1080 while (n
&& ((!DECL_EXTERNAL (n
->decl
) && !TREE_PUBLIC (n
->decl
))
1081 || !DECL_VIRTUAL_P (n
->decl
)))
1082 n
= n
->next_sharing_asm_name
;
1085 /* Merge decl state in both directions, we may still end up using
1087 TREE_ADDRESSABLE (n
->decl
) |= TREE_ADDRESSABLE (decl
);
1088 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (n
->decl
);
1090 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1092 /* Merge decl state in both directions, we may still end up using
1094 DECL_POSSIBLY_INLINED (n
->decl
) |= DECL_POSSIBLY_INLINED (decl
);
1095 DECL_POSSIBLY_INLINED (decl
) |= DECL_POSSIBLY_INLINED (n
->decl
);
1097 lto_symtab_prevail_decl (n
->decl
, decl
);
1101 symtab_node::get_create (decl
);