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"
34 #include "lto-symtab.h"
35 #include "stringpool.h"
38 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
39 all edges and removing the old node. */
42 lto_cgraph_replace_node (struct cgraph_node
*node
,
43 struct cgraph_node
*prevailing_node
)
45 struct cgraph_edge
*e
, *next
;
48 if (symtab
->dump_file
)
50 fprintf (symtab
->dump_file
, "Replacing cgraph node %s by %s"
53 prevailing_node
->dump_name (),
54 IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
)
55 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->decl
)))));
58 /* Merge node flags. */
59 if (node
->force_output
)
60 prevailing_node
->mark_force_output ();
61 if (node
->forced_by_abi
)
62 prevailing_node
->forced_by_abi
= true;
63 if (node
->address_taken
)
65 gcc_assert (!prevailing_node
->global
.inlined_to
);
66 prevailing_node
->mark_address_taken ();
68 if (node
->definition
&& prevailing_node
->definition
69 && DECL_COMDAT (node
->decl
) && DECL_COMDAT (prevailing_node
->decl
))
70 prevailing_node
->merged_comdat
= true;
72 /* Redirect all incoming edges. */
74 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node
->decl
)),
75 TREE_TYPE (TREE_TYPE (node
->decl
)));
76 for (e
= node
->callers
; e
; e
= next
)
78 next
= e
->next_caller
;
79 e
->redirect_callee (prevailing_node
);
80 /* If there is a mismatch between the supposed callee return type and
81 the real one do not attempt to inline this function.
82 ??? We really need a way to match function signatures for ABI
83 compatibility and perform related promotions at inlining time. */
86 e
->inline_failed
= CIF_LTO_MISMATCHED_DECLARATIONS
;
87 e
->call_stmt_cannot_inline_p
= 1;
90 /* Redirect incomming references. */
91 prevailing_node
->clone_referring (node
);
93 /* Fix instrumentation references. */
94 if (node
->instrumented_version
)
96 gcc_assert (node
->instrumentation_clone
97 == prevailing_node
->instrumentation_clone
);
98 node
->instrumented_version
->instrumented_version
= prevailing_node
;
99 if (!prevailing_node
->instrumented_version
)
100 prevailing_node
->instrumented_version
= node
->instrumented_version
;
101 /* Need to reset node->instrumented_version to NULL,
102 otherwise node removal code would reset
103 node->instrumented_version->instrumented_version. */
104 node
->instrumented_version
= NULL
;
107 lto_free_function_in_decl_state_for_node (node
);
109 if (node
->decl
!= prevailing_node
->decl
)
110 node
->release_body ();
112 /* Finally remove the replaced node. */
116 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
117 all edges and removing the old node. */
120 lto_varpool_replace_node (varpool_node
*vnode
,
121 varpool_node
*prevailing_node
)
123 gcc_assert (!vnode
->definition
|| prevailing_node
->definition
);
124 gcc_assert (!vnode
->analyzed
|| prevailing_node
->analyzed
);
126 prevailing_node
->clone_referring (vnode
);
127 if (vnode
->force_output
)
128 prevailing_node
->force_output
= true;
129 if (vnode
->forced_by_abi
)
130 prevailing_node
->forced_by_abi
= true;
132 /* Be sure we can garbage collect the initializer. */
133 if (DECL_INITIAL (vnode
->decl
)
134 && vnode
->decl
!= prevailing_node
->decl
)
135 DECL_INITIAL (vnode
->decl
) = error_mark_node
;
137 /* Check and report ODR violations on virtual tables. */
138 if (DECL_VIRTUAL_P (vnode
->decl
) || DECL_VIRTUAL_P (prevailing_node
->decl
))
139 compare_virtual_tables (prevailing_node
, vnode
);
141 if (vnode
->tls_model
!= prevailing_node
->tls_model
)
145 /* Non-TLS and TLS never mix together. Also emulated model is not
146 compatible with anything else. */
147 if (prevailing_node
->tls_model
== TLS_MODEL_NONE
148 || prevailing_node
->tls_model
== TLS_MODEL_EMULATED
149 || vnode
->tls_model
== TLS_MODEL_NONE
150 || vnode
->tls_model
== TLS_MODEL_EMULATED
)
152 /* Linked is silently supporting transitions
153 GD -> IE, GD -> LE, LD -> LE, IE -> LE, LD -> IE.
154 Do the same transitions and error out on others. */
155 else if ((prevailing_node
->tls_model
== TLS_MODEL_REAL
156 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
157 && (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
158 || vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
159 prevailing_node
->tls_model
= vnode
->tls_model
;
160 else if ((vnode
->tls_model
== TLS_MODEL_REAL
161 || vnode
->tls_model
== TLS_MODEL_LOCAL_DYNAMIC
)
162 && (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
163 || prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
))
165 else if (prevailing_node
->tls_model
== TLS_MODEL_INITIAL_EXEC
166 && vnode
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
167 prevailing_node
->tls_model
= vnode
->tls_model
;
168 else if (vnode
->tls_model
== TLS_MODEL_INITIAL_EXEC
169 && prevailing_node
->tls_model
== TLS_MODEL_LOCAL_EXEC
)
175 error_at (DECL_SOURCE_LOCATION (vnode
->decl
),
176 "%qD is defined with tls model %s", vnode
->decl
, tls_model_names
[vnode
->tls_model
]);
177 inform (DECL_SOURCE_LOCATION (prevailing_node
->decl
),
178 "previously defined here as %s",
179 tls_model_names
[prevailing_node
->tls_model
]);
182 /* Finally remove the replaced node. */
186 /* Return non-zero if we want to output waring about T1 and T2.
187 Return value is a bitmask of reasons of violation:
188 Bit 0 indicates that types are not compatible.
189 Bit 1 indicates that types are not compatible because of C++ ODR rule.
190 If COMMON_OR_EXTERN is true, do not warn on size mismatches of arrays.
191 Bit 2 indicates that types are not ODR compatible
193 The interoperability rules are language specific. At present we do only
194 full checking for C++ ODR rule and for other languages we do basic check
195 that data structures are of same size and TBAA compatible. Our TBAA
196 implementation should be coarse enough so all valid type transitions
197 across different languages are allowed.
199 In partiucular we thus allow almost arbitrary type changes with
200 -fno-strict-aliasing which may be tough of as a feature rather than bug
201 as it allows to implement dodgy tricks in the language runtimes.
203 Naturally this code can be strenghtened significantly if we could track
204 down the language of origin. */
207 warn_type_compatibility_p (tree prevailing_type
, tree type
,
208 bool common_or_extern
)
211 bool odr_p
= odr_or_derived_type_p (prevailing_type
)
212 && odr_or_derived_type_p (type
);
214 if (prevailing_type
== type
)
217 /* C++ provide a robust way to check for type compatibility via the ODR
219 if (odr_p
&& !odr_types_equivalent_p (prevailing_type
, type
))
222 /* Function types needs special care, because types_compatible_p never
223 thinks prototype is compatible to non-prototype. */
224 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
226 if (TREE_CODE (type
) != TREE_CODE (prevailing_type
))
228 lev
|= warn_type_compatibility_p (TREE_TYPE (prevailing_type
),
229 TREE_TYPE (type
), false);
230 if (TREE_CODE (type
) == METHOD_TYPE
231 && TREE_CODE (prevailing_type
) == METHOD_TYPE
)
232 lev
|= warn_type_compatibility_p (TYPE_METHOD_BASETYPE (prevailing_type
),
233 TYPE_METHOD_BASETYPE (type
), false);
234 if (prototype_p (prevailing_type
) && prototype_p (type
)
235 && TYPE_ARG_TYPES (prevailing_type
) != TYPE_ARG_TYPES (type
))
238 for (parm1
= TYPE_ARG_TYPES (prevailing_type
),
239 parm2
= TYPE_ARG_TYPES (type
);
241 parm1
= TREE_CHAIN (parm1
),
242 parm2
= TREE_CHAIN (parm2
))
243 lev
|= warn_type_compatibility_p (TREE_VALUE (parm1
),
244 TREE_VALUE (parm2
), false);
246 lev
|= odr_p
? 3 : 1;
248 if (comp_type_attributes (prevailing_type
, type
) == 0)
253 /* Get complete type. */
254 prevailing_type
= TYPE_MAIN_VARIANT (prevailing_type
);
255 type
= TYPE_MAIN_VARIANT (type
);
257 /* We can not use types_compatible_p because we permit some changes
258 across types. For example unsigned size_t and "signed size_t" may be
259 compatible when merging C and Fortran types. */
260 if (COMPLETE_TYPE_P (prevailing_type
)
261 && COMPLETE_TYPE_P (type
)
262 /* While global declarations are never variadic, we can recurse here
263 for function parameter types. */
264 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
265 && TREE_CODE (TYPE_SIZE (prevailing_type
)) == INTEGER_CST
266 && !tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (prevailing_type
)))
268 /* As a special case do not warn about merging
272 here the first declaration is COMMON or EXTERN
273 and sizeof(a) == sizeof (int). */
274 if (!common_or_extern
275 || TREE_CODE (type
) != ARRAY_TYPE
276 || TYPE_SIZE (type
) != TYPE_SIZE (TREE_TYPE (type
)))
280 /* Verify TBAA compatibility. Take care of alias set 0 and the fact that
281 we make ptr_type_node to TBAA compatible with every other type. */
282 if (type_with_alias_set_p (type
) && type_with_alias_set_p (prevailing_type
))
284 alias_set_type set1
= get_alias_set (type
);
285 alias_set_type set2
= get_alias_set (prevailing_type
);
287 if (set1
&& set2
&& set1
!= set2
)
289 tree t1
= type
, t2
= prevailing_type
;
291 /* Alias sets of arrays with aliased components are the same as alias
292 sets of the inner types. */
293 while (TREE_CODE (t1
) == ARRAY_TYPE
294 && !TYPE_NONALIASED_COMPONENT (t1
)
295 && TREE_CODE (t2
) == ARRAY_TYPE
296 && !TYPE_NONALIASED_COMPONENT (t2
))
301 if ((!POINTER_TYPE_P (t1
) || !POINTER_TYPE_P (t2
))
302 || (set1
!= TYPE_ALIAS_SET (ptr_type_node
)
303 && set2
!= TYPE_ALIAS_SET (ptr_type_node
)))
311 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
312 Return false if the symbols are not fully compatible and a diagnostic
313 should be emitted. */
316 lto_symtab_merge (symtab_node
*prevailing
, symtab_node
*entry
)
318 tree prevailing_decl
= prevailing
->decl
;
319 tree decl
= entry
->decl
;
321 if (prevailing_decl
== decl
)
324 if (TREE_CODE (decl
) != TREE_CODE (prevailing_decl
))
327 /* Merge decl state in both directions, we may still end up using
329 TREE_ADDRESSABLE (prevailing_decl
) |= TREE_ADDRESSABLE (decl
);
330 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (prevailing_decl
);
332 /* The linker may ask us to combine two incompatible symbols.
333 Detect this case and notify the caller of required diagnostics. */
335 if (TREE_CODE (decl
) == FUNCTION_DECL
)
337 /* Merge decl state in both directions, we may still end up using
339 DECL_POSSIBLY_INLINED (prevailing_decl
) |= DECL_POSSIBLY_INLINED (decl
);
340 DECL_POSSIBLY_INLINED (decl
) |= DECL_POSSIBLY_INLINED (prevailing_decl
);
342 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
345 || DECL_EXTERNAL (decl
)))
351 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl
),
353 DECL_COMMON (decl
) || DECL_EXTERNAL (decl
)))
356 /* There is no point in comparing too many details of the decls here.
357 The type compatibility checks or the completing of types has properly
358 dealt with most issues. */
360 /* The following should all not invoke fatal errors as in non-LTO
361 mode the linker wouldn't complain either. Just emit warnings. */
363 /* Report a warning if user-specified alignments do not match. */
364 if ((DECL_USER_ALIGN (prevailing_decl
) && DECL_USER_ALIGN (decl
))
365 && DECL_ALIGN (prevailing_decl
) < DECL_ALIGN (decl
))
368 if (DECL_SIZE (decl
) && DECL_SIZE (prevailing_decl
)
369 && !tree_int_cst_equal (DECL_SIZE (decl
), DECL_SIZE (prevailing_decl
)))
371 if (!DECL_COMMON (decl
) && !DECL_EXTERNAL (decl
))
374 tree type
= TREE_TYPE (decl
);
376 /* For record type, check for array at the end of the structure. */
377 if (TREE_CODE (type
) == RECORD_TYPE
)
379 tree field
= TYPE_FIELDS (type
);
380 while (DECL_CHAIN (field
) != NULL_TREE
)
381 field
= DECL_CHAIN (field
);
383 return TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
;
385 /* As a special case do not warn about merging
389 here the first declaration is COMMON
390 and sizeof(a) == sizeof (int). */
391 else if (TREE_CODE (type
) == ARRAY_TYPE
)
392 return (TYPE_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (type
)));
398 /* Return true if the symtab entry E can be replaced by another symtab
402 lto_symtab_resolve_replaceable_p (symtab_node
*e
)
404 if (DECL_EXTERNAL (e
->decl
)
405 || DECL_COMDAT (e
->decl
)
406 || DECL_ONE_ONLY (e
->decl
)
407 || DECL_WEAK (e
->decl
))
410 if (TREE_CODE (e
->decl
) == VAR_DECL
)
411 return (DECL_COMMON (e
->decl
)
412 || (!flag_no_common
&& !DECL_INITIAL (e
->decl
)));
417 /* Return true, if the symbol E should be resolved by lto-symtab.
418 Those are all external symbols and all real symbols that are not static (we
419 handle renaming of static later in partitioning). */
422 lto_symtab_symbol_p (symtab_node
*e
)
424 if (!TREE_PUBLIC (e
->decl
) && !DECL_EXTERNAL (e
->decl
))
426 return e
->real_symbol_p ();
429 /* Return true if the symtab entry E can be the prevailing one. */
432 lto_symtab_resolve_can_prevail_p (symtab_node
*e
)
434 if (!lto_symtab_symbol_p (e
))
437 /* The C++ frontend ends up neither setting TREE_STATIC nor
438 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
439 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
440 if (DECL_EXTERNAL (e
->decl
))
443 return e
->definition
;
446 /* Resolve the symbol with the candidates in the chain *SLOT and store
447 their resolutions. */
450 lto_symtab_resolve_symbols (symtab_node
*first
)
453 symtab_node
*prevailing
= NULL
;
455 /* Always set e->node so that edges are updated to reflect decl merging. */
456 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
457 if (lto_symtab_symbol_p (e
)
458 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
459 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
460 || e
->resolution
== LDPR_PREVAILING_DEF
))
466 /* If the chain is already resolved there is nothing else to do. */
469 /* Assert it's the only one. */
470 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= e
->next_sharing_asm_name
)
471 if (lto_symtab_symbol_p (e
)
472 && (e
->resolution
== LDPR_PREVAILING_DEF_IRONLY
473 || e
->resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
474 || e
->resolution
== LDPR_PREVAILING_DEF
))
475 fatal_error (input_location
, "multiple prevailing defs for %qE",
476 DECL_NAME (prevailing
->decl
));
480 /* Find the single non-replaceable prevailing symbol and
481 diagnose ODR violations. */
482 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
484 if (!lto_symtab_resolve_can_prevail_p (e
))
487 /* If we have a non-replaceable definition it prevails. */
488 if (!lto_symtab_resolve_replaceable_p (e
))
492 error_at (DECL_SOURCE_LOCATION (e
->decl
),
493 "%qD has already been defined", e
->decl
);
494 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
495 "previously defined here");
503 /* Do a second round choosing one from the replaceable prevailing decls. */
504 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
506 if (!lto_symtab_resolve_can_prevail_p (e
))
509 /* Choose the first function that can prevail as prevailing. */
510 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
)
516 /* From variables that can prevail choose the largest one. */
518 || tree_int_cst_lt (DECL_SIZE (prevailing
->decl
),
520 /* When variables are equivalent try to chose one that has useful
521 DECL_INITIAL. This makes sense for keyed vtables that are
522 DECL_EXTERNAL but initialized. In units that do not need them
523 we replace the initializer by error_mark_node to conserve
526 We know that the vtable is keyed outside the LTO unit - otherwise
527 the keyed instance would prevail. We still can preserve useful
528 info in the initializer. */
529 || (DECL_SIZE (prevailing
->decl
) == DECL_SIZE (e
->decl
)
530 && (DECL_INITIAL (e
->decl
)
531 && DECL_INITIAL (e
->decl
) != error_mark_node
)
532 && (!DECL_INITIAL (prevailing
->decl
)
533 || DECL_INITIAL (prevailing
->decl
) == error_mark_node
)))
540 /* Decide if it is OK to merge DECL into PREVAILING.
541 Because we wrap most of uses of declarations in MEM_REF, we can tolerate
542 some differences but other code may inspect directly the DECL. */
545 lto_symtab_merge_p (tree prevailing
, tree decl
)
547 if (TREE_CODE (prevailing
) != TREE_CODE (decl
))
549 if (symtab
->dump_file
)
550 fprintf (symtab
->dump_file
, "Not merging decls; "
551 "TREE_CODE mismatch\n");
554 gcc_checking_assert (TREE_CHAIN (prevailing
) == TREE_CHAIN (decl
));
556 if (TREE_CODE (prevailing
) == FUNCTION_DECL
)
558 if (DECL_BUILT_IN (prevailing
) != DECL_BUILT_IN (decl
))
560 if (symtab
->dump_file
)
561 fprintf (symtab
->dump_file
, "Not merging decls; "
562 "DECL_BUILT_IN mismatch\n");
565 if (DECL_BUILT_IN (prevailing
)
566 && (DECL_BUILT_IN_CLASS (prevailing
) != DECL_BUILT_IN_CLASS (decl
)
567 || DECL_FUNCTION_CODE (prevailing
) != DECL_FUNCTION_CODE (decl
)))
569 if (symtab
->dump_file
)
570 fprintf (symtab
->dump_file
, "Not merging decls; "
571 "DECL_BUILT_IN_CLASS or CODE mismatch\n");
575 if (DECL_ATTRIBUTES (prevailing
) != DECL_ATTRIBUTES (decl
))
577 tree prev_attr
= lookup_attribute ("error", DECL_ATTRIBUTES (prevailing
));
578 tree attr
= lookup_attribute ("error", DECL_ATTRIBUTES (decl
));
579 if ((prev_attr
== NULL
) != (attr
== NULL
)
581 && TREE_VALUE (TREE_VALUE (prev_attr
))
582 != TREE_VALUE (TREE_VALUE (attr
))))
584 if (symtab
->dump_file
)
585 fprintf (symtab
->dump_file
, "Not merging decls; "
586 "error attribute mismatch\n");
590 prev_attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (prevailing
));
591 attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (decl
));
592 if ((prev_attr
== NULL
) != (attr
== NULL
)
594 && TREE_VALUE (TREE_VALUE (prev_attr
))
595 != TREE_VALUE (TREE_VALUE (attr
))))
597 if (symtab
->dump_file
)
598 fprintf (symtab
->dump_file
, "Not merging decls; "
599 "warning attribute mismatch\n");
606 /* Merge all decls in the symbol table chain to the prevailing decl and
607 issue diagnostics about type mismatches. If DIAGNOSED_P is true
608 do not issue further diagnostics.*/
611 lto_symtab_merge_decls_2 (symtab_node
*first
, bool diagnosed_p
)
613 symtab_node
*prevailing
;
615 vec
<tree
> mismatches
= vNULL
;
620 /* Nothing to do for a single entry. */
622 if (!prevailing
->next_sharing_asm_name
)
625 /* Try to merge each entry with the prevailing one. */
626 symtab_node
*last_prevailing
= prevailing
, *next
;
627 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= next
)
629 next
= e
->next_sharing_asm_name
;
631 /* Skip non-LTO symbols and symbols whose declaration we already
633 if (lto_symtab_prevailing_decl (e
->decl
) != e
->decl
634 || !lto_symtab_symbol_p (e
)
635 || e
->decl
== prevailing
->decl
)
638 if (!lto_symtab_merge (prevailing
, e
)
640 && !DECL_ARTIFICIAL (e
->decl
))
641 mismatches
.safe_push (e
->decl
);
643 symtab_node
*this_prevailing
;
644 for (this_prevailing
= prevailing
; ;
645 this_prevailing
= this_prevailing
->next_sharing_asm_name
)
647 if (this_prevailing
->decl
!= e
->decl
648 && lto_symtab_merge_p (this_prevailing
->decl
, e
->decl
))
650 if (this_prevailing
== last_prevailing
)
652 this_prevailing
= NULL
;
658 lto_symtab_prevail_decl (this_prevailing
->decl
, e
->decl
);
659 /* Maintain LRU list: relink the new prevaililng symbol
660 just after previaling node in the chain and update last_prevailing.
661 Since the number of possible declarations of a given symbol is
662 small, this should be faster than building a hash. */
663 else if (e
== prevailing
->next_sharing_asm_name
)
667 if (e
->next_sharing_asm_name
)
668 e
->next_sharing_asm_name
->previous_sharing_asm_name
669 = e
->previous_sharing_asm_name
;
670 e
->previous_sharing_asm_name
->next_sharing_asm_name
671 = e
->next_sharing_asm_name
;
672 e
->previous_sharing_asm_name
= prevailing
;
673 e
->next_sharing_asm_name
= prevailing
->next_sharing_asm_name
;
674 prevailing
->next_sharing_asm_name
->previous_sharing_asm_name
= e
;
675 prevailing
->next_sharing_asm_name
= e
;
676 if (last_prevailing
== prevailing
)
680 if (mismatches
.is_empty ())
683 /* Diagnose all mismatched re-declarations. */
684 FOR_EACH_VEC_ELT (mismatches
, i
, decl
)
686 /* Do not diagnose two built-in declarations, there is no useful
687 location in that case. It also happens for AVR if two built-ins
688 use the same asm name because their libgcc assembler code is the
689 same, see PR78562. */
690 if (DECL_IS_BUILTIN (prevailing
->decl
)
691 && DECL_IS_BUILTIN (decl
))
694 int level
= warn_type_compatibility_p (TREE_TYPE (prevailing
->decl
),
701 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
703 "%qD violates the C++ One Definition Rule ",
705 if (!diag
&& (level
& 1))
706 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
707 OPT_Wlto_type_mismatch
,
708 "type of %qD does not match original "
709 "declaration", decl
);
712 warn_types_mismatch (TREE_TYPE (prevailing
->decl
),
714 DECL_SOURCE_LOCATION (prevailing
->decl
),
715 DECL_SOURCE_LOCATION (decl
));
717 && !TREE_READONLY (prevailing
->decl
))
722 else if ((DECL_USER_ALIGN (prevailing
->decl
)
723 && DECL_USER_ALIGN (decl
))
724 && DECL_ALIGN (prevailing
->decl
) < DECL_ALIGN (decl
))
726 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
727 OPT_Wlto_type_mismatch
,
728 "alignment of %qD is bigger than "
729 "original declaration", decl
);
732 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
733 OPT_Wlto_type_mismatch
,
734 "size of %qD differ from the size of "
735 "original declaration", decl
);
738 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
739 "%qD was previously declared here", prevailing
->decl
);
741 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
742 "code may be misoptimized unless "
743 "-fno-strict-aliasing is used");
745 mismatches
.release ();
748 /* Helper to process the decl chain for the symbol table entry *SLOT. */
751 lto_symtab_merge_decls_1 (symtab_node
*first
)
754 symtab_node
*prevailing
;
755 bool diagnosed_p
= false;
757 if (symtab
->dump_file
)
759 fprintf (symtab
->dump_file
, "Merging nodes for %s. Candidates:\n",
761 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
762 if (TREE_PUBLIC (e
->decl
))
763 e
->dump (symtab
->dump_file
);
766 /* Compute the symbol resolutions. This is a no-op when using the
767 linker plugin and resolution was decided by the linker. */
768 prevailing
= lto_symtab_resolve_symbols (first
);
770 /* If there's not a prevailing symbol yet it's an external reference.
771 Happens a lot during ltrans. Choose the first symbol with a
772 cgraph or a varpool node. */
775 for (prevailing
= first
;
776 prevailing
; prevailing
= prevailing
->next_sharing_asm_name
)
777 if (lto_symtab_symbol_p (prevailing
))
781 /* For variables chose with a priority variant with vnode
782 attached (i.e. from unit where external declaration of
783 variable is actually used).
784 When there are multiple variants, chose one with size.
785 This is needed for C++ typeinfos, for example in
786 lto/20081204-1 there are typeifos in both units, just
787 one of them do have size. */
788 if (TREE_CODE (prevailing
->decl
) == VAR_DECL
)
790 for (e
= prevailing
->next_sharing_asm_name
;
791 e
; e
= e
->next_sharing_asm_name
)
792 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing
->decl
))
793 && COMPLETE_TYPE_P (TREE_TYPE (e
->decl
))
794 && lto_symtab_symbol_p (e
))
797 /* For functions prefer the non-builtin if one is available. */
798 else if (TREE_CODE (prevailing
->decl
) == FUNCTION_DECL
)
800 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
801 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
802 && !DECL_BUILT_IN (e
->decl
)
803 && lto_symtab_symbol_p (e
))
811 symtab
->symtab_prevail_in_asm_name_hash (prevailing
);
813 /* Diagnose mismatched objects. */
814 for (e
= prevailing
->next_sharing_asm_name
;
815 e
; e
= e
->next_sharing_asm_name
)
817 if (TREE_CODE (prevailing
->decl
)
818 == TREE_CODE (e
->decl
))
820 if (!lto_symtab_symbol_p (e
))
823 switch (TREE_CODE (prevailing
->decl
))
826 gcc_assert (TREE_CODE (e
->decl
) == FUNCTION_DECL
);
827 error_at (DECL_SOURCE_LOCATION (e
->decl
),
828 "variable %qD redeclared as function",
833 gcc_assert (TREE_CODE (e
->decl
) == VAR_DECL
);
834 error_at (DECL_SOURCE_LOCATION (e
->decl
),
835 "function %qD redeclared as variable",
846 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
847 "previously declared here");
849 /* Merge the chain to the single prevailing decl and diagnose
851 lto_symtab_merge_decls_2 (prevailing
, diagnosed_p
);
853 if (symtab
->dump_file
)
855 fprintf (symtab
->dump_file
, "After resolution:\n");
856 for (e
= prevailing
; e
; e
= e
->next_sharing_asm_name
)
857 e
->dump (symtab
->dump_file
);
861 /* Resolve and merge all symbol table chains to a prevailing decl. */
864 lto_symtab_merge_decls (void)
868 /* Populate assembler name hash. */
869 symtab
->symtab_initialize_asm_name_hash ();
871 FOR_EACH_SYMBOL (node
)
872 if (!node
->previous_sharing_asm_name
873 && node
->next_sharing_asm_name
)
874 lto_symtab_merge_decls_1 (node
);
877 /* Helper to process the decl chain for the symbol table entry *SLOT. */
880 lto_symtab_merge_symbols_1 (symtab_node
*prevailing
)
885 prevailing
->decl
->decl_with_vis
.symtab_node
= prevailing
;
887 /* Replace the cgraph node of each entry with the prevailing one. */
888 for (e
= prevailing
->next_sharing_asm_name
; e
;
891 next
= e
->next_sharing_asm_name
;
893 if (!lto_symtab_symbol_p (e
))
895 cgraph_node
*ce
= dyn_cast
<cgraph_node
*> (e
);
896 symtab_node
*to
= symtab_node::get (lto_symtab_prevailing_decl (e
->decl
));
898 /* No matter how we are going to deal with resolution, we will ultimately
899 use prevailing definition. */
901 ipa_merge_profiles (dyn_cast
<cgraph_node
*> (prevailing
),
902 dyn_cast
<cgraph_node
*> (e
));
904 /* If we decided to replace the node by TO, do it. */
908 lto_cgraph_replace_node (ce
, dyn_cast
<cgraph_node
*> (to
));
909 else if (varpool_node
*ve
= dyn_cast
<varpool_node
*> (e
))
910 lto_varpool_replace_node (ve
, dyn_cast
<varpool_node
*> (to
));
912 /* Watch out for duplicated symbols for a given declaration. */
913 else if (!e
->transparent_alias
914 || !e
->definition
|| e
->get_alias_target () != to
)
916 /* We got a new declaration we do not want to merge. In this case
917 get rid of the existing definition and create a transparent
921 lto_free_function_in_decl_state_for_node (ce
);
925 symtab
->call_cgraph_removal_hooks (ce
);
929 DECL_INITIAL (e
->decl
) = error_mark_node
;
930 if (e
->lto_file_data
)
932 lto_free_function_in_decl_state_for_node (e
);
933 e
->lto_file_data
= NULL
;
935 symtab
->call_varpool_removal_hooks (dyn_cast
<varpool_node
*> (e
));
937 e
->remove_all_references ();
938 e
->analyzed
= e
->body_removed
= false;
939 e
->resolve_alias (prevailing
, true);
940 gcc_assert (e
!= prevailing
);
947 /* Merge cgraph nodes according to the symbol merging done by
948 lto_symtab_merge_decls. */
951 lto_symtab_merge_symbols (void)
957 symtab
->symtab_initialize_asm_name_hash ();
959 /* Do the actual merging.
960 At this point we invalidate hash translating decls into symtab nodes
961 because after removing one of duplicate decls the hash is not correcly
962 updated to the ohter dupliate. */
963 FOR_EACH_SYMBOL (node
)
964 if (lto_symtab_symbol_p (node
)
965 && node
->next_sharing_asm_name
966 && !node
->previous_sharing_asm_name
)
967 lto_symtab_merge_symbols_1 (node
);
969 /* Resolve weakref aliases whose target are now in the compilation unit.
970 also re-populate the hash translating decls into symtab nodes*/
971 FOR_EACH_SYMBOL (node
)
973 cgraph_node
*cnode
, *cnode2
;
977 if (!node
->analyzed
&& node
->alias_target
)
979 symtab_node
*tgt
= symtab_node::get_for_asmname (node
->alias_target
);
980 gcc_assert (node
->weakref
);
982 node
->resolve_alias (tgt
, true);
984 /* If the symbol was preempted outside IR, see if we want to get rid
985 of the definition. */
987 && !DECL_EXTERNAL (node
->decl
)
988 && (node
->resolution
== LDPR_PREEMPTED_REG
989 || node
->resolution
== LDPR_RESOLVED_IR
990 || node
->resolution
== LDPR_RESOLVED_EXEC
991 || node
->resolution
== LDPR_RESOLVED_DYN
))
993 DECL_EXTERNAL (node
->decl
) = 1;
994 /* If alias to local symbol was preempted by external definition,
995 we know it is not pointing to the local symbol. Remove it. */
998 && !node
->transparent_alias
999 && node
->get_alias_target ()->binds_to_current_def_p ())
1001 node
->alias
= false;
1002 node
->remove_all_references ();
1003 node
->definition
= false;
1004 node
->analyzed
= false;
1005 node
->cpp_implicit_alias
= false;
1007 else if (!node
->alias
1009 && node
->get_availability () <= AVAIL_INTERPOSABLE
)
1011 if ((cnode
= dyn_cast
<cgraph_node
*> (node
)) != NULL
)
1015 node
->analyzed
= node
->definition
= false;
1016 node
->remove_all_references ();
1021 if (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
1023 || cnode
->clone_of
->decl
!= cnode
->decl
)
1025 /* Builtins are not merged via decl merging. It is however
1026 possible that tree merging unified the declaration. We
1027 do not want duplicate entries in symbol table. */
1028 if (cnode
&& DECL_BUILT_IN (node
->decl
)
1029 && (cnode2
= cgraph_node::get (node
->decl
))
1031 lto_cgraph_replace_node (cnode2
, cnode
);
1033 /* The user defined assembler variables are also not unified by their
1034 symbol name (since it is irrelevant), but we need to unify symbol
1035 nodes if tree merging occurred. */
1036 if ((vnode
= dyn_cast
<varpool_node
*> (node
))
1037 && DECL_HARD_REGISTER (vnode
->decl
)
1038 && (node2
= symtab_node::get (vnode
->decl
))
1040 lto_varpool_replace_node (dyn_cast
<varpool_node
*> (node2
),
1044 /* Abstract functions may have duplicated cgraph nodes attached;
1046 else if (cnode
&& DECL_ABSTRACT_P (cnode
->decl
)
1047 && (cnode2
= cgraph_node::get (node
->decl
))
1051 node
->decl
->decl_with_vis
.symtab_node
= node
;
1057 /* Virtual tables may matter for code generation even if they are not
1058 directly refernced by the code because they may be used for devirtualizaiton.
1059 For this reason it is important to merge even virtual tables that have no
1060 associated symbol table entries. Without doing so we lose optimization
1061 oppurtunities by losing track of the vtable constructor.
1062 FIXME: we probably ought to introduce explicit symbol table entries for
1063 those before streaming. */
1066 lto_symtab_prevailing_virtual_decl (tree decl
)
1068 if (DECL_ABSTRACT_P (decl
))
1070 gcc_checking_assert (!type_in_anonymous_namespace_p (DECL_CONTEXT (decl
))
1071 && DECL_ASSEMBLER_NAME_SET_P (decl
));
1073 symtab_node
*n
= symtab_node::get_for_asmname
1074 (DECL_ASSEMBLER_NAME (decl
));
1075 while (n
&& ((!DECL_EXTERNAL (n
->decl
) && !TREE_PUBLIC (n
->decl
))
1076 || !DECL_VIRTUAL_P (n
->decl
)))
1077 n
= n
->next_sharing_asm_name
;
1080 /* Merge decl state in both directions, we may still end up using
1082 TREE_ADDRESSABLE (n
->decl
) |= TREE_ADDRESSABLE (decl
);
1083 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (n
->decl
);
1085 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1087 /* Merge decl state in both directions, we may still end up using
1089 DECL_POSSIBLY_INLINED (n
->decl
) |= DECL_POSSIBLY_INLINED (decl
);
1090 DECL_POSSIBLY_INLINED (decl
) |= DECL_POSSIBLY_INLINED (n
->decl
);
1092 lto_symtab_prevail_decl (n
->decl
, decl
);
1096 symtab_node::get_create (decl
);