1 /* LTO plugin for linkers like gold, GNU ld or mold.
2 Copyright (C) 2009-2022 Free Software Foundation, Inc.
3 Contributed by Rafael Avila de Espindola (espindola@google.com).
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3, or (at your option)
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; see the file COPYING3. If not see
17 <http://www.gnu.org/licenses/>. */
19 /* The plugin has only one external function: onload. A linker passes it an array of
20 function that the plugin uses to communicate back to the linker.
22 With the functions provided by the linker, the plugin can be notified when
23 the linker first analyzes a file and pass a symbol table back to the linker. The plugin
24 is also notified when all symbols have been read and it is time to generate
25 machine code for the necessary symbols.
27 More information at http://gcc.gnu.org/wiki/whopr/driver.
29 This plugin should be passed the lto-wrapper options and will forward them.
30 It also has options at his own:
31 -debug: Print the command line used to run lto-wrapper.
32 -nop: Instead of running lto-wrapper, pass the original to the plugin. This
33 only works if the input files are hybrid.
34 -linker-output-known: Do not determine linker output
35 -linker-output-auto-nolto-rel: Switch from rel to nolto-rel mode without
36 warning. This is used on systems like VxWorks (kernel) where the link is
37 always partial and repeated incremental linking is generally not used.
38 -sym-style={none,win32,underscore|uscore}
44 #error POSIX threads are mandatory dependency
61 #include <sys/types.h>
63 #ifdef HAVE_SYS_WAIT_H
67 #define WIFEXITED(S) (((S) & 0xff) == 0)
70 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
72 #include <libiberty.h>
74 #include "../gcc/lto/common.h"
75 #include "simple-object.h"
76 #include "plugin-api.h"
78 /* We need to use I64 instead of ll width-specifier on native Windows.
79 The reason for this is that older MS-runtimes don't support the ll. */
86 /* Handle opening elf files on hosts, such as Windows, that may use
87 text file handling that will break binary access. */
92 /* Segment name for LTO sections. This is only used for Mach-O.
93 FIXME: This needs to be kept in sync with darwin.c. */
95 #define LTO_SEGMENT_NAME "__GNU_LTO"
97 /* Return true if STR string starts with PREFIX. */
100 startswith (const char *str
, const char *prefix
)
102 return strncmp (str
, prefix
, strlen (prefix
)) == 0;
105 /* The part of the symbol table the plugin has to keep track of. Note that we
106 must keep SYMS until all_symbols_read is called to give the linker time to
107 copy the symbol information.
108 The id must be 64bit to minimze collisions. */
113 unsigned long long id
;
114 unsigned next_conflict
;
122 struct ld_plugin_symbol
*syms
;
123 unsigned long long id
;
126 /* Encapsulates object file data during symbol scan. */
127 struct plugin_objfile
131 simple_object_read
*objfile
;
132 struct plugin_symtab
*out
;
133 const struct ld_plugin_input_file
*file
;
136 /* All that we have to remember about a file. */
138 struct plugin_file_info
142 struct plugin_symtab symtab
;
143 struct plugin_symtab conflicts
;
147 /* List item with name of the file with offloading. */
149 struct plugin_offload_file
152 struct plugin_offload_file
*next
;
155 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
156 stdio file streams, we do simple label translation here. */
160 ss_none
, /* No underscore prefix. */
161 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
162 ss_uscore
, /* Underscore prefix all symbols. */
166 static pthread_mutex_t plugin_lock
;
168 static char *arguments_file_name
;
169 static ld_plugin_register_claim_file register_claim_file
;
170 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
171 static ld_plugin_get_symbols get_symbols
, get_symbols_v2
, get_symbols_v3
;
172 static ld_plugin_register_cleanup register_cleanup
;
173 static ld_plugin_add_input_file add_input_file
;
174 static ld_plugin_add_input_library add_input_library
;
175 static ld_plugin_message message
;
176 static ld_plugin_add_symbols add_symbols
, add_symbols_v2
;
178 static struct plugin_file_info
*claimed_files
= NULL
;
179 static unsigned int num_claimed_files
= 0;
180 static unsigned int non_claimed_files
= 0;
182 /* List of files with offloading. */
183 static struct plugin_offload_file
*offload_files
;
184 /* Last file in the list. */
185 static struct plugin_offload_file
*offload_files_last
;
186 /* Last non-archive file in the list. */
187 static struct plugin_offload_file
*offload_files_last_obj
;
188 /* Last LTO file in the list. */
189 static struct plugin_offload_file
*offload_files_last_lto
;
190 /* Total number of files with offloading. */
191 static unsigned num_offload_files
;
193 static char **output_files
= NULL
;
194 static unsigned int num_output_files
= 0;
196 static char **lto_wrapper_argv
;
197 static int lto_wrapper_num_args
;
199 static char **pass_through_items
= NULL
;
200 static unsigned int num_pass_through_items
;
202 static char *ltrans_objects
= NULL
;
205 static bool save_temps
;
208 static char *resolution_file
= NULL
;
209 static enum ld_plugin_output_file_type linker_output
;
210 static bool linker_output_set
;
211 static bool linker_output_known
;
212 static bool linker_output_auto_nolto_rel
;
213 static const char *link_output_name
= NULL
;
215 /* This indicates link_output_name already contains the dot of the
216 suffix, so we can skip it in extensions. */
217 static bool skip_in_suffix
= false;
219 /* The version of gold being used, or -1 if not gold. The number is
220 MAJOR * 100 + MINOR. */
221 static int gold_version
= -1;
223 /* Not used by default, but can be overridden at runtime
224 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
225 (in fact, only first letter of style arg is checked.) */
226 static enum symbol_style sym_style
= ss_none
;
229 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
235 message (level
, text
);
238 /* If there is no nicer way to inform the user, fallback to stderr. */
239 fprintf (stderr
, "%s\n", text
);
240 if (level
== LDPL_FATAL
)
245 /* This little wrapper allows check to be called with a non-integer
246 first argument, such as a pointer that must be non-NULL. We can't
247 use c99 bool type to coerce it into range, so we explicitly test. */
248 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
250 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
251 by P and the result is written in ENTRY. The slot number is stored in SLOT.
252 Returns the address of the next entry. */
255 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
259 enum ld_plugin_symbol_kind translate_kind
[] =
268 enum ld_plugin_symbol_visibility translate_visibility
[] =
281 /* cf. Duff's device. */
283 entry
->name
= xstrdup (p
);
288 entry
->name
= concat ("_", p
, NULL
);
291 check (0, LDPL_FATAL
, "invalid symbol style requested");
298 entry
->version
= NULL
;
300 entry
->comdat_key
= p
;
305 if (strlen (entry
->comdat_key
) == 0)
306 entry
->comdat_key
= NULL
;
308 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
310 entry
->unused
= entry
->section_kind
= entry
->symbol_type
= 0;
313 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
314 entry
->def
= translate_kind
[t
];
318 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
319 entry
->visibility
= translate_visibility
[t
];
322 memcpy (&entry
->size
, p
, sizeof (uint64_t));
325 memcpy (&aux
->slot
, p
, sizeof (uint32_t));
328 entry
->resolution
= LDPR_UNKNOWN
;
330 aux
->next_conflict
= -1;
335 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
336 by P and the result is written in ENTRY. The slot number is stored in SLOT.
337 Returns the address of the next entry. */
340 parse_table_entry_extension (char *p
, struct ld_plugin_symbol
*entry
)
343 enum ld_plugin_symbol_type symbol_types
[] =
351 check (t
<= 2, LDPL_FATAL
, "invalid symbol type found");
352 entry
->symbol_type
= symbol_types
[t
];
354 entry
->section_kind
= *p
;
361 /* Translate the IL symbol table located between DATA and END. Append the
362 slots and symbols to OUT. */
365 translate (char *data
, char *end
, struct plugin_symtab
*out
)
368 struct ld_plugin_symbol
*syms
= NULL
;
371 /* This overestimates the output buffer sizes, but at least
372 the algorithm is O(1) now. */
374 len
= (end
- data
)/8 + out
->nsyms
+ 1;
375 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
376 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
378 for (n
= out
->nsyms
; data
< end
; n
++)
381 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
392 parse_symtab_extension (char *data
, char *end
, struct plugin_symtab
*out
)
395 unsigned char version
;
398 /* FIXME: Issue an error ? */
407 /* Version 1 contains the following data per entry:
412 unsigned long nsyms
= (end
- data
) / 2;
414 for (i
= 0; i
< nsyms
; i
++)
415 data
= parse_table_entry_extension (data
, out
->syms
+ i
+ out
->last_sym
);
417 out
->last_sym
+= nsyms
;
420 /* Free all memory that is no longer needed after writing the symbol
424 free_1 (struct plugin_file_info
*files
, unsigned num_files
)
427 for (i
= 0; i
< num_files
; i
++)
429 struct plugin_file_info
*info
= &files
[i
];
430 struct plugin_symtab
*symtab
= &info
->symtab
;
432 for (j
= 0; j
< symtab
->nsyms
; j
++)
434 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
436 free (s
->comdat_key
);
443 /* Free all remaining memory. */
449 for (i
= 0; i
< num_claimed_files
; i
++)
451 struct plugin_file_info
*info
= &claimed_files
[i
];
452 struct plugin_symtab
*symtab
= &info
->symtab
;
457 for (i
= 0; i
< num_output_files
; i
++)
458 free (output_files
[i
]);
461 free (claimed_files
);
462 claimed_files
= NULL
;
463 num_claimed_files
= 0;
465 while (offload_files
)
467 struct plugin_offload_file
*ofld
= offload_files
;
468 offload_files
= offload_files
->next
;
471 num_offload_files
= 0;
473 free (arguments_file_name
);
474 arguments_file_name
= NULL
;
477 /* Dump SYMTAB to resolution file F. */
480 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
484 for (j
= 0; j
< symtab
->nsyms
; j
++)
486 uint32_t slot
= symtab
->aux
[j
].slot
;
487 unsigned int resolution
= symtab
->syms
[j
].resolution
;
489 assert (resolution
!= LDPR_UNKNOWN
);
491 fprintf (f
, "%u %" PRI_LL
"x %s %s\n",
492 (unsigned int) slot
, symtab
->aux
[j
].id
,
493 lto_resolution_str
[resolution
],
494 symtab
->syms
[j
].name
);
498 /* Finish the conflicts' resolution information after the linker resolved
499 the original symbols */
502 finish_conflict_resolution (struct plugin_symtab
*symtab
,
503 struct plugin_symtab
*conflicts
)
507 if (conflicts
->nsyms
== 0)
510 for (i
= 0; i
< symtab
->nsyms
; i
++)
512 char resolution
= LDPR_UNKNOWN
;
514 if (symtab
->aux
[i
].next_conflict
== -1)
517 switch (symtab
->syms
[i
].def
)
520 case LDPK_COMMON
: /* ??? */
521 resolution
= LDPR_RESOLVED_IR
;
524 resolution
= LDPR_PREEMPTED_IR
;
528 resolution
= symtab
->syms
[i
].resolution
;
534 assert (resolution
!= LDPR_UNKNOWN
);
536 for (j
= symtab
->aux
[i
].next_conflict
;
538 j
= conflicts
->aux
[j
].next_conflict
)
539 conflicts
->syms
[j
].resolution
= resolution
;
543 /* Free symbol table SYMTAB. */
546 free_symtab (struct plugin_symtab
*symtab
)
554 /* Writes the relocations to disk. */
557 write_resolution (void)
559 unsigned int i
, included_files
= 0;
562 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
563 f
= fopen (resolution_file
, "w");
564 check (f
, LDPL_FATAL
, "could not open file");
566 for (i
= 0; i
< num_claimed_files
; i
++)
568 struct plugin_file_info
*info
= &claimed_files
[i
];
569 struct plugin_symtab
*symtab
= &info
->symtab
;
570 struct ld_plugin_symbol
*syms
= symtab
->syms
;
572 /* Version 2 of API supports IRONLY_EXP resolution that is
573 accepted by GCC-4.7 and newer.
574 Version 3 can return LDPS_NO_SYMS that means the object
575 will not be used at all. */
578 enum ld_plugin_status status
579 = get_symbols_v3 (info
->handle
, symtab
->nsyms
, syms
);
580 if (status
== LDPS_NO_SYMS
)
582 info
->skip_file
= true;
586 else if (get_symbols_v2
)
587 get_symbols_v2 (info
->handle
, symtab
->nsyms
, syms
);
589 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
593 finish_conflict_resolution (symtab
, &info
->conflicts
);
596 fprintf (f
, "%d\n", included_files
);
598 for (i
= 0; i
< num_claimed_files
; i
++)
600 struct plugin_file_info
*info
= &claimed_files
[i
];
601 struct plugin_symtab
*symtab
= &info
->symtab
;
606 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
607 dump_symtab (f
, symtab
);
608 if (info
->conflicts
.nsyms
)
610 dump_symtab (f
, &info
->conflicts
);
611 free_symtab (&info
->conflicts
);
617 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
621 add_output_files (FILE *f
)
625 const unsigned piece
= 32;
626 char *buf
, *s
= xmalloc (piece
);
631 if (!fgets (buf
, piece
, f
))
637 if (s
[len
- 1] != '\n')
639 s
= xrealloc (s
, len
+ piece
);
647 = xrealloc (output_files
, num_output_files
* sizeof (char *));
648 output_files
[num_output_files
- 1] = s
;
649 add_input_file (output_files
[num_output_files
- 1]);
653 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
657 exec_lto_wrapper (char *argv
[])
663 FILE *wrapper_output
;
668 /* Write argv to a file to avoid a command line that is too long
669 Save the file locally on save-temps. */
670 const char *suffix
= ".lto_wrapper_args";
673 if (save_temps
&& link_output_name
)
674 arguments_file_name
= concat (link_output_name
, suffix
, NULL
);
676 arguments_file_name
= make_temp_file (".lto_wrapper_args");
677 check (arguments_file_name
, LDPL_FATAL
,
678 "Failed to generate a temorary file name");
680 args
= fopen (arguments_file_name
, "w");
681 check (args
, LDPL_FATAL
, "could not open arguments file");
683 t
= writeargv (&argv
[1], args
);
684 check (t
== 0, LDPL_FATAL
, "could not write arguments");
686 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
688 at_args
= concat ("@", arguments_file_name
, NULL
);
689 check (at_args
, LDPL_FATAL
, "could not allocate");
691 for (i
= 1; argv
[i
]; i
++)
694 /* Check the input argument list for a verbose marker too. */
695 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
704 for (i
= 0; argv
[i
]; i
++)
705 fprintf (stderr
, "%s ", argv
[i
]);
706 fprintf (stderr
, "\n");
709 new_argv
[0] = argv
[0];
710 new_argv
[1] = at_args
;
715 for (i
= 0; new_argv
[i
]; i
++)
716 fprintf (stderr
, "%s ", new_argv
[i
]);
717 fprintf (stderr
, "\n");
720 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
721 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
723 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
724 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
725 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
727 wrapper_output
= pex_read_output (pex
, 0);
728 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
730 add_output_files (wrapper_output
);
732 t
= pex_get_status (pex
, 1, &status
);
733 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
734 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
735 "lto-wrapper failed");
742 /* Pass the original files back to the linker. */
745 use_original_files (void)
748 for (i
= 0; i
< num_claimed_files
; i
++)
750 struct plugin_file_info
*info
= &claimed_files
[i
];
751 add_input_file (info
->name
);
756 /* Called by the linker once all symbols have been read. */
758 static enum ld_plugin_status
759 all_symbols_read_handler (void)
761 const unsigned num_lto_args
762 = num_claimed_files
+ lto_wrapper_num_args
+ 2
763 + !linker_output_known
+ !linker_output_auto_nolto_rel
;
766 const char *linker_output_str
= NULL
;
767 const char **lto_arg_ptr
;
768 if (num_claimed_files
+ num_offload_files
== 0)
773 use_original_files ();
779 FILE *objs
= fopen (ltrans_objects
, "r");
780 add_output_files (objs
);
785 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
786 lto_arg_ptr
= (const char **) lto_argv
;
787 assert (lto_wrapper_argv
);
791 free_1 (claimed_files
, num_claimed_files
);
793 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
794 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
796 if (!linker_output_known
)
798 assert (linker_output_set
);
799 switch (linker_output
)
802 if (non_claimed_files
)
804 if (!linker_output_auto_nolto_rel
)
805 message (LDPL_WARNING
, "incremental linking of LTO and non-LTO"
806 " objects; using -flinker-output=nolto-rel which will"
807 " bypass whole program optimization");
808 linker_output_str
= "-flinker-output=nolto-rel";
811 linker_output_str
= "-flinker-output=rel";
814 linker_output_str
= "-flinker-output=dyn";
817 linker_output_str
= "-flinker-output=pie";
820 linker_output_str
= "-flinker-output=exec";
823 message (LDPL_FATAL
, "unsupported linker output %i", linker_output
);
826 *lto_arg_ptr
++ = xstrdup (linker_output_str
);
829 if (num_offload_files
> 0)
833 char *offload_objects_file_name
;
834 struct plugin_offload_file
*ofld
;
835 const char *suffix
= ".ofldlist";
837 if (save_temps
&& link_output_name
)
839 suffix
+= skip_in_suffix
;
840 offload_objects_file_name
= concat (link_output_name
, suffix
, NULL
);
843 offload_objects_file_name
= make_temp_file (suffix
);
844 check (offload_objects_file_name
, LDPL_FATAL
,
845 "Failed to generate a temporary file name");
846 f
= fopen (offload_objects_file_name
, "w");
847 check (f
, LDPL_FATAL
, "could not open file with offload objects");
848 fprintf (f
, "%u\n", num_offload_files
);
850 /* Skip the dummy item at the start of the list. */
851 ofld
= offload_files
->next
;
854 fprintf (f
, "%s\n", ofld
->name
);
859 arg
= concat ("-foffload-objects=", offload_objects_file_name
, NULL
);
860 check (arg
, LDPL_FATAL
, "could not allocate");
861 *lto_arg_ptr
++ = arg
;
864 for (i
= 0; i
< num_claimed_files
; i
++)
866 struct plugin_file_info
*info
= &claimed_files
[i
];
868 if (!info
->skip_file
)
869 *lto_arg_ptr
++ = info
->name
;
872 *lto_arg_ptr
++ = NULL
;
873 exec_lto_wrapper (lto_argv
);
877 /* --pass-through is not needed when using gold 1.11 or later. */
878 if (pass_through_items
&& gold_version
< 111)
881 for (i
= 0; i
< num_pass_through_items
; i
++)
883 if (startswith (pass_through_items
[i
], "-l"))
884 add_input_library (pass_through_items
[i
] + 2);
886 add_input_file (pass_through_items
[i
]);
887 free (pass_through_items
[i
]);
888 pass_through_items
[i
] = NULL
;
890 free (pass_through_items
);
891 pass_through_items
= NULL
;
897 /* Helper, as used in collect2. */
899 file_exists (const char *name
)
901 return access (name
, R_OK
) == 0;
904 /* Unlink FILE unless we have save-temps set.
905 Note that we're saving files if verbose output is set. */
908 maybe_unlink (const char *file
)
910 if (save_temps
&& file_exists (file
))
913 fprintf (stderr
, "[Leaving %s]\n", file
);
917 unlink_if_ordinary (file
);
920 /* Remove temporary files at the end of the link. */
922 static enum ld_plugin_status
923 cleanup_handler (void)
930 if (arguments_file_name
)
931 maybe_unlink (arguments_file_name
);
933 for (i
= 0; i
< num_output_files
; i
++)
934 maybe_unlink (output_files
[i
]);
940 #define SWAP(type, a, b) \
941 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
943 /* Compare two hash table entries */
945 static int eq_sym (const void *a
, const void *b
)
947 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
948 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
950 return !strcmp (as
->name
, bs
->name
);
955 static hashval_t
hash_sym (const void *a
)
957 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
959 return htab_hash_string (as
->name
);
962 /* Determine how strong a symbol is */
964 static int symbol_strength (struct ld_plugin_symbol
*s
)
978 /* In the ld -r case we can get dups in the LTO symbol tables, where
979 the same symbol can have different resolutions (e.g. undefined and defined).
981 We have to keep that in the LTO symbol tables, but the dups confuse
982 gold and then finally gcc by supplying incorrect resolutions.
984 Problem is that the main gold symbol table doesn't know about subids
985 and does not distingush the same symbols in different states.
987 So we drop duplicates from the linker visible symbol table
988 and keep them in a private table. Then later do own symbol
989 resolution for the duplicated based on the results for the
992 Then when writing out the resolution file readd the dropped symbols.
994 XXX how to handle common? */
997 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
999 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
1005 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
1006 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
1008 /* Move all duplicate symbols into the auxiliary conflicts table. */
1010 for (i
= 0; i
< t
->nsyms
; i
++)
1012 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
1013 struct sym_aux
*aux
= &t
->aux
[i
];
1016 slot
= htab_find_slot (symtab
, s
, INSERT
);
1020 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
1021 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
1023 /* Always let the linker resolve the strongest symbol */
1024 if (symbol_strength (orig
) < symbol_strength (s
))
1026 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
1027 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
1028 SWAP (unsigned long long, orig_aux
->id
, aux
->id
);
1029 /* Don't swap conflict chain pointer */
1032 /* Move current symbol into the conflicts table */
1033 cnf
= conflicts
->nsyms
++;
1034 conflicts
->syms
[cnf
] = *s
;
1035 conflicts
->aux
[cnf
] = *aux
;
1036 aux
= &conflicts
->aux
[cnf
];
1038 /* Update conflicts chain of the original symbol */
1039 aux
->next_conflict
= orig_aux
->next_conflict
;
1040 orig_aux
->next_conflict
= cnf
;
1045 /* Remove previous duplicates in the main table */
1052 /* Put original into the hash table */
1053 *slot
= &t
->syms
[out
];
1057 assert (conflicts
->nsyms
<= outlen
);
1058 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
1061 htab_delete (symtab
);
1064 /* Process one section of an object file. */
1067 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
1069 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1071 char *secdatastart
, *secdata
;
1073 if (!startswith (name
, ".gnu.lto_.symtab"))
1076 s
= strrchr (name
, '.');
1078 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1079 secdata
= secdatastart
= xmalloc (length
);
1080 offset
+= obj
->file
->offset
;
1081 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1086 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1094 else if (errno
!= EINTR
)
1101 translate (secdatastart
, secdata
, obj
->out
);
1103 free (secdatastart
);
1108 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1109 /* Force claim_file_handler to abandon this file. */
1111 free (secdatastart
);
1115 /* Process one section of an object file. */
1118 process_symtab_extension (void *data
, const char *name
, off_t offset
,
1121 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1123 char *secdatastart
, *secdata
;
1125 if (!startswith (name
, ".gnu.lto_.ext_symtab"))
1128 s
= strrchr (name
, '.');
1130 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1131 secdata
= secdatastart
= xmalloc (length
);
1132 offset
+= obj
->file
->offset
;
1133 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1138 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1146 else if (errno
!= EINTR
)
1153 parse_symtab_extension (secdatastart
, secdata
, obj
->out
);
1155 free (secdatastart
);
1160 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1161 /* Force claim_file_handler to abandon this file. */
1163 free (secdatastart
);
1168 /* Find an offload section of an object file. */
1171 process_offload_section (void *data
, const char *name
, off_t offset
, off_t len
)
1173 if (startswith (name
, ".gnu.offload_lto_.opts"))
1175 struct plugin_objfile
*obj
= (struct plugin_objfile
*) data
;
1176 obj
->offload
= true;
1183 /* Callback used by a linker to check if the plugin will claim FILE. Writes
1184 the result in CLAIMED. */
1186 static enum ld_plugin_status
1187 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
1189 enum ld_plugin_status status
;
1190 struct plugin_objfile obj
;
1191 struct plugin_file_info lto_file
;
1195 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
1197 if (file
->offset
!= 0)
1199 /* We pass the offset of the actual file, not the archive header.
1200 Can't use PRIx64, because that's C99, so we have to print the
1201 64-bit hex int as two 32-bit ones. Use xasprintf instead of
1202 asprintf because asprintf doesn't work as expected on some older
1205 lo
= file
->offset
& 0xffffffff;
1206 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
1207 lto_file
.name
= hi
? xasprintf ("%s@0x%x%08x", file
->name
, hi
, lo
)
1208 : xasprintf ("%s@0x%x", file
->name
, lo
);
1212 lto_file
.name
= xstrdup (file
->name
);
1214 lto_file
.handle
= file
->handle
;
1219 obj
.offload
= false;
1220 obj
.out
= <o_file
.symtab
;
1222 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
1224 /* No file, but also no error code means unrecognized format; just skip it. */
1225 if (!obj
.objfile
&& !err
)
1230 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
,
1232 /* Parsing symtab extension should be done only for add_symbols_v2 and
1234 if (!errmsg
&& add_symbols_v2
!= NULL
)
1236 obj
.out
->last_sym
= 0;
1237 errmsg
= simple_object_find_sections (obj
.objfile
,
1238 process_symtab_extension
,
1243 if (!obj
.objfile
|| errmsg
)
1246 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
1249 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
1254 simple_object_find_sections (obj
.objfile
, process_offload_section
,
1257 if (obj
.found
== 0 && !obj
.offload
)
1261 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
1266 status
= add_symbols_v2 (file
->handle
, lto_file
.symtab
.nsyms
,
1267 lto_file
.symtab
.syms
);
1269 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
1270 lto_file
.symtab
.syms
);
1271 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
1273 pthread_mutex_lock (&plugin_lock
);
1274 num_claimed_files
++;
1276 xrealloc (claimed_files
,
1277 num_claimed_files
* sizeof (struct plugin_file_info
));
1278 claimed_files
[num_claimed_files
- 1] = lto_file
;
1279 pthread_mutex_unlock (&plugin_lock
);
1284 pthread_mutex_lock (&plugin_lock
);
1285 if (offload_files
== NULL
)
1287 /* Add dummy item to the start of the list. */
1288 offload_files
= xmalloc (sizeof (struct plugin_offload_file
));
1289 offload_files
->name
= NULL
;
1290 offload_files
->next
= NULL
;
1291 offload_files_last
= offload_files
;
1294 /* If this is an LTO file without offload, and it is the first LTO file, save
1295 the pointer to the last offload file in the list. Further offload LTO
1296 files will be inserted after it, if any. */
1297 if (*claimed
&& !obj
.offload
&& offload_files_last_lto
== NULL
)
1298 offload_files_last_lto
= offload_files_last
;
1302 /* Add file to the list. The order must be exactly the same as the final
1303 order after recompilation and linking, otherwise host and target tables
1304 with addresses wouldn't match. If a static library contains both LTO
1305 and non-LTO objects, ld and gold link them in a different order. */
1306 struct plugin_offload_file
*ofld
1307 = xmalloc (sizeof (struct plugin_offload_file
));
1308 ofld
->name
= lto_file
.name
;
1311 if (*claimed
&& offload_files_last_lto
== NULL
&& file
->offset
!= 0
1312 && gold_version
== -1)
1314 /* ld only: insert first LTO file from the archive after the last real
1315 object file immediately preceding the archive, or at the begin of
1316 the list if there was no real objects before archives. */
1317 if (offload_files_last_obj
!= NULL
)
1319 ofld
->next
= offload_files_last_obj
->next
;
1320 offload_files_last_obj
->next
= ofld
;
1324 ofld
->next
= offload_files
->next
;
1325 offload_files
->next
= ofld
;
1328 else if (*claimed
&& offload_files_last_lto
!= NULL
)
1330 /* Insert LTO file after the last LTO file in the list. */
1331 ofld
->next
= offload_files_last_lto
->next
;
1332 offload_files_last_lto
->next
= ofld
;
1335 /* Add non-LTO file or first non-archive LTO file to the end of the
1337 offload_files_last
->next
= ofld
;
1339 if (ofld
->next
== NULL
)
1340 offload_files_last
= ofld
;
1341 if (file
->offset
== 0)
1342 offload_files_last_obj
= ofld
;
1344 offload_files_last_lto
= ofld
;
1345 num_offload_files
++;
1347 pthread_mutex_unlock (&plugin_lock
);
1352 pthread_mutex_lock (&plugin_lock
);
1353 non_claimed_files
++;
1354 pthread_mutex_unlock (&plugin_lock
);
1355 free (lto_file
.name
);
1359 simple_object_release_read (obj
.objfile
);
1364 /* Parse the plugin options. */
1367 process_option (const char *option
)
1369 if (strcmp (option
, "-linker-output-known") == 0)
1370 linker_output_known
= true;
1371 /* Also accept "notlo" for backwards compatibility. */
1372 else if ((strcmp (option
, "-linker-output-auto-nolto-rel") == 0)
1373 || (strcmp (option
, "-linker-output-auto-notlo-rel") == 0))
1374 linker_output_auto_nolto_rel
= true;
1375 else if (strcmp (option
, "-debug") == 0)
1377 else if ((strcmp (option
, "-v") == 0)
1378 || (strcmp (option
, "--verbose") == 0))
1380 else if (strcmp (option
, "-save-temps") == 0)
1382 else if (strcmp (option
, "-nop") == 0)
1384 else if (startswith (option
, "-pass-through="))
1386 num_pass_through_items
++;
1387 pass_through_items
= xrealloc (pass_through_items
,
1388 num_pass_through_items
* sizeof (char *));
1389 pass_through_items
[num_pass_through_items
- 1] =
1390 xstrdup (option
+ strlen ("-pass-through="));
1392 else if (startswith (option
, "-sym-style="))
1394 switch (option
[sizeof ("-sym-style=") - 1])
1397 sym_style
= ss_win32
;
1400 sym_style
= ss_uscore
;
1403 sym_style
= ss_none
;
1407 else if (startswith (option
, "-ltrans-objects="))
1408 ltrans_objects
= xstrdup (option
+ strlen ("-ltrans-objects="));
1412 char *opt
= xstrdup (option
);
1413 lto_wrapper_num_args
+= 1;
1414 size
= lto_wrapper_num_args
* sizeof (char *);
1415 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
1416 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
1417 if (startswith (option
, "-fresolution="))
1418 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
1420 save_temps
= save_temps
|| debug
;
1421 verbose
= verbose
|| debug
;
1424 /* Called by a linker after loading the plugin. TV is the transfer vector. */
1426 enum ld_plugin_status
1427 onload (struct ld_plugin_tv
*tv
)
1429 struct ld_plugin_tv
*p
;
1430 enum ld_plugin_status status
;
1432 if (pthread_mutex_init (&plugin_lock
, NULL
) != 0)
1434 fprintf (stderr
, "mutex init failed\n");
1444 message
= p
->tv_u
.tv_message
;
1446 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1447 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
1449 case LDPT_ADD_SYMBOLS_V2
:
1450 add_symbols_v2
= p
->tv_u
.tv_add_symbols
;
1452 case LDPT_ADD_SYMBOLS
:
1453 add_symbols
= p
->tv_u
.tv_add_symbols
;
1455 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1456 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
1458 case LDPT_GET_SYMBOLS_V3
:
1459 get_symbols_v3
= p
->tv_u
.tv_get_symbols
;
1461 case LDPT_GET_SYMBOLS_V2
:
1462 get_symbols_v2
= p
->tv_u
.tv_get_symbols
;
1464 case LDPT_GET_SYMBOLS
:
1465 get_symbols
= p
->tv_u
.tv_get_symbols
;
1467 case LDPT_REGISTER_CLEANUP_HOOK
:
1468 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
1470 case LDPT_ADD_INPUT_FILE
:
1471 add_input_file
= p
->tv_u
.tv_add_input_file
;
1473 case LDPT_ADD_INPUT_LIBRARY
:
1474 add_input_library
= p
->tv_u
.tv_add_input_library
;
1477 process_option (p
->tv_u
.tv_string
);
1479 case LDPT_GOLD_VERSION
:
1480 gold_version
= p
->tv_u
.tv_val
;
1482 case LDPT_LINKER_OUTPUT
:
1483 linker_output
= (enum ld_plugin_output_file_type
) p
->tv_u
.tv_val
;
1484 linker_output_set
= true;
1486 case LDPT_OUTPUT_NAME
:
1487 /* We only use this to make user-friendly temp file names. */
1488 link_output_name
= p
->tv_u
.tv_string
;
1496 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1497 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1498 status
= register_claim_file (claim_file_handler
);
1499 check (status
== LDPS_OK
, LDPL_FATAL
,
1500 "could not register the claim_file callback");
1502 if (register_cleanup
)
1504 status
= register_cleanup (cleanup_handler
);
1505 check (status
== LDPS_OK
, LDPL_FATAL
,
1506 "could not register the cleanup callback");
1509 if (register_all_symbols_read
)
1511 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1512 status
= register_all_symbols_read (all_symbols_read_handler
);
1513 check (status
== LDPS_OK
, LDPL_FATAL
,
1514 "could not register the all_symbols_read callback");
1517 char *collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1518 if (collect_gcc_options
)
1520 /* Support -fno-use-linker-plugin by failing to load the plugin
1521 for the case where it is auto-loaded by BFD. */
1522 if (strstr (collect_gcc_options
, "'-fno-use-linker-plugin'"))
1525 if (strstr (collect_gcc_options
, "'-save-temps'"))
1528 if (strstr (collect_gcc_options
, "'-v'")
1529 || strstr (collect_gcc_options
, "'--verbose'"))
1533 if ((p
= strstr (collect_gcc_options
, "'-dumpdir'")))
1535 p
+= sizeof ("'-dumpdir'");
1538 const char *start
= p
;
1539 int ticks
= 0, escapes
= 0;
1540 /* Count ticks (') and escaped (\.) characters. Stop at the
1541 end of the options or at a blank after an even number of
1542 ticks (not counting escaped ones. */
1543 for (p
= start
; *p
; p
++)
1550 else if ((ticks
% 2) != 0)
1564 /* Now allocate a new link_output_name and decode dumpdir
1565 into it. The loop uses the same logic, except it counts
1566 ticks and escapes backwards (so ticks is adjusted if we
1567 find an odd number of them), and it copies characters
1568 that are escaped or not otherwise skipped. */
1569 int len
= p
- start
- ticks
- escapes
+ 1;
1570 char *q
= xmalloc (len
);
1571 link_output_name
= q
;
1572 int oddticks
= (ticks
% 2);
1574 for (p
= start
; *p
; p
++)
1581 else if ((ticks
% 2) != 0)
1596 assert (escapes
== 0);
1597 assert (ticks
== oddticks
);
1598 assert (q
- link_output_name
== len
- 1);
1599 skip_in_suffix
= true;