2 Copyright (C) 2009-2013 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
24 #include "diagnostic-core.h"
29 #include "plugin-api.h"
30 #include "lto-streamer.h"
32 /* Vector to keep track of external variables we've seen so far. */
33 vec
<tree
, va_gc
> *lto_global_var_decls
;
35 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
36 all edges and removing the old node. */
39 lto_cgraph_replace_node (struct cgraph_node
*node
,
40 struct cgraph_node
*prevailing_node
)
42 struct cgraph_edge
*e
, *next
;
47 fprintf (cgraph_dump_file
, "Replacing cgraph node %s/%i by %s/%i"
49 cgraph_node_name (node
), node
->symbol
.order
,
50 cgraph_node_name (prevailing_node
),
51 prevailing_node
->symbol
.order
,
52 IDENTIFIER_POINTER ((*targetm
.asm_out
.mangle_assembler_name
)
53 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node
->symbol
.decl
)))));
56 /* Merge node flags. */
57 if (node
->symbol
.force_output
)
58 cgraph_mark_force_output_node (prevailing_node
);
59 if (node
->symbol
.address_taken
)
61 gcc_assert (!prevailing_node
->global
.inlined_to
);
62 cgraph_mark_address_taken_node (prevailing_node
);
65 /* Redirect all incoming edges. */
67 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node
->symbol
.decl
)),
68 TREE_TYPE (TREE_TYPE (node
->symbol
.decl
)));
69 for (e
= node
->callers
; e
; e
= next
)
71 next
= e
->next_caller
;
72 cgraph_redirect_edge_callee (e
, prevailing_node
);
73 /* If there is a mismatch between the supposed callee return type and
74 the real one do not attempt to inline this function.
75 ??? We really need a way to match function signatures for ABI
76 compatibility and perform related promotions at inlining time. */
78 e
->call_stmt_cannot_inline_p
= 1;
80 /* Redirect incomming references. */
81 ipa_clone_referring ((symtab_node
)prevailing_node
, &node
->symbol
.ref_list
);
83 /* Finally remove the replaced node. */
84 cgraph_remove_node (node
);
87 /* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
88 all edges and removing the old node. */
91 lto_varpool_replace_node (struct varpool_node
*vnode
,
92 struct varpool_node
*prevailing_node
)
94 gcc_assert (!vnode
->symbol
.definition
|| prevailing_node
->symbol
.definition
);
95 gcc_assert (!vnode
->symbol
.analyzed
|| prevailing_node
->symbol
.analyzed
);
97 ipa_clone_referring ((symtab_node
)prevailing_node
, &vnode
->symbol
.ref_list
);
99 /* Be sure we can garbage collect the initializer. */
100 if (DECL_INITIAL (vnode
->symbol
.decl
))
101 DECL_INITIAL (vnode
->symbol
.decl
) = error_mark_node
;
102 /* Finally remove the replaced node. */
103 varpool_remove_node (vnode
);
106 /* Merge two variable or function symbol table entries PREVAILING and ENTRY.
107 Return false if the symbols are not fully compatible and a diagnostic
108 should be emitted. */
111 lto_symtab_merge (symtab_node prevailing
, symtab_node entry
)
113 tree prevailing_decl
= prevailing
->symbol
.decl
;
114 tree decl
= entry
->symbol
.decl
;
115 tree prevailing_type
, type
;
117 if (prevailing_decl
== decl
)
120 /* Merge decl state in both directions, we may still end up using
122 TREE_ADDRESSABLE (prevailing_decl
) |= TREE_ADDRESSABLE (decl
);
123 TREE_ADDRESSABLE (decl
) |= TREE_ADDRESSABLE (prevailing_decl
);
125 /* The linker may ask us to combine two incompatible symbols.
126 Detect this case and notify the caller of required diagnostics. */
128 if (TREE_CODE (decl
) == FUNCTION_DECL
)
130 if (!types_compatible_p (TREE_TYPE (prevailing_decl
),
132 /* If we don't have a merged type yet...sigh. The linker
133 wouldn't complain if the types were mismatched, so we
134 probably shouldn't either. Just use the type from
135 whichever decl appears to be associated with the
136 definition. If for some odd reason neither decl is, the
143 /* Now we exclusively deal with VAR_DECLs. */
145 /* Sharing a global symbol is a strong hint that two types are
146 compatible. We could use this information to complete
147 incomplete pointed-to types more aggressively here, ignoring
148 mismatches in both field and tag names. It's difficult though
149 to guarantee that this does not have side-effects on merging
150 more compatible types from other translation units though. */
152 /* We can tolerate differences in type qualification, the
153 qualification of the prevailing definition will prevail.
154 ??? In principle we might want to only warn for structurally
155 incompatible types here, but unless we have protective measures
156 for TBAA in place that would hide useful information. */
157 prevailing_type
= TYPE_MAIN_VARIANT (TREE_TYPE (prevailing_decl
));
158 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
160 if (!types_compatible_p (prevailing_type
, type
))
162 if (COMPLETE_TYPE_P (type
))
165 /* If type is incomplete then avoid warnings in the cases
166 that TBAA handles just fine. */
168 if (TREE_CODE (prevailing_type
) != TREE_CODE (type
))
171 if (TREE_CODE (prevailing_type
) == ARRAY_TYPE
)
173 tree tem1
= TREE_TYPE (prevailing_type
);
174 tree tem2
= TREE_TYPE (type
);
175 while (TREE_CODE (tem1
) == ARRAY_TYPE
176 && TREE_CODE (tem2
) == ARRAY_TYPE
)
178 tem1
= TREE_TYPE (tem1
);
179 tem2
= TREE_TYPE (tem2
);
182 if (TREE_CODE (tem1
) != TREE_CODE (tem2
))
185 if (!types_compatible_p (tem1
, tem2
))
189 /* Fallthru. Compatible enough. */
192 /* ??? We might want to emit a warning here if type qualification
193 differences were spotted. Do not do this unconditionally though. */
195 /* There is no point in comparing too many details of the decls here.
196 The type compatibility checks or the completing of types has properly
197 dealt with most issues. */
199 /* The following should all not invoke fatal errors as in non-LTO
200 mode the linker wouldn't complain either. Just emit warnings. */
202 /* Report a warning if user-specified alignments do not match. */
203 if ((DECL_USER_ALIGN (prevailing_decl
) && DECL_USER_ALIGN (decl
))
204 && DECL_ALIGN (prevailing_decl
) < DECL_ALIGN (decl
))
210 /* Return true if the symtab entry E can be replaced by another symtab
214 lto_symtab_resolve_replaceable_p (symtab_node e
)
216 if (DECL_EXTERNAL (e
->symbol
.decl
)
217 || DECL_COMDAT (e
->symbol
.decl
)
218 || DECL_ONE_ONLY (e
->symbol
.decl
)
219 || DECL_WEAK (e
->symbol
.decl
))
222 if (TREE_CODE (e
->symbol
.decl
) == VAR_DECL
)
223 return (DECL_COMMON (e
->symbol
.decl
)
224 || (!flag_no_common
&& !DECL_INITIAL (e
->symbol
.decl
)));
229 /* Return true, if the symbol E should be resolved by lto-symtab.
230 Those are all external symbols and all real symbols that are not static (we
231 handle renaming of static later in partitioning). */
234 lto_symtab_symbol_p (symtab_node e
)
236 if (!TREE_PUBLIC (e
->symbol
.decl
) && !DECL_EXTERNAL (e
->symbol
.decl
))
238 /* weakrefs are really static variables that are made external by a hack. */
239 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (e
->symbol
.decl
)))
241 return symtab_real_symbol_p (e
);
244 /* Return true if the symtab entry E can be the prevailing one. */
247 lto_symtab_resolve_can_prevail_p (symtab_node e
)
249 if (!lto_symtab_symbol_p (e
))
252 /* The C++ frontend ends up neither setting TREE_STATIC nor
253 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
254 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
255 if (DECL_EXTERNAL (e
->symbol
.decl
))
258 return e
->symbol
.definition
;
261 /* Resolve the symbol with the candidates in the chain *SLOT and store
262 their resolutions. */
265 lto_symtab_resolve_symbols (symtab_node first
)
268 symtab_node prevailing
= NULL
;
270 /* Always set e->node so that edges are updated to reflect decl merging. */
271 for (e
= first
; e
; e
= e
->symbol
.next_sharing_asm_name
)
272 if (lto_symtab_symbol_p (e
)
273 && (e
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY
274 || e
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
275 || e
->symbol
.resolution
== LDPR_PREVAILING_DEF
))
281 /* If the chain is already resolved there is nothing else to do. */
284 /* Assert it's the only one. */
285 for (e
= prevailing
->symbol
.next_sharing_asm_name
; e
; e
= e
->symbol
.next_sharing_asm_name
)
286 if (lto_symtab_symbol_p (e
)
287 && (e
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY
288 || e
->symbol
.resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
289 || e
->symbol
.resolution
== LDPR_PREVAILING_DEF
))
290 fatal_error ("multiple prevailing defs for %qE",
291 DECL_NAME (prevailing
->symbol
.decl
));
295 /* Find the single non-replaceable prevailing symbol and
296 diagnose ODR violations. */
297 for (e
= first
; e
; e
= e
->symbol
.next_sharing_asm_name
)
299 if (!lto_symtab_resolve_can_prevail_p (e
))
302 /* If we have a non-replaceable definition it prevails. */
303 if (!lto_symtab_resolve_replaceable_p (e
))
307 error_at (DECL_SOURCE_LOCATION (e
->symbol
.decl
),
308 "%qD has already been defined", e
->symbol
.decl
);
309 inform (DECL_SOURCE_LOCATION (prevailing
->symbol
.decl
),
310 "previously defined here");
318 /* Do a second round choosing one from the replaceable prevailing decls. */
319 for (e
= first
; e
; e
= e
->symbol
.next_sharing_asm_name
)
321 if (!lto_symtab_resolve_can_prevail_p (e
))
324 /* Choose the first function that can prevail as prevailing. */
325 if (TREE_CODE (e
->symbol
.decl
) == FUNCTION_DECL
)
331 /* From variables that can prevail choose the largest one. */
333 || tree_int_cst_lt (DECL_SIZE (prevailing
->symbol
.decl
),
334 DECL_SIZE (e
->symbol
.decl
))
335 /* When variables are equivalent try to chose one that has useful
336 DECL_INITIAL. This makes sense for keyed vtables that are
337 DECL_EXTERNAL but initialized. In units that do not need them
338 we replace the initializer by error_mark_node to conserve
341 We know that the vtable is keyed outside the LTO unit - otherwise
342 the keyed instance would prevail. We still can preserve useful
343 info in the initializer. */
344 || (DECL_SIZE (prevailing
->symbol
.decl
) == DECL_SIZE (e
->symbol
.decl
)
345 && (DECL_INITIAL (e
->symbol
.decl
)
346 && DECL_INITIAL (e
->symbol
.decl
) != error_mark_node
)
347 && (!DECL_INITIAL (prevailing
->symbol
.decl
)
348 || DECL_INITIAL (prevailing
->symbol
.decl
) == error_mark_node
)))
355 /* Merge all decls in the symbol table chain to the prevailing decl and
356 issue diagnostics about type mismatches. If DIAGNOSED_P is true
357 do not issue further diagnostics.*/
360 lto_symtab_merge_decls_2 (symtab_node first
, bool diagnosed_p
)
362 symtab_node prevailing
, e
;
363 vec
<tree
> mismatches
= vNULL
;
367 /* Nothing to do for a single entry. */
369 if (!prevailing
->symbol
.next_sharing_asm_name
)
372 /* Try to merge each entry with the prevailing one. */
373 for (e
= prevailing
->symbol
.next_sharing_asm_name
;
374 e
; e
= e
->symbol
.next_sharing_asm_name
)
375 if (TREE_PUBLIC (e
->symbol
.decl
))
377 if (!lto_symtab_merge (prevailing
, e
)
379 mismatches
.safe_push (e
->symbol
.decl
);
381 if (mismatches
.is_empty ())
384 /* Diagnose all mismatched re-declarations. */
385 FOR_EACH_VEC_ELT (mismatches
, i
, decl
)
387 if (!types_compatible_p (TREE_TYPE (prevailing
->symbol
.decl
),
389 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
), 0,
390 "type of %qD does not match original "
391 "declaration", decl
);
393 else if ((DECL_USER_ALIGN (prevailing
->symbol
.decl
)
394 && DECL_USER_ALIGN (decl
))
395 && DECL_ALIGN (prevailing
->symbol
.decl
) < DECL_ALIGN (decl
))
397 diagnosed_p
|= warning_at (DECL_SOURCE_LOCATION (decl
), 0,
398 "alignment of %qD is bigger than "
399 "original declaration", decl
);
403 inform (DECL_SOURCE_LOCATION (prevailing
->symbol
.decl
),
404 "previously declared here");
406 mismatches
.release ();
409 /* Helper to process the decl chain for the symbol table entry *SLOT. */
412 lto_symtab_merge_decls_1 (symtab_node first
)
414 symtab_node e
, prevailing
;
415 bool diagnosed_p
= false;
417 if (cgraph_dump_file
)
419 fprintf (cgraph_dump_file
, "Merging nodes for %s. Candidates:\n",
420 symtab_node_asm_name (first
));
421 for (e
= first
; e
; e
= e
->symbol
.next_sharing_asm_name
)
422 if (TREE_PUBLIC (e
->symbol
.decl
))
423 dump_symtab_node (cgraph_dump_file
, e
);
426 /* Compute the symbol resolutions. This is a no-op when using the
427 linker plugin and resolution was decided by the linker. */
428 prevailing
= lto_symtab_resolve_symbols (first
);
430 /* If there's not a prevailing symbol yet it's an external reference.
431 Happens a lot during ltrans. Choose the first symbol with a
432 cgraph or a varpool node. */
436 /* For variables chose with a priority variant with vnode
437 attached (i.e. from unit where external declaration of
438 variable is actually used).
439 When there are multiple variants, chose one with size.
440 This is needed for C++ typeinfos, for example in
441 lto/20081204-1 there are typeifos in both units, just
442 one of them do have size. */
443 if (TREE_CODE (prevailing
->symbol
.decl
) == VAR_DECL
)
445 for (e
= prevailing
->symbol
.next_sharing_asm_name
;
446 e
; e
= e
->symbol
.next_sharing_asm_name
)
447 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing
->symbol
.decl
))
448 && COMPLETE_TYPE_P (TREE_TYPE (e
->symbol
.decl
))
449 && lto_symtab_symbol_p (e
))
452 /* For variables prefer the non-builtin if one is available. */
453 else if (TREE_CODE (prevailing
->symbol
.decl
) == FUNCTION_DECL
)
455 for (e
= first
; e
; e
= e
->symbol
.next_sharing_asm_name
)
456 if (TREE_CODE (e
->symbol
.decl
) == FUNCTION_DECL
457 && !DECL_BUILT_IN (e
->symbol
.decl
)
458 && lto_symtab_symbol_p (e
))
466 symtab_prevail_in_asm_name_hash (prevailing
);
468 /* Diagnose mismatched objects. */
469 for (e
= prevailing
->symbol
.next_sharing_asm_name
;
470 e
; e
= e
->symbol
.next_sharing_asm_name
)
472 if (TREE_CODE (prevailing
->symbol
.decl
)
473 == TREE_CODE (e
->symbol
.decl
))
475 if (!lto_symtab_symbol_p (e
))
478 switch (TREE_CODE (prevailing
->symbol
.decl
))
481 gcc_assert (TREE_CODE (e
->symbol
.decl
) == FUNCTION_DECL
);
482 error_at (DECL_SOURCE_LOCATION (e
->symbol
.decl
),
483 "variable %qD redeclared as function",
484 prevailing
->symbol
.decl
);
488 gcc_assert (TREE_CODE (e
->symbol
.decl
) == VAR_DECL
);
489 error_at (DECL_SOURCE_LOCATION (e
->symbol
.decl
),
490 "function %qD redeclared as variable",
491 prevailing
->symbol
.decl
);
501 inform (DECL_SOURCE_LOCATION (prevailing
->symbol
.decl
),
502 "previously declared here");
504 /* Merge the chain to the single prevailing decl and diagnose
506 lto_symtab_merge_decls_2 (prevailing
, diagnosed_p
);
508 if (cgraph_dump_file
)
510 fprintf (cgraph_dump_file
, "After resolution:\n");
511 for (e
= prevailing
; e
; e
= e
->symbol
.next_sharing_asm_name
)
512 dump_symtab_node (cgraph_dump_file
, e
);
516 /* Resolve and merge all symbol table chains to a prevailing decl. */
519 lto_symtab_merge_decls (void)
523 /* Populate assembler name hash. */
524 symtab_initialize_asm_name_hash ();
526 FOR_EACH_SYMBOL (node
)
527 if (lto_symtab_symbol_p (node
)
528 && node
->symbol
.next_sharing_asm_name
)
532 /* To avoid duplicated work, see if this is first real symbol in the
534 for (n
= node
->symbol
.previous_sharing_asm_name
;
535 n
&& !lto_symtab_symbol_p (n
); n
= n
->symbol
.previous_sharing_asm_name
)
538 lto_symtab_merge_decls_1 (node
);
542 /* Helper to process the decl chain for the symbol table entry *SLOT. */
545 lto_symtab_merge_symbols_1 (symtab_node prevailing
)
549 /* Replace the cgraph node of each entry with the prevailing one. */
550 for (e
= prevailing
->symbol
.next_sharing_asm_name
; e
;
553 next
= e
->symbol
.next_sharing_asm_name
;
555 if (!lto_symtab_symbol_p (e
))
557 cgraph_node
*ce
= dyn_cast
<cgraph_node
> (e
);
558 if (ce
&& !DECL_BUILT_IN (e
->symbol
.decl
))
559 lto_cgraph_replace_node (ce
, cgraph (prevailing
));
560 if (varpool_node
*ve
= dyn_cast
<varpool_node
> (e
))
561 lto_varpool_replace_node (ve
, varpool (prevailing
));
567 /* Merge cgraph nodes according to the symbol merging done by
568 lto_symtab_merge_decls. */
571 lto_symtab_merge_symbols (void)
577 symtab_initialize_asm_name_hash ();
579 /* Do the actual merging. */
580 FOR_EACH_SYMBOL (node
)
581 if (lto_symtab_symbol_p (node
)
582 && node
->symbol
.next_sharing_asm_name
583 && !node
->symbol
.previous_sharing_asm_name
)
584 lto_symtab_merge_symbols_1 (node
);
586 /* Resolve weakref aliases whose target are now in the compilation unit. */
587 FOR_EACH_SYMBOL (node
)
589 if (!node
->symbol
.analyzed
&& node
->symbol
.alias_target
)
591 symtab_node tgt
= symtab_node_for_asm (node
->symbol
.alias_target
);
593 symtab_resolve_alias (node
, tgt
);
595 node
->symbol
.aux
= NULL
;
600 /* Given the decl DECL, return the prevailing decl with the same name. */
603 lto_symtab_prevailing_decl (tree decl
)
607 /* Builtins and local symbols are their own prevailing decl. */
608 if ((!TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
)) || is_builtin_fn (decl
))
611 /* DECL_ABSTRACTs are their own prevailng decl. */
612 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_ABSTRACT (decl
))
615 /* Likewise builtins are their own prevailing decl. This preserves
616 non-builtin vs. builtin uses from compile-time. */
617 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
620 /* As an anoying special cases weakrefs are really static variables with
622 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl
)))
625 /* Ensure DECL_ASSEMBLER_NAME will not set assembler name. */
626 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl
));
628 /* Walk through the list of candidates and return the one we merged to. */
629 ret
= symtab_node_for_asm (DECL_ASSEMBLER_NAME (decl
));
633 return ret
->symbol
.decl
;