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
288 && (!POINTER_TYPE_P (type
) || !POINTER_TYPE_P (prevailing_type
)
289 || (set1
!= TYPE_ALIAS_SET (ptr_type_node
)
290 && 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 for (e
= prevailing
->next_sharing_asm_name
; 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
))
461 fatal_error (input_location
, "multiple prevailing defs for %qE",
462 DECL_NAME (prevailing
->decl
));
466 /* Find the single non-replaceable prevailing symbol and
467 diagnose ODR violations. */
468 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
470 if (!lto_symtab_resolve_can_prevail_p (e
))
473 /* If we have a non-replaceable definition it prevails. */
474 if (!lto_symtab_resolve_replaceable_p (e
))
478 error_at (DECL_SOURCE_LOCATION (e
->decl
),
479 "%qD has already been defined", e
->decl
);
480 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
481 "previously defined here");
489 /* Do a second round choosing one from the replaceable prevailing decls. */
490 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
492 if (!lto_symtab_resolve_can_prevail_p (e
))
495 /* Choose the first function that can prevail as prevailing. */
496 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
)
502 /* From variables that can prevail choose the largest one. */
504 || tree_int_cst_lt (DECL_SIZE (prevailing
->decl
),
506 /* When variables are equivalent try to chose one that has useful
507 DECL_INITIAL. This makes sense for keyed vtables that are
508 DECL_EXTERNAL but initialized. In units that do not need them
509 we replace the initializer by error_mark_node to conserve
512 We know that the vtable is keyed outside the LTO unit - otherwise
513 the keyed instance would prevail. We still can preserve useful
514 info in the initializer. */
515 || (DECL_SIZE (prevailing
->decl
) == DECL_SIZE (e
->decl
)
516 && (DECL_INITIAL (e
->decl
)
517 && DECL_INITIAL (e
->decl
) != error_mark_node
)
518 && (!DECL_INITIAL (prevailing
->decl
)
519 || DECL_INITIAL (prevailing
->decl
) == error_mark_node
)))
526 /* Decide if it is OK to merge DECL into PREVAILING.
527 Because we wrap most of uses of declarations in MEM_REF, we can tolerate
528 some differences but other code may inspect directly the DECL. */
531 lto_symtab_merge_p (tree prevailing
, tree decl
)
533 if (TREE_CODE (prevailing
) != TREE_CODE (decl
))
535 if (symtab
->dump_file
)
536 fprintf (symtab
->dump_file
, "Not merging decls; "
537 "TREE_CODE mismatch\n");
540 gcc_checking_assert (TREE_CHAIN (prevailing
) == TREE_CHAIN (decl
));
542 if (TREE_CODE (prevailing
) == FUNCTION_DECL
)
544 if (DECL_BUILT_IN (prevailing
) != DECL_BUILT_IN (decl
))
546 if (symtab
->dump_file
)
547 fprintf (symtab
->dump_file
, "Not merging decls; "
548 "DECL_BUILT_IN mismatch\n");
551 if (DECL_BUILT_IN (prevailing
)
552 && (DECL_BUILT_IN_CLASS (prevailing
) != DECL_BUILT_IN_CLASS (decl
)
553 || DECL_FUNCTION_CODE (prevailing
) != DECL_FUNCTION_CODE (decl
)))
555 if (symtab
->dump_file
)
556 fprintf (symtab
->dump_file
, "Not merging decls; "
557 "DECL_BUILT_IN_CLASS or CODE mismatch\n");
561 if (DECL_ATTRIBUTES (prevailing
) != DECL_ATTRIBUTES (decl
))
563 tree prev_attr
= lookup_attribute ("error", DECL_ATTRIBUTES (prevailing
));
564 tree attr
= lookup_attribute ("error", DECL_ATTRIBUTES (decl
));
565 if ((prev_attr
== NULL
) != (attr
== NULL
)
567 && TREE_VALUE (TREE_VALUE (prev_attr
))
568 != TREE_VALUE (TREE_VALUE (attr
))))
570 if (symtab
->dump_file
)
571 fprintf (symtab
->dump_file
, "Not merging decls; "
572 "error attribute mismatch\n");
576 prev_attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (prevailing
));
577 attr
= lookup_attribute ("warning", DECL_ATTRIBUTES (decl
));
578 if ((prev_attr
== NULL
) != (attr
== NULL
)
580 && TREE_VALUE (TREE_VALUE (prev_attr
))
581 != TREE_VALUE (TREE_VALUE (attr
))))
583 if (symtab
->dump_file
)
584 fprintf (symtab
->dump_file
, "Not merging decls; "
585 "warning attribute mismatch\n");
592 /* Merge all decls in the symbol table chain to the prevailing decl and
593 issue diagnostics about type mismatches. If DIAGNOSED_P is true
594 do not issue further diagnostics.*/
597 lto_symtab_merge_decls_2 (symtab_node
*first
, bool diagnosed_p
)
599 symtab_node
*prevailing
;
601 vec
<tree
> mismatches
= vNULL
;
606 /* Nothing to do for a single entry. */
608 if (!prevailing
->next_sharing_asm_name
)
611 /* Try to merge each entry with the prevailing one. */
612 symtab_node
*last_prevailing
= prevailing
, *next
;
613 for (e
= prevailing
->next_sharing_asm_name
; e
; e
= next
)
615 next
= e
->next_sharing_asm_name
;
617 /* Skip non-LTO symbols and symbols whose declaration we already
619 if (lto_symtab_prevailing_decl (e
->decl
) != e
->decl
620 || !lto_symtab_symbol_p (e
)
621 || e
->decl
== prevailing
->decl
)
624 if (!lto_symtab_merge (prevailing
, e
)
626 && !DECL_ARTIFICIAL (e
->decl
))
627 mismatches
.safe_push (e
->decl
);
629 symtab_node
*this_prevailing
;
630 for (this_prevailing
= prevailing
; ;
631 this_prevailing
= this_prevailing
->next_sharing_asm_name
)
633 if (this_prevailing
->decl
!= e
->decl
634 && lto_symtab_merge_p (this_prevailing
->decl
, e
->decl
))
636 if (this_prevailing
== last_prevailing
)
638 this_prevailing
= NULL
;
644 lto_symtab_prevail_decl (this_prevailing
->decl
, e
->decl
);
645 /* Maintain LRU list: relink the new prevaililng symbol
646 just after previaling node in the chain and update last_prevailing.
647 Since the number of possible declarations of a given symbol is
648 small, this should be faster than building a hash. */
649 else if (e
== prevailing
->next_sharing_asm_name
)
653 if (e
->next_sharing_asm_name
)
654 e
->next_sharing_asm_name
->previous_sharing_asm_name
655 = e
->previous_sharing_asm_name
;
656 e
->previous_sharing_asm_name
->next_sharing_asm_name
657 = e
->next_sharing_asm_name
;
658 e
->previous_sharing_asm_name
= prevailing
;
659 e
->next_sharing_asm_name
= prevailing
->next_sharing_asm_name
;
660 prevailing
->next_sharing_asm_name
->previous_sharing_asm_name
= e
;
661 prevailing
->next_sharing_asm_name
= e
;
662 if (last_prevailing
== prevailing
)
666 if (mismatches
.is_empty ())
669 /* Diagnose all mismatched re-declarations. */
670 FOR_EACH_VEC_ELT (mismatches
, i
, decl
)
672 /* Do not diagnose two built-in declarations, there is no useful
673 location in that case. It also happens for AVR if two built-ins
674 use the same asm name because their libgcc assembler code is the
675 same, see PR78562. */
676 if (DECL_IS_BUILTIN (prevailing
->decl
)
677 && DECL_IS_BUILTIN (decl
))
680 int level
= warn_type_compatibility_p (TREE_TYPE (prevailing
->decl
),
687 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
689 "%qD violates the C++ One Definition Rule ",
691 if (!diag
&& (level
& 1))
692 diag
= warning_at (DECL_SOURCE_LOCATION (decl
),
693 OPT_Wlto_type_mismatch
,
694 "type of %qD does not match original "
695 "declaration", decl
);
698 warn_types_mismatch (TREE_TYPE (prevailing
->decl
),
700 DECL_SOURCE_LOCATION (prevailing
->decl
),
701 DECL_SOURCE_LOCATION (decl
));
703 && !TREE_READONLY (prevailing
->decl
))
708 else if ((DECL_USER_ALIGN (prevailing
->decl
)
709 && DECL_USER_ALIGN (decl
))
710 && DECL_ALIGN (prevailing
->decl
) < DECL_ALIGN (decl
))
712 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
713 OPT_Wlto_type_mismatch
,
714 "alignment of %qD is bigger than "
715 "original declaration", decl
);
718 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
),
719 OPT_Wlto_type_mismatch
,
720 "size of %qD differ from the size of "
721 "original declaration", decl
);
724 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
725 "%qD was previously declared here", prevailing
->decl
);
727 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
728 "code may be misoptimized unless "
729 "-fno-strict-aliasing is used");
731 mismatches
.release ();
734 /* Helper to process the decl chain for the symbol table entry *SLOT. */
737 lto_symtab_merge_decls_1 (symtab_node
*first
)
740 symtab_node
*prevailing
;
741 bool diagnosed_p
= false;
743 if (symtab
->dump_file
)
745 fprintf (symtab
->dump_file
, "Merging nodes for %s. Candidates:\n",
747 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
748 if (TREE_PUBLIC (e
->decl
))
749 e
->dump (symtab
->dump_file
);
752 /* Compute the symbol resolutions. This is a no-op when using the
753 linker plugin and resolution was decided by the linker. */
754 prevailing
= lto_symtab_resolve_symbols (first
);
756 /* If there's not a prevailing symbol yet it's an external reference.
757 Happens a lot during ltrans. Choose the first symbol with a
758 cgraph or a varpool node. */
761 for (prevailing
= first
;
762 prevailing
; prevailing
= prevailing
->next_sharing_asm_name
)
763 if (lto_symtab_symbol_p (prevailing
))
767 /* For variables chose with a priority variant with vnode
768 attached (i.e. from unit where external declaration of
769 variable is actually used).
770 When there are multiple variants, chose one with size.
771 This is needed for C++ typeinfos, for example in
772 lto/20081204-1 there are typeifos in both units, just
773 one of them do have size. */
774 if (TREE_CODE (prevailing
->decl
) == VAR_DECL
)
776 for (e
= prevailing
->next_sharing_asm_name
;
777 e
; e
= e
->next_sharing_asm_name
)
778 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing
->decl
))
779 && COMPLETE_TYPE_P (TREE_TYPE (e
->decl
))
780 && lto_symtab_symbol_p (e
))
783 /* For functions prefer the non-builtin if one is available. */
784 else if (TREE_CODE (prevailing
->decl
) == FUNCTION_DECL
)
786 for (e
= first
; e
; e
= e
->next_sharing_asm_name
)
787 if (TREE_CODE (e
->decl
) == FUNCTION_DECL
788 && !DECL_BUILT_IN (e
->decl
)
789 && lto_symtab_symbol_p (e
))
797 symtab
->symtab_prevail_in_asm_name_hash (prevailing
);
799 /* Diagnose mismatched objects. */
800 for (e
= prevailing
->next_sharing_asm_name
;
801 e
; e
= e
->next_sharing_asm_name
)
803 if (TREE_CODE (prevailing
->decl
)
804 == TREE_CODE (e
->decl
))
806 if (!lto_symtab_symbol_p (e
))
809 switch (TREE_CODE (prevailing
->decl
))
812 gcc_assert (TREE_CODE (e
->decl
) == FUNCTION_DECL
);
813 error_at (DECL_SOURCE_LOCATION (e
->decl
),
814 "variable %qD redeclared as function",
819 gcc_assert (TREE_CODE (e
->decl
) == VAR_DECL
);
820 error_at (DECL_SOURCE_LOCATION (e
->decl
),
821 "function %qD redeclared as variable",
832 inform (DECL_SOURCE_LOCATION (prevailing
->decl
),
833 "previously declared here");
835 /* Merge the chain to the single prevailing decl and diagnose
837 lto_symtab_merge_decls_2 (prevailing
, diagnosed_p
);
839 if (symtab
->dump_file
)
841 fprintf (symtab
->dump_file
, "After resolution:\n");
842 for (e
= prevailing
; e
; e
= e
->next_sharing_asm_name
)
843 e
->dump (symtab
->dump_file
);
847 /* Resolve and merge all symbol table chains to a prevailing decl. */
850 lto_symtab_merge_decls (void)
854 /* Populate assembler name hash. */
855 symtab
->symtab_initialize_asm_name_hash ();
857 FOR_EACH_SYMBOL (node
)
858 if (!node
->previous_sharing_asm_name
859 && node
->next_sharing_asm_name
)
860 lto_symtab_merge_decls_1 (node
);
863 /* Helper to process the decl chain for the symbol table entry *SLOT. */
866 lto_symtab_merge_symbols_1 (symtab_node
*prevailing
)
871 prevailing
->decl
->decl_with_vis
.symtab_node
= prevailing
;
873 /* Replace the cgraph node of each entry with the prevailing one. */
874 for (e
= prevailing
->next_sharing_asm_name
; e
;
877 next
= e
->next_sharing_asm_name
;
879 if (!lto_symtab_symbol_p (e
))
881 cgraph_node
*ce
= dyn_cast
<cgraph_node
*> (e
);
882 symtab_node
*to
= symtab_node::get (lto_symtab_prevailing_decl (e
->decl
));
884 /* No matter how we are going to deal with resolution, we will ultimately
885 use prevailing definition. */
887 ipa_merge_profiles (dyn_cast
<cgraph_node
*> (prevailing
),
888 dyn_cast
<cgraph_node
*> (e
));
890 /* If we decided to replace the node by TO, do it. */
894 lto_cgraph_replace_node (ce
, dyn_cast
<cgraph_node
*> (to
));
895 else if (varpool_node
*ve
= dyn_cast
<varpool_node
*> (e
))
896 lto_varpool_replace_node (ve
, dyn_cast
<varpool_node
*> (to
));
898 /* Watch out for duplicated symbols for a given declaration. */
899 else if (!e
->transparent_alias
900 || !e
->definition
|| e
->get_alias_target () != to
)
902 /* We got a new declaration we do not want to merge. In this case
903 get rid of the existing definition and create a transparent
907 lto_free_function_in_decl_state_for_node (ce
);
911 symtab
->call_cgraph_removal_hooks (ce
);
915 DECL_INITIAL (e
->decl
) = error_mark_node
;
916 if (e
->lto_file_data
)
918 lto_free_function_in_decl_state_for_node (e
);
919 e
->lto_file_data
= NULL
;
921 symtab
->call_varpool_removal_hooks (dyn_cast
<varpool_node
*> (e
));
923 e
->remove_all_references ();
924 e
->analyzed
= e
->body_removed
= false;
925 e
->resolve_alias (prevailing
, true);
926 gcc_assert (e
!= prevailing
);
933 /* Merge cgraph nodes according to the symbol merging done by
934 lto_symtab_merge_decls. */
937 lto_symtab_merge_symbols (void)
943 symtab
->symtab_initialize_asm_name_hash ();
945 /* Do the actual merging.
946 At this point we invalidate hash translating decls into symtab nodes
947 because after removing one of duplicate decls the hash is not correcly
948 updated to the ohter dupliate. */
949 FOR_EACH_SYMBOL (node
)
950 if (lto_symtab_symbol_p (node
)
951 && node
->next_sharing_asm_name
952 && !node
->previous_sharing_asm_name
)
953 lto_symtab_merge_symbols_1 (node
);
955 /* Resolve weakref aliases whose target are now in the compilation unit.
956 also re-populate the hash translating decls into symtab nodes*/
957 FOR_EACH_SYMBOL (node
)
959 cgraph_node
*cnode
, *cnode2
;
963 if (!node
->analyzed
&& node
->alias_target
)
965 symtab_node
*tgt
= symtab_node::get_for_asmname (node
->alias_target
);
966 gcc_assert (node
->weakref
);
968 node
->resolve_alias (tgt
, true);
970 /* If the symbol was preempted outside IR, see if we want to get rid
971 of the definition. */
973 && !DECL_EXTERNAL (node
->decl
)
974 && (node
->resolution
== LDPR_PREEMPTED_REG
975 || node
->resolution
== LDPR_RESOLVED_IR
976 || node
->resolution
== LDPR_RESOLVED_EXEC
977 || node
->resolution
== LDPR_RESOLVED_DYN
))
979 DECL_EXTERNAL (node
->decl
) = 1;
980 /* If alias to local symbol was preempted by external definition,
981 we know it is not pointing to the local symbol. Remove it. */
984 && !node
->transparent_alias
985 && node
->get_alias_target ()->binds_to_current_def_p ())
988 node
->remove_all_references ();
989 node
->definition
= false;
990 node
->analyzed
= false;
991 node
->cpp_implicit_alias
= false;
993 else if (!node
->alias
995 && node
->get_availability () <= AVAIL_INTERPOSABLE
)
997 if ((cnode
= dyn_cast
<cgraph_node
*> (node
)) != NULL
)
1001 node
->analyzed
= node
->definition
= false;
1002 node
->remove_all_references ();
1007 if (!(cnode
= dyn_cast
<cgraph_node
*> (node
))
1009 || cnode
->clone_of
->decl
!= cnode
->decl
)
1011 /* Builtins are not merged via decl merging. It is however
1012 possible that tree merging unified the declaration. We
1013 do not want duplicate entries in symbol table. */
1014 if (cnode
&& DECL_BUILT_IN (node
->decl
)
1015 && (cnode2
= cgraph_node::get (node
->decl
))
1017 lto_cgraph_replace_node (cnode2
, cnode
);
1019 /* The user defined assembler variables are also not unified by their
1020 symbol name (since it is irrelevant), but we need to unify symbol
1021 nodes if tree merging occurred. */
1022 if ((vnode
= dyn_cast
<varpool_node
*> (node
))
1023 && DECL_HARD_REGISTER (vnode
->decl
)
1024 && (node2
= symtab_node::get (vnode
->decl
))
1026 lto_varpool_replace_node (dyn_cast
<varpool_node
*> (node2
),
1030 /* Abstract functions may have duplicated cgraph nodes attached;
1032 else if (cnode
&& DECL_ABSTRACT_P (cnode
->decl
)
1033 && (cnode2
= cgraph_node::get (node
->decl
))
1037 node
->decl
->decl_with_vis
.symtab_node
= node
;
1043 /* Virtual tables may matter for code generation even if they are not
1044 directly refernced by the code because they may be used for devirtualizaiton.
1045 For this reason it is important to merge even virtual tables that have no
1046 associated symbol table entries. Without doing so we lose optimization
1047 oppurtunities by losing track of the vtable constructor.
1048 FIXME: we probably ought to introduce explicit symbol table entries for
1049 those before streaming. */
1052 lto_symtab_prevailing_virtual_decl (tree decl
)
1054 if (DECL_ABSTRACT_P (decl
))
1056 gcc_checking_assert (!type_in_anonymous_namespace_p (DECL_CONTEXT (decl
))
1057 && DECL_ASSEMBLER_NAME_SET_P (decl
));
1059 symtab_node
*n
= symtab_node::get_for_asmname
1060 (DECL_ASSEMBLER_NAME (decl
));
1061 while (n
&& ((!DECL_EXTERNAL (n
->decl
) && !TREE_PUBLIC (n
->decl
))
1062 || !DECL_VIRTUAL_P (n
->decl
)))
1063 n
= n
->next_sharing_asm_name
;
1066 /* Merge decl state in both directions, we may still end up using
1068 TREE_ADDRESSABLE (n
->decl
) |= TREE_ADDRESSABLE (decl
);
1069 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (n
->decl
);
1071 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1073 /* Merge decl state in both directions, we may still end up using
1075 DECL_POSSIBLY_INLINED (n
->decl
) |= DECL_POSSIBLY_INLINED (decl
);
1076 DECL_POSSIBLY_INLINED (decl
) |= DECL_POSSIBLY_INLINED (n
->decl
);
1078 lto_symtab_prevail_decl (n
->decl
, decl
);
1082 symtab_node::get_create (decl
);