1/* LTO symbol table.
2 Copyright (C) 2009-2023 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "target.h"
25#include "function.h"
26#include "basic-block.h"
27#include "tree.h"
28#include "gimple.h"
29#include "cgraph.h"
30#include "lto-streamer.h"
31#include "ipa-utils.h"
32#include "builtins.h"
33#include "alias.h"
34#include "lto.h"
35#include "lto-symtab.h"
36#include "stringpool.h"
37#include "attribs.h"
38
39/* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
40 all edges and removing the old node. */
41
42static void
43lto_cgraph_replace_node (struct cgraph_node *node,
44 struct cgraph_node *prevailing_node)
45{
46 struct cgraph_edge *e, *next;
47 bool compatible_p;
48
49 if (dump_file)
50 {
51 fprintf (stream: dump_file, format: "Replacing cgraph node %s by %s"
52 " for symbol %s\n",
53 node->dump_name (),
54 prevailing_node->dump_name (),
55 IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name)
56 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->decl)))));
57 }
58
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)
65 {
66 gcc_assert (!prevailing_node->inlined_to);
67 prevailing_node->mark_address_taken ();
68 }
69 if (node->definition && prevailing_node->definition
70 && DECL_COMDAT (node->decl) && DECL_COMDAT (prevailing_node->decl))
71 prevailing_node->merged_comdat = true;
72 else if ((node->definition || node->body_removed)
73 && DECL_DECLARED_INLINE_P (node->decl)
74 && DECL_EXTERNAL (node->decl)
75 && prevailing_node->definition)
76 prevailing_node->merged_extern_inline = true;
77 prevailing_node->merged_comdat |= node->merged_comdat;
78 prevailing_node->merged_extern_inline |= node->merged_extern_inline;
79
80 /* Redirect all incoming edges. */
81 compatible_p
82 = types_compatible_p (TREE_TYPE (TREE_TYPE (prevailing_node->decl)),
83 TREE_TYPE (TREE_TYPE (node->decl)));
84 for (e = node->callers; e; e = next)
85 {
86 next = e->next_caller;
87 e->redirect_callee (n: prevailing_node);
88 /* If there is a mismatch between the supposed callee return type and
89 the real one do not attempt to inline this function.
90 ??? We really need a way to match function signatures for ABI
91 compatibility and perform related promotions at inlining time. */
92 if (!compatible_p)
93 {
94 e->inline_failed = CIF_LTO_MISMATCHED_DECLARATIONS;
95 e->call_stmt_cannot_inline_p = 1;
96 }
97 }
98 /* Redirect incomming references. */
99 prevailing_node->clone_referring (node);
100 lto_free_function_in_decl_state_for_node (node);
101
102 if (node->decl != prevailing_node->decl)
103 node->release_body ();
104
105 /* Finally remove the replaced node. */
106 node->remove ();
107}
108
109/* Replace the cgraph node NODE with PREVAILING_NODE in the cgraph, merging
110 all edges and removing the old node. */
111
112static void
113lto_varpool_replace_node (varpool_node *vnode,
114 varpool_node *prevailing_node)
115{
116 gcc_assert (!vnode->definition || prevailing_node->definition);
117 gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
118
119 prevailing_node->clone_referring (node: vnode);
120 if (vnode->force_output)
121 prevailing_node->force_output = true;
122 if (vnode->forced_by_abi)
123 prevailing_node->forced_by_abi = true;
124
125 /* Be sure we can garbage collect the initializer. */
126 if (DECL_INITIAL (vnode->decl)
127 && vnode->decl != prevailing_node->decl)
128 DECL_INITIAL (vnode->decl) = error_mark_node;
129
130 /* Check and report ODR violations on virtual tables. */
131 if (DECL_VIRTUAL_P (vnode->decl) || DECL_VIRTUAL_P (prevailing_node->decl))
132 compare_virtual_tables (prevailing_node, vnode);
133
134 if (vnode->tls_model != prevailing_node->tls_model)
135 {
136 bool error = false;
137
138 /* Non-TLS and TLS never mix together. Also emulated model is not
139 compatible with anything else. */
140 if (prevailing_node->tls_model == TLS_MODEL_NONE
141 || prevailing_node->tls_model == TLS_MODEL_EMULATED
142 || vnode->tls_model == TLS_MODEL_NONE
143 || vnode->tls_model == TLS_MODEL_EMULATED)
144 error = true;
145 /* Linked is silently supporting transitions
146 GD -> IE, GD -> LE, LD -> LE, IE -> LE, LD -> IE.
147 Do the same transitions and error out on others. */
148 else if ((prevailing_node->tls_model == TLS_MODEL_REAL
149 || prevailing_node->tls_model == TLS_MODEL_LOCAL_DYNAMIC)
150 && (vnode->tls_model == TLS_MODEL_INITIAL_EXEC
151 || vnode->tls_model == TLS_MODEL_LOCAL_EXEC))
152 prevailing_node->tls_model = vnode->tls_model;
153 else if ((vnode->tls_model == TLS_MODEL_REAL
154 || vnode->tls_model == TLS_MODEL_LOCAL_DYNAMIC)
155 && (prevailing_node->tls_model == TLS_MODEL_INITIAL_EXEC
156 || prevailing_node->tls_model == TLS_MODEL_LOCAL_EXEC))
157 ;
158 else if (prevailing_node->tls_model == TLS_MODEL_INITIAL_EXEC
159 && vnode->tls_model == TLS_MODEL_LOCAL_EXEC)
160 prevailing_node->tls_model = vnode->tls_model;
161 else if (vnode->tls_model == TLS_MODEL_INITIAL_EXEC
162 && prevailing_node->tls_model == TLS_MODEL_LOCAL_EXEC)
163 ;
164 else
165 error = true;
166 if (error)
167 {
168 error_at (DECL_SOURCE_LOCATION (vnode->decl),
169 "%qD is defined with tls model %s", vnode->decl, tls_model_names [vnode->tls_model]);
170 inform (DECL_SOURCE_LOCATION (prevailing_node->decl),
171 "previously defined here as %s",
172 tls_model_names [prevailing_node->tls_model]);
173 }
174 }
175 /* Finally remove the replaced node. */
176 vnode->remove ();
177}
178
179/* Return non-zero if we want to output waring about T1 and T2.
180 Return value is a bitmask of reasons of violation:
181 Bit 0 indicates that types are not compatible.
182 Bit 1 indicates that types are not compatible because of C++ ODR rule.
183 If COMMON_OR_EXTERN is true, do not warn on size mismatches of arrays.
184 Bit 2 indicates that types are not ODR compatible
185
186 The interoperability rules are language specific. At present we do only
187 full checking for C++ ODR rule and for other languages we do basic check
188 that data structures are of same size and TBAA compatible. Our TBAA
189 implementation should be coarse enough so all valid type transitions
190 across different languages are allowed.
191
192 In partiucular we thus allow almost arbitrary type changes with
193 -fno-strict-aliasing which may be tough of as a feature rather than bug
194 as it allows to implement dodgy tricks in the language runtimes.
195
196 Naturally this code can be strenghtened significantly if we could track
197 down the language of origin. */
198
199static int
200warn_type_compatibility_p (tree prevailing_type, tree type,
201 bool common_or_extern)
202{
203 int lev = 0;
204 bool odr_p = odr_or_derived_type_p (t: prevailing_type)
205 && odr_or_derived_type_p (t: type);
206
207 if (prevailing_type == type)
208 return 0;
209
210 /* C++ provide a robust way to check for type compatibility via the ODR
211 rule. */
212 if (odr_p && !odr_types_equivalent_p (type1: prevailing_type, type2: type))
213 lev |= 2;
214
215 /* Function types needs special care, because types_compatible_p never
216 thinks prototype is compatible to non-prototype. */
217 if (FUNC_OR_METHOD_TYPE_P (type))
218 {
219 if (TREE_CODE (type) != TREE_CODE (prevailing_type))
220 lev |= 1;
221 lev |= warn_type_compatibility_p (TREE_TYPE (prevailing_type),
222 TREE_TYPE (type), common_or_extern: false);
223 if (TREE_CODE (type) == METHOD_TYPE
224 && TREE_CODE (prevailing_type) == METHOD_TYPE)
225 lev |= warn_type_compatibility_p (TYPE_METHOD_BASETYPE (prevailing_type),
226 TYPE_METHOD_BASETYPE (type), common_or_extern: false);
227 if (prototype_p (prevailing_type) && prototype_p (type)
228 && TYPE_ARG_TYPES (prevailing_type) != TYPE_ARG_TYPES (type))
229 {
230 tree parm1, parm2;
231 for (parm1 = TYPE_ARG_TYPES (prevailing_type),
232 parm2 = TYPE_ARG_TYPES (type);
233 parm1 && parm2;
234 parm1 = TREE_CHAIN (parm1),
235 parm2 = TREE_CHAIN (parm2))
236 lev |= warn_type_compatibility_p (TREE_VALUE (parm1),
237 TREE_VALUE (parm2), common_or_extern: false);
238 if (parm1 || parm2)
239 lev |= odr_p ? 3 : 1;
240 }
241 if (comp_type_attributes (prevailing_type, type) == 0)
242 lev |= 1;
243 return lev;
244 }
245
246 /* Get complete type. */
247 prevailing_type = TYPE_MAIN_VARIANT (prevailing_type);
248 type = TYPE_MAIN_VARIANT (type);
249
250 /* We cannot use types_compatible_p because we permit some changes
251 across types. For example unsigned size_t and "signed size_t" may be
252 compatible when merging C and Fortran types. */
253 if (COMPLETE_TYPE_P (prevailing_type)
254 && COMPLETE_TYPE_P (type)
255 /* While global declarations are never variadic, we can recurse here
256 for function parameter types. */
257 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
258 && TREE_CODE (TYPE_SIZE (prevailing_type)) == INTEGER_CST
259 && !tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prevailing_type)))
260 {
261 /* As a special case do not warn about merging
262 int a[];
263 and
264 int a[]={1,2,3};
265 here the first declaration is COMMON or EXTERN
266 and sizeof(a) == sizeof (int). */
267 if (!common_or_extern
268 || TREE_CODE (type) != ARRAY_TYPE
269 || TYPE_SIZE (type) != TYPE_SIZE (TREE_TYPE (type)))
270 lev |= 1;
271 }
272
273 /* Verify TBAA compatibility. Take care of alias set 0 and the fact that
274 we make ptr_type_node to TBAA compatible with every other type. */
275 if (type_with_alias_set_p (t: type) && type_with_alias_set_p (t: prevailing_type))
276 {
277 alias_set_type set1 = get_alias_set (type);
278 alias_set_type set2 = get_alias_set (prevailing_type);
279
280 if (set1 && set2 && set1 != set2)
281 {
282 tree t1 = type, t2 = prevailing_type;
283
284 /* Alias sets of arrays with aliased components are the same as alias
285 sets of the inner types. */
286 while (TREE_CODE (t1) == ARRAY_TYPE
287 && !TYPE_NONALIASED_COMPONENT (t1)
288 && TREE_CODE (t2) == ARRAY_TYPE
289 && !TYPE_NONALIASED_COMPONENT (t2))
290 {
291 t1 = TREE_TYPE (t1);
292 t2 = TREE_TYPE (t2);
293 }
294 if ((!POINTER_TYPE_P (t1) || !POINTER_TYPE_P (t2))
295 || (set1 != TYPE_ALIAS_SET (ptr_type_node)
296 && set2 != TYPE_ALIAS_SET (ptr_type_node)))
297 lev |= 5;
298 }
299 }
300
301 return lev;
302}
303
304/* Merge two variable or function symbol table entries PREVAILING and ENTRY.
305 Return false if the symbols are not fully compatible and a diagnostic
306 should be emitted. */
307
308static bool
309lto_symtab_merge (symtab_node *prevailing, symtab_node *entry)
310{
311 tree prevailing_decl = prevailing->decl;
312 tree decl = entry->decl;
313
314 if (prevailing_decl == decl)
315 return true;
316
317 if (TREE_CODE (decl) != TREE_CODE (prevailing_decl))
318 return false;
319
320 /* Merge decl state in both directions, we may still end up using
321 the new decl. */
322 TREE_ADDRESSABLE (prevailing_decl) |= TREE_ADDRESSABLE (decl);
323 TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (prevailing_decl);
324
325 /* The linker may ask us to combine two incompatible symbols.
326 Detect this case and notify the caller of required diagnostics. */
327
328 if (TREE_CODE (decl) == FUNCTION_DECL)
329 {
330 /* Merge decl state in both directions, we may still end up using
331 the new decl. */
332 DECL_POSSIBLY_INLINED (prevailing_decl) |= DECL_POSSIBLY_INLINED (decl);
333 DECL_POSSIBLY_INLINED (decl) |= DECL_POSSIBLY_INLINED (prevailing_decl);
334
335 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl),
336 TREE_TYPE (decl),
337 DECL_COMMON (decl)
338 || DECL_EXTERNAL (decl)))
339 return false;
340
341 return true;
342 }
343
344 if (warn_type_compatibility_p (TREE_TYPE (prevailing_decl),
345 TREE_TYPE (decl),
346 DECL_COMMON (decl) || DECL_EXTERNAL (decl)))
347 return false;
348
349 /* There is no point in comparing too many details of the decls here.
350 The type compatibility checks or the completing of types has properly
351 dealt with most issues. */
352
353 /* The following should all not invoke fatal errors as in non-LTO
354 mode the linker wouldn't complain either. Just emit warnings. */
355
356 /* Report a warning if user-specified alignments do not match. */
357 if ((DECL_USER_ALIGN (prevailing_decl) && DECL_USER_ALIGN (decl))
358 && DECL_ALIGN (prevailing_decl) < DECL_ALIGN (decl))
359 return false;
360
361 if (DECL_SIZE (decl) && DECL_SIZE (prevailing_decl)
362 && !tree_int_cst_equal (DECL_SIZE (decl), DECL_SIZE (prevailing_decl)))
363 {
364 if (!DECL_COMMON (decl) && !DECL_EXTERNAL (decl))
365 return false;
366
367 tree type = TREE_TYPE (decl);
368
369 /* For record type, check for array at the end of the structure. */
370 if (TREE_CODE (type) == RECORD_TYPE)
371 {
372 tree field = TYPE_FIELDS (type);
373 while (DECL_CHAIN (field) != NULL_TREE)
374 field = DECL_CHAIN (field);
375
376 return TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE;
377 }
378 /* As a special case do not warn about merging
379 int a[];
380 and
381 int a[]={1,2,3};
382 here the first declaration is COMMON
383 and sizeof(a) == sizeof (int). */
384 else if (TREE_CODE (type) != ARRAY_TYPE
385 || (TYPE_SIZE (type) != TYPE_SIZE (TREE_TYPE (type))))
386 return false;
387 }
388
389 return true;
390}
391
392/* Return true if the symtab entry E can be replaced by another symtab
393 entry. */
394
395static bool
396lto_symtab_resolve_replaceable_p (symtab_node *e)
397{
398 if (DECL_EXTERNAL (e->decl)
399 || DECL_COMDAT (e->decl)
400 || DECL_ONE_ONLY (e->decl)
401 || DECL_WEAK (e->decl))
402 return true;
403
404 if (VAR_P (e->decl))
405 return (DECL_COMMON (e->decl)
406 || (!flag_no_common && !DECL_INITIAL (e->decl)));
407
408 return false;
409}
410
411/* Return true, if the symbol E should be resolved by lto-symtab.
412 Those are all external symbols and all real symbols that are not static (we
413 handle renaming of static later in partitioning). */
414
415static bool
416lto_symtab_symbol_p (symtab_node *e)
417{
418 if (!TREE_PUBLIC (e->decl) && !DECL_EXTERNAL (e->decl))
419 return false;
420 return e->real_symbol_p ();
421}
422
423/* Return true if the symtab entry E can be the prevailing one. */
424
425static bool
426lto_symtab_resolve_can_prevail_p (symtab_node *e)
427{
428 if (!lto_symtab_symbol_p (e))
429 return false;
430
431 /* The C++ frontend ends up neither setting TREE_STATIC nor
432 DECL_EXTERNAL on virtual methods but only TREE_PUBLIC.
433 So do not reject !TREE_STATIC here but only DECL_EXTERNAL. */
434 if (DECL_EXTERNAL (e->decl))
435 return false;
436
437 return e->definition;
438}
439
440/* Resolve the symbol with the candidates in the chain *SLOT and store
441 their resolutions. */
442
443static symtab_node *
444lto_symtab_resolve_symbols (symtab_node *first)
445{
446 symtab_node *e;
447 symtab_node *prevailing = NULL;
448
449 /* Always set e->node so that edges are updated to reflect decl merging. */
450 for (e = first; e; e = e->next_sharing_asm_name)
451 if (lto_symtab_symbol_p (e)
452 && (e->resolution == LDPR_PREVAILING_DEF_IRONLY
453 || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
454 || e->resolution == LDPR_PREVAILING_DEF))
455 {
456 prevailing = e;
457 break;
458 }
459
460 /* If the chain is already resolved there is nothing else to do. */
461 if (prevailing)
462 {
463 /* Assert it's the only one.
464 GCC should silence multiple PREVAILING_DEF_IRONLY defs error
465 on COMMON symbols since it isn't error.
466 See: https://sourceware.org/bugzilla/show_bug.cgi?id=23079. */
467 for (e = prevailing->next_sharing_asm_name; e; e = e->next_sharing_asm_name)
468 if (lto_symtab_symbol_p (e)
469 && !DECL_COMMON (prevailing->decl)
470 && !DECL_COMMON (e->decl)
471 && (e->resolution == LDPR_PREVAILING_DEF_IRONLY
472 || e->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP
473 || e->resolution == LDPR_PREVAILING_DEF))
474 fatal_error (input_location, "multiple prevailing defs for %qE",
475 DECL_NAME (prevailing->decl));
476 return prevailing;
477 }
478
479 /* Find the single non-replaceable prevailing symbol and
480 diagnose ODR violations. */
481 for (e = first; e; e = e->next_sharing_asm_name)
482 {
483 if (!lto_symtab_resolve_can_prevail_p (e))
484 continue;
485
486 /* If we have a non-replaceable definition it prevails. */
487 if (!lto_symtab_resolve_replaceable_p (e))
488 {
489 if (prevailing)
490 {
491 error_at (DECL_SOURCE_LOCATION (e->decl),
492 "%qD has already been defined", e->decl);
493 inform (DECL_SOURCE_LOCATION (prevailing->decl),
494 "previously defined here");
495 }
496 prevailing = e;
497 }
498 }
499 if (prevailing)
500 return prevailing;
501
502 /* Do a second round choosing one from the replaceable prevailing decls. */
503 for (e = first; e; e = e->next_sharing_asm_name)
504 {
505 if (!lto_symtab_resolve_can_prevail_p (e))
506 continue;
507
508 /* Choose the first function that can prevail as prevailing. */
509 if (TREE_CODE (e->decl) == FUNCTION_DECL)
510 {
511 prevailing = e;
512 break;
513 }
514
515 /* From variables that can prevail choose the largest one. */
516 if (!prevailing
517 || tree_int_cst_lt (DECL_SIZE (prevailing->decl),
518 DECL_SIZE (e->decl))
519 /* When variables are equivalent try to chose one that has useful
520 DECL_INITIAL. This makes sense for keyed vtables that are
521 DECL_EXTERNAL but initialized. In units that do not need them
522 we replace the initializer by error_mark_node to conserve
523 memory.
524
525 We know that the vtable is keyed outside the LTO unit - otherwise
526 the keyed instance would prevail. We still can preserve useful
527 info in the initializer. */
528 || (DECL_SIZE (prevailing->decl) == DECL_SIZE (e->decl)
529 && (DECL_INITIAL (e->decl)
530 && DECL_INITIAL (e->decl) != error_mark_node)
531 && (!DECL_INITIAL (prevailing->decl)
532 || DECL_INITIAL (prevailing->decl) == error_mark_node)))
533 prevailing = e;
534 }
535
536 return prevailing;
537}
538
539/* Decide if it is OK to merge DECL into PREVAILING.
540 Because we wrap most of uses of declarations in MEM_REF, we can tolerate
541 some differences but other code may inspect directly the DECL. */
542
543static bool
544lto_symtab_merge_p (tree prevailing, tree decl)
545{
546 if (TREE_CODE (prevailing) != TREE_CODE (decl))
547 {
548 if (dump_file)
549 fprintf (stream: dump_file, format: "Not merging decls; "
550 "TREE_CODE mismatch\n");
551 return false;
552 }
553 gcc_checking_assert (TREE_CHAIN (prevailing) == TREE_CHAIN (decl));
554
555 if (TREE_CODE (prevailing) == FUNCTION_DECL)
556 {
557 if (fndecl_built_in_p (node: prevailing) != fndecl_built_in_p (node: decl))
558 {
559 if (dump_file)
560 fprintf (stream: dump_file, format: "Not merging decls; "
561 "DECL_BUILT_IN mismatch\n");
562 return false;
563 }
564 if (fndecl_built_in_p (node: prevailing)
565 && (DECL_BUILT_IN_CLASS (prevailing) != DECL_BUILT_IN_CLASS (decl)
566 || (DECL_UNCHECKED_FUNCTION_CODE (prevailing)
567 != DECL_UNCHECKED_FUNCTION_CODE (decl))))
568 {
569 if (dump_file)
570 fprintf (stream: dump_file, format: "Not merging decls; "
571 "DECL_BUILT_IN_CLASS or CODE mismatch\n");
572 return false;
573 }
574 }
575
576 if (DECL_ATTRIBUTES (prevailing) != DECL_ATTRIBUTES (decl))
577 {
578 tree prev_attr = lookup_attribute (attr_name: "error", DECL_ATTRIBUTES (prevailing));
579 tree attr = lookup_attribute (attr_name: "error", DECL_ATTRIBUTES (decl));
580 if ((prev_attr == NULL) != (attr == NULL)
581 || (prev_attr && !attribute_value_equal (prev_attr, attr)))
582 {
583 if (dump_file)
584 fprintf (stream: dump_file, format: "Not merging decls; "
585 "error attribute mismatch\n");
586 return false;
587 }
588
589 prev_attr = lookup_attribute (attr_name: "warning", DECL_ATTRIBUTES (prevailing));
590 attr = lookup_attribute (attr_name: "warning", DECL_ATTRIBUTES (decl));
591 if ((prev_attr == NULL) != (attr == NULL)
592 || (prev_attr && !attribute_value_equal (prev_attr, attr)))
593 {
594 if (dump_file)
595 fprintf (stream: dump_file, format: "Not merging decls; "
596 "warning attribute mismatch\n");
597 return false;
598 }
599
600 prev_attr = lookup_attribute (attr_name: "noreturn", DECL_ATTRIBUTES (prevailing));
601 attr = lookup_attribute (attr_name: "noreturn", DECL_ATTRIBUTES (decl));
602 if ((prev_attr == NULL) != (attr == NULL))
603 {
604 if (dump_file)
605 fprintf (stream: dump_file, format: "Not merging decls; "
606 "noreturn attribute mismatch\n");
607 return false;
608 }
609 }
610 return true;
611}
612
613/* Merge all decls in the symbol table chain to the prevailing decl and
614 issue diagnostics about type mismatches. If DIAGNOSED_P is true
615 do not issue further diagnostics.*/
616
617static void
618lto_symtab_merge_decls_2 (symtab_node *first, bool diagnosed_p)
619{
620 symtab_node *prevailing;
621 symtab_node *e;
622 vec<tree> mismatches = vNULL;
623 unsigned i;
624 tree decl;
625 bool tbaa_p = false;
626
627 /* Nothing to do for a single entry. */
628 prevailing = first;
629 if (!prevailing->next_sharing_asm_name)
630 return;
631
632 /* Try to merge each entry with the prevailing one. */
633 symtab_node *last_prevailing = prevailing, *next;
634 for (e = prevailing->next_sharing_asm_name; e; e = next)
635 {
636 next = e->next_sharing_asm_name;
637
638 /* Skip non-LTO symbols and symbols whose declaration we already
639 visited. */
640 if (lto_symtab_prevailing_decl (decl: e->decl) != e->decl
641 || !lto_symtab_symbol_p (e)
642 || e->decl == prevailing->decl)
643 continue;
644
645 if (!lto_symtab_merge (prevailing, entry: e)
646 && !diagnosed_p
647 && !DECL_ARTIFICIAL (e->decl))
648 mismatches.safe_push (obj: e->decl);
649
650 symtab_node *this_prevailing;
651 for (this_prevailing = prevailing; ;
652 this_prevailing = this_prevailing->next_sharing_asm_name)
653 {
654 if (this_prevailing->decl != e->decl
655 && lto_symtab_merge_p (prevailing: this_prevailing->decl, decl: e->decl))
656 break;
657 if (this_prevailing == last_prevailing)
658 {
659 this_prevailing = NULL;
660 break;
661 }
662 }
663
664 if (this_prevailing)
665 lto_symtab_prevail_decl (prevailing: this_prevailing->decl, decl: e->decl);
666 /* Maintain LRU list: relink the new prevaililng symbol
667 just after previaling node in the chain and update last_prevailing.
668 Since the number of possible declarations of a given symbol is
669 small, this should be faster than building a hash. */
670 else if (e == prevailing->next_sharing_asm_name)
671 last_prevailing = e;
672 else
673 {
674 if (e->next_sharing_asm_name)
675 e->next_sharing_asm_name->previous_sharing_asm_name
676 = e->previous_sharing_asm_name;
677 e->previous_sharing_asm_name->next_sharing_asm_name
678 = e->next_sharing_asm_name;
679 e->previous_sharing_asm_name = prevailing;
680 e->next_sharing_asm_name = prevailing->next_sharing_asm_name;
681 prevailing->next_sharing_asm_name->previous_sharing_asm_name = e;
682 prevailing->next_sharing_asm_name = e;
683 if (last_prevailing == prevailing)
684 last_prevailing = e;
685 }
686 }
687 if (mismatches.is_empty ())
688 return;
689
690 /* Diagnose all mismatched re-declarations. */
691 FOR_EACH_VEC_ELT (mismatches, i, decl)
692 {
693 /* Do not diagnose two built-in declarations, there is no useful
694 location in that case. It also happens for AVR if two built-ins
695 use the same asm name because their libgcc assembler code is the
696 same, see PR78562. */
697 if (DECL_IS_UNDECLARED_BUILTIN (prevailing->decl)
698 && DECL_IS_UNDECLARED_BUILTIN (decl))
699 continue;
700
701 int level = warn_type_compatibility_p (TREE_TYPE (prevailing->decl),
702 TREE_TYPE (decl),
703 DECL_COMDAT (decl));
704 if (level)
705 {
706 bool diag = false;
707 if (level & 2)
708 {
709 /* Silence warning for method and variables which belong
710 to types which already have ODR violation reported. Complaining
711 once is enough. */
712 if (TREE_CODE (decl) != FUNCTION_DECL
713 || TREE_CODE (TREE_TYPE (decl)) != METHOD_TYPE
714 || !TYPE_METHOD_BASETYPE (TREE_TYPE (decl))
715 || !odr_type_p (TYPE_METHOD_BASETYPE (TREE_TYPE (decl)))
716 || !odr_type_violation_reported_p
717 (TYPE_METHOD_BASETYPE (TREE_TYPE (decl))))
718 diag = warning_at (DECL_SOURCE_LOCATION (decl),
719 OPT_Wodr,
720 "%qD violates the C++ One Definition Rule",
721 decl);
722 }
723 if (!diag && (level & 1))
724 diag = warning_at (DECL_SOURCE_LOCATION (decl),
725 OPT_Wlto_type_mismatch,
726 "type of %qD does not match original "
727 "declaration", decl);
728 if (diag)
729 {
730 warn_types_mismatch (TREE_TYPE (prevailing->decl),
731 TREE_TYPE (decl),
732 DECL_SOURCE_LOCATION (prevailing->decl),
733 DECL_SOURCE_LOCATION (decl));
734 if ((level & 4)
735 && !TREE_READONLY (prevailing->decl))
736 tbaa_p = true;
737 }
738 diagnosed_p |= diag;
739 }
740 else if ((DECL_USER_ALIGN (prevailing->decl)
741 && DECL_USER_ALIGN (decl))
742 && DECL_ALIGN (prevailing->decl) < DECL_ALIGN (decl))
743 {
744 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl),
745 OPT_Wlto_type_mismatch,
746 "alignment of %qD is bigger than "
747 "original declaration", decl);
748 }
749 else
750 diagnosed_p |= warning_at (DECL_SOURCE_LOCATION (decl),
751 OPT_Wlto_type_mismatch,
752 "size of %qD differ from the size of "
753 "original declaration", decl);
754 }
755 if (diagnosed_p)
756 inform (DECL_SOURCE_LOCATION (prevailing->decl),
757 "%qD was previously declared here", prevailing->decl);
758 if (tbaa_p)
759 inform (DECL_SOURCE_LOCATION (prevailing->decl),
760 "code may be misoptimized unless "
761 "%<-fno-strict-aliasing%> is used");
762
763 mismatches.release ();
764}
765
766/* Helper to process the decl chain for the symbol table entry *SLOT. */
767
768static void
769lto_symtab_merge_decls_1 (symtab_node *first)
770{
771 symtab_node *e;
772 symtab_node *prevailing;
773 bool diagnosed_p = false;
774
775 if (dump_file)
776 {
777 fprintf (stream: dump_file, format: "Merging nodes for %s. Candidates:\n",
778 first->asm_name ());
779 for (e = first; e; e = e->next_sharing_asm_name)
780 if (TREE_PUBLIC (e->decl))
781 e->dump (f: dump_file);
782 }
783
784 /* Compute the symbol resolutions. This is a no-op when using the
785 linker plugin and resolution was decided by the linker. */
786 prevailing = lto_symtab_resolve_symbols (first);
787
788 /* If there's not a prevailing symbol yet it's an external reference.
789 Happens a lot during ltrans. Choose the first symbol with a
790 cgraph or a varpool node. */
791 if (!prevailing)
792 {
793 for (prevailing = first;
794 prevailing; prevailing = prevailing->next_sharing_asm_name)
795 if (lto_symtab_symbol_p (e: prevailing))
796 break;
797 if (!prevailing)
798 return;
799 /* For variables chose with a priority variant with vnode
800 attached (i.e. from unit where external declaration of
801 variable is actually used).
802 When there are multiple variants, chose one with size.
803 This is needed for C++ typeinfos, for example in
804 lto/20081204-1 there are typeifos in both units, just
805 one of them do have size. */
806 if (VAR_P (prevailing->decl))
807 {
808 for (e = prevailing->next_sharing_asm_name;
809 e; e = e->next_sharing_asm_name)
810 if (!COMPLETE_TYPE_P (TREE_TYPE (prevailing->decl))
811 && COMPLETE_TYPE_P (TREE_TYPE (e->decl))
812 && lto_symtab_symbol_p (e))
813 prevailing = e;
814 }
815 /* For functions prefer the non-builtin if one is available. */
816 else if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
817 {
818 for (e = first; e; e = e->next_sharing_asm_name)
819 if (TREE_CODE (e->decl) == FUNCTION_DECL
820 && !fndecl_built_in_p (node: e->decl)
821 && lto_symtab_symbol_p (e))
822 {
823 prevailing = e;
824 break;
825 }
826 }
827 }
828
829 symtab->symtab_prevail_in_asm_name_hash (node: prevailing);
830
831 /* Diagnose mismatched objects. */
832 for (e = prevailing->next_sharing_asm_name;
833 e; e = e->next_sharing_asm_name)
834 {
835 if (TREE_CODE (prevailing->decl)
836 == TREE_CODE (e->decl))
837 continue;
838 if (!lto_symtab_symbol_p (e))
839 continue;
840
841 switch (TREE_CODE (prevailing->decl))
842 {
843 case VAR_DECL:
844 gcc_assert (TREE_CODE (e->decl) == FUNCTION_DECL);
845 error_at (DECL_SOURCE_LOCATION (e->decl),
846 "variable %qD redeclared as function",
847 prevailing->decl);
848 break;
849
850 case FUNCTION_DECL:
851 gcc_assert (VAR_P (e->decl));
852 error_at (DECL_SOURCE_LOCATION (e->decl),
853 "function %qD redeclared as variable",
854 prevailing->decl);
855 break;
856
857 default:
858 gcc_unreachable ();
859 }
860
861 diagnosed_p = true;
862 }
863 if (diagnosed_p)
864 inform (DECL_SOURCE_LOCATION (prevailing->decl),
865 "previously declared here");
866
867 /* Merge the chain to the single prevailing decl and diagnose
868 mismatches. */
869 lto_symtab_merge_decls_2 (first: prevailing, diagnosed_p);
870
871 if (dump_file)
872 {
873 fprintf (stream: dump_file, format: "After resolution:\n");
874 for (e = prevailing; e; e = e->next_sharing_asm_name)
875 e->dump (f: dump_file);
876 }
877}
878
879/* Resolve and merge all symbol table chains to a prevailing decl. */
880
881void
882lto_symtab_merge_decls (void)
883{
884 symtab_node *node;
885
886 gcc_assert (!dump_file);
887 dump_file = dump_begin (decl_merge_dump_id, NULL);
888
889 /* Populate assembler name hash. */
890 symtab->symtab_initialize_asm_name_hash ();
891
892 FOR_EACH_SYMBOL (node)
893 if (!node->previous_sharing_asm_name
894 && node->next_sharing_asm_name)
895 lto_symtab_merge_decls_1 (first: node);
896
897 if (dump_file)
898 dump_end (decl_merge_dump_id, dump_file);
899 dump_file = NULL;
900}
901
902/* Helper to process the decl chain for the symbol table entry *SLOT. */
903
904static void
905lto_symtab_merge_symbols_1 (symtab_node *prevailing)
906{
907 symtab_node *e;
908 symtab_node *next;
909
910 prevailing->decl->decl_with_vis.symtab_node = prevailing;
911
912 /* Replace the cgraph node of each entry with the prevailing one. */
913 for (e = prevailing->next_sharing_asm_name; e;
914 e = next)
915 {
916 next = e->next_sharing_asm_name;
917 cgraph_node *ce = dyn_cast <cgraph_node *> (p: e);
918
919 if ((!TREE_PUBLIC (e->decl) && !DECL_EXTERNAL (e->decl))
920 || (ce != NULL && ce->inlined_to))
921 continue;
922 symtab_node *to = symtab_node::get (decl: lto_symtab_prevailing_decl (decl: e->decl));
923
924 /* No matter how we are going to deal with resolution, we will ultimately
925 use prevailing definition. */
926 if (ce)
927 ipa_merge_profiles (dst: dyn_cast<cgraph_node *> (p: prevailing),
928 src: dyn_cast<cgraph_node *> (p: e));
929
930 /* If we decided to replace the node by TO, do it. */
931 if (e != to)
932 {
933 if (ce)
934 lto_cgraph_replace_node (node: ce, prevailing_node: dyn_cast<cgraph_node *> (p: to));
935 else if (varpool_node *ve = dyn_cast <varpool_node *> (p: e))
936 lto_varpool_replace_node (vnode: ve, prevailing_node: dyn_cast<varpool_node *> (p: to));
937 }
938 /* Watch out for duplicated symbols for a given declaration. */
939 else if (!e->transparent_alias
940 || !e->definition || e->get_alias_target () != to)
941 {
942 /* We got a new declaration we do not want to merge. In this case
943 get rid of the existing definition and create a transparent
944 alias. */
945 if (ce)
946 {
947 lto_free_function_in_decl_state_for_node (ce);
948 if (!ce->weakref)
949 ce->release_body ();
950 ce->reset ();
951 symtab->call_cgraph_removal_hooks (node: ce);
952 }
953 else
954 {
955 DECL_INITIAL (e->decl) = error_mark_node;
956 if (e->lto_file_data)
957 {
958 lto_free_function_in_decl_state_for_node (e);
959 e->lto_file_data = NULL;
960 }
961 symtab->call_varpool_removal_hooks (node: dyn_cast<varpool_node *> (p: e));
962 }
963 e->remove_all_references ();
964 e->analyzed = e->body_removed = false;
965 e->resolve_alias (target: prevailing, transparent: true);
966 gcc_assert (e != prevailing);
967 }
968 }
969
970 return;
971}
972
973/* Merge cgraph nodes according to the symbol merging done by
974 lto_symtab_merge_decls. */
975
976void
977lto_symtab_merge_symbols (void)
978{
979 symtab_node *node;
980
981 if (!flag_ltrans)
982 {
983 symtab->symtab_initialize_asm_name_hash ();
984
985 /* Do the actual merging.
986 At this point we invalidate hash translating decls into symtab nodes
987 because after removing one of duplicate decls the hash is not correcly
988 updated to the other duplicate. */
989 FOR_EACH_SYMBOL (node)
990 if (lto_symtab_symbol_p (e: node)
991 && node->next_sharing_asm_name
992 && !node->previous_sharing_asm_name)
993 lto_symtab_merge_symbols_1 (prevailing: node);
994
995 /* Resolve weakref aliases whose target are now in the compilation unit.
996 also re-populate the hash translating decls into symtab nodes*/
997 FOR_EACH_SYMBOL (node)
998 {
999 cgraph_node *cnode, *cnode2;
1000 varpool_node *vnode;
1001 symtab_node *node2;
1002
1003 if (!node->analyzed && node->alias_target)
1004 {
1005 symtab_node *tgt = symtab_node::get_for_asmname (asmname: node->alias_target);
1006 gcc_assert (node->weakref);
1007 if (tgt)
1008 node->resolve_alias (target: tgt, transparent: true);
1009 }
1010 /* If the symbol was preempted outside IR, see if we want to get rid
1011 of the definition. */
1012 if (node->analyzed
1013 && !DECL_EXTERNAL (node->decl)
1014 && (node->resolution == LDPR_PREEMPTED_REG
1015 || node->resolution == LDPR_RESOLVED_IR
1016 || node->resolution == LDPR_RESOLVED_EXEC
1017 || node->resolution == LDPR_RESOLVED_DYN))
1018 {
1019 DECL_EXTERNAL (node->decl) = 1;
1020 /* If alias to local symbol was preempted by external definition,
1021 we know it is not pointing to the local symbol. Remove it. */
1022 if (node->alias
1023 && !node->weakref
1024 && !node->transparent_alias
1025 && node->get_alias_target ()->binds_to_current_def_p ())
1026 {
1027 node->alias = false;
1028 node->remove_all_references ();
1029 node->definition = false;
1030 node->analyzed = false;
1031 node->cpp_implicit_alias = false;
1032 }
1033 else if (!node->alias
1034 && node->definition
1035 && node->get_availability () <= AVAIL_INTERPOSABLE)
1036 {
1037 if ((cnode = dyn_cast <cgraph_node *> (p: node)) != NULL)
1038 cnode->reset ();
1039 else
1040 {
1041 node->analyzed = node->definition = false;
1042 node->remove_all_references ();
1043 }
1044 }
1045 }
1046
1047 if (!(cnode = dyn_cast <cgraph_node *> (p: node))
1048 || !cnode->clone_of
1049 || cnode->clone_of->decl != cnode->decl)
1050 {
1051 /* Builtins are not merged via decl merging. It is however
1052 possible that tree merging unified the declaration. We
1053 do not want duplicate entries in symbol table. */
1054 if (cnode && fndecl_built_in_p (node: node->decl)
1055 && (cnode2 = cgraph_node::get (decl: node->decl))
1056 && cnode2 != cnode)
1057 lto_cgraph_replace_node (node: cnode2, prevailing_node: cnode);
1058
1059 /* The user defined assembler variables are also not unified by their
1060 symbol name (since it is irrelevant), but we need to unify symbol
1061 nodes if tree merging occurred. */
1062 if ((vnode = dyn_cast <varpool_node *> (p: node))
1063 && DECL_HARD_REGISTER (vnode->decl)
1064 && (node2 = symtab_node::get (decl: vnode->decl))
1065 && node2 != node)
1066 lto_varpool_replace_node (vnode: dyn_cast <varpool_node *> (p: node2),
1067 prevailing_node: vnode);
1068
1069
1070 /* Abstract functions may have duplicated cgraph nodes attached;
1071 remove them. */
1072 else if (cnode && DECL_ABSTRACT_P (cnode->decl)
1073 && (cnode2 = cgraph_node::get (decl: node->decl))
1074 && cnode2 != cnode)
1075 cnode2->remove ();
1076
1077 node->decl->decl_with_vis.symtab_node = node;
1078 }
1079 }
1080 }
1081}
1082
1083/* Virtual tables may matter for code generation even if they are not
1084 directly referenced by the code because they may be used for
1085 devirtualization.
1086 For this reason it is important to merge even virtual tables that have no
1087 associated symbol table entries. Without doing so we lose optimization
1088 oppurtunities by losing track of the vtable constructor.
1089 FIXME: we probably ought to introduce explicit symbol table entries for
1090 those before streaming. */
1091
1092tree
1093lto_symtab_prevailing_virtual_decl (tree decl)
1094{
1095 if (DECL_ABSTRACT_P (decl))
1096 return decl;
1097
1098 if (type_in_anonymous_namespace_p (DECL_CONTEXT (decl)))
1099 /* There can't be any other declarations. */
1100 return decl;
1101
1102 gcc_checking_assert (DECL_ASSEMBLER_NAME_SET_P (decl));
1103
1104 symtab_node *n = symtab_node::get_for_asmname
1105 (DECL_ASSEMBLER_NAME (decl));
1106 while (n && ((!DECL_EXTERNAL (n->decl) && !TREE_PUBLIC (n->decl))
1107 || !DECL_VIRTUAL_P (n->decl)))
1108 n = n->next_sharing_asm_name;
1109 if (n)
1110 {
1111 /* Merge decl state in both directions, we may still end up using
1112 the other decl. */
1113 TREE_ADDRESSABLE (n->decl) |= TREE_ADDRESSABLE (decl);
1114 TREE_ADDRESSABLE (decl) |= TREE_ADDRESSABLE (n->decl);
1115
1116 if (TREE_CODE (decl) == FUNCTION_DECL)
1117 {
1118 /* Merge decl state in both directions, we may still end up using
1119 the other decl. */
1120 DECL_POSSIBLY_INLINED (n->decl) |= DECL_POSSIBLY_INLINED (decl);
1121 DECL_POSSIBLY_INLINED (decl) |= DECL_POSSIBLY_INLINED (n->decl);
1122 }
1123 lto_symtab_prevail_decl (prevailing: n->decl, decl);
1124 decl = n->decl;
1125 }
1126 else
1127 symtab_node::get_create (node: decl);
1128
1129 return decl;
1130}
1131

source code of gcc/lto/lto-symtab.cc