1 /* LTO plugin for linkers like gold, GNU ld or mold.
2 Copyright (C) 2009-2023 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}
57 #include <sys/types.h>
58 #if HAVE_PTHREAD_LOCKING
61 #ifdef HAVE_SYS_WAIT_H
65 #define WIFEXITED(S) (((S) & 0xff) == 0)
68 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
70 #include <libiberty.h>
72 #include "../gcc/lto/common.h"
73 #include "simple-object.h"
74 #include "plugin-api.h"
76 /* We need to use I64 instead of ll width-specifier on native Windows.
77 The reason for this is that older MS-runtimes don't support the ll. */
84 /* Handle opening elf files on hosts, such as Windows, that may use
85 text file handling that will break binary access. */
90 /* Segment name for LTO sections. This is only used for Mach-O.
91 FIXME: This needs to be kept in sync with darwin.c. */
93 #define LTO_SEGMENT_NAME "__GNU_LTO"
95 /* Return true if STR string starts with PREFIX. */
98 startswith (const char *str
, const char *prefix
)
100 return strncmp (str
, prefix
, strlen (prefix
)) == 0;
103 /* The part of the symbol table the plugin has to keep track of. Note that we
104 must keep SYMS until all_symbols_read is called to give the linker time to
105 copy the symbol information.
106 The id must be 64bit to minimze collisions. */
111 unsigned long long id
;
112 unsigned next_conflict
;
120 struct ld_plugin_symbol
*syms
;
121 unsigned long long id
;
124 /* Encapsulates object file data during symbol scan. */
125 struct plugin_objfile
129 simple_object_read
*objfile
;
130 struct plugin_symtab
*out
;
131 const struct ld_plugin_input_file
*file
;
134 /* All that we have to remember about a file. */
136 struct plugin_file_info
140 struct plugin_symtab symtab
;
141 struct plugin_symtab conflicts
;
145 /* List item with name of the file with offloading. */
147 struct plugin_offload_file
150 struct plugin_offload_file
*next
;
153 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
154 stdio file streams, we do simple label translation here. */
158 ss_none
, /* No underscore prefix. */
159 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
160 ss_uscore
, /* Underscore prefix all symbols. */
163 #if HAVE_PTHREAD_LOCKING
165 static pthread_mutex_t plugin_lock
;
167 #define LOCK_SECTION pthread_mutex_lock (&plugin_lock)
168 #define UNLOCK_SECTION pthread_mutex_unlock (&plugin_lock)
171 #define UNLOCK_SECTION
174 static char *arguments_file_name
;
175 static ld_plugin_register_claim_file register_claim_file
;
176 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
177 static ld_plugin_get_symbols get_symbols
, get_symbols_v2
, get_symbols_v3
;
178 static ld_plugin_register_cleanup register_cleanup
;
179 static ld_plugin_add_input_file add_input_file
;
180 static ld_plugin_add_input_library add_input_library
;
181 static ld_plugin_message message
;
182 static ld_plugin_add_symbols add_symbols
, add_symbols_v2
;
183 static ld_plugin_get_api_version get_api_version
;
185 /* By default, use version LAPI_V0 if there is not negotiation. */
186 static enum linker_api_version api_version
= LAPI_V0
;
188 static struct plugin_file_info
*claimed_files
= NULL
;
189 static unsigned int num_claimed_files
= 0;
190 static unsigned int non_claimed_files
= 0;
192 /* List of files with offloading. */
193 static struct plugin_offload_file
*offload_files
;
194 /* Last file in the list. */
195 static struct plugin_offload_file
*offload_files_last
;
196 /* Last non-archive file in the list. */
197 static struct plugin_offload_file
*offload_files_last_obj
;
198 /* Last LTO file in the list. */
199 static struct plugin_offload_file
*offload_files_last_lto
;
200 /* Total number of files with offloading. */
201 static unsigned num_offload_files
;
203 static char **output_files
= NULL
;
204 static unsigned int num_output_files
= 0;
206 static char **lto_wrapper_argv
;
207 static int lto_wrapper_num_args
;
209 static char **pass_through_items
= NULL
;
210 static unsigned int num_pass_through_items
;
212 static char *ltrans_objects
= NULL
;
215 static bool save_temps
;
218 static char *resolution_file
= NULL
;
219 static enum ld_plugin_output_file_type linker_output
;
220 static bool linker_output_set
;
221 static bool linker_output_known
;
222 static bool linker_output_auto_nolto_rel
;
223 static const char *link_output_name
= NULL
;
225 /* This indicates link_output_name already contains the dot of the
226 suffix, so we can skip it in extensions. */
227 static bool skip_in_suffix
= false;
229 /* The version of gold being used, or -1 if not gold. The number is
230 MAJOR * 100 + MINOR. */
231 static int gold_version
= -1;
233 /* Not used by default, but can be overridden at runtime
234 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
235 (in fact, only first letter of style arg is checked.) */
236 static enum symbol_style sym_style
= ss_none
;
239 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
245 message (level
, text
);
248 /* If there is no nicer way to inform the user, fallback to stderr. */
249 fprintf (stderr
, "%s\n", text
);
250 if (level
== LDPL_FATAL
)
255 /* This little wrapper allows check to be called with a non-integer
256 first argument, such as a pointer that must be non-NULL. We can't
257 use c99 bool type to coerce it into range, so we explicitly test. */
258 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
260 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
261 by P and the result is written in ENTRY. The slot number is stored in SLOT.
262 Returns the address of the next entry. */
265 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
269 enum ld_plugin_symbol_kind translate_kind
[] =
278 enum ld_plugin_symbol_visibility translate_visibility
[] =
291 /* cf. Duff's device. */
293 entry
->name
= xstrdup (p
);
298 entry
->name
= concat ("_", p
, NULL
);
301 check (0, LDPL_FATAL
, "invalid symbol style requested");
308 entry
->version
= NULL
;
310 entry
->comdat_key
= p
;
315 if (strlen (entry
->comdat_key
) == 0)
316 entry
->comdat_key
= NULL
;
318 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
320 entry
->unused
= entry
->section_kind
= entry
->symbol_type
= 0;
323 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
324 entry
->def
= translate_kind
[t
];
328 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
329 entry
->visibility
= translate_visibility
[t
];
332 memcpy (&entry
->size
, p
, sizeof (uint64_t));
335 memcpy (&aux
->slot
, p
, sizeof (uint32_t));
338 entry
->resolution
= LDPR_UNKNOWN
;
340 aux
->next_conflict
= -1;
345 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
346 by P and the result is written in ENTRY. The slot number is stored in SLOT.
347 Returns the address of the next entry. */
350 parse_table_entry_extension (char *p
, struct ld_plugin_symbol
*entry
)
353 enum ld_plugin_symbol_type symbol_types
[] =
361 check (t
<= 2, LDPL_FATAL
, "invalid symbol type found");
362 entry
->symbol_type
= symbol_types
[t
];
364 entry
->section_kind
= *p
;
371 /* Translate the IL symbol table located between DATA and END. Append the
372 slots and symbols to OUT. */
375 translate (char *data
, char *end
, struct plugin_symtab
*out
)
378 struct ld_plugin_symbol
*syms
= NULL
;
381 /* This overestimates the output buffer sizes, but at least
382 the algorithm is O(1) now. */
384 len
= (end
- data
)/8 + out
->nsyms
+ 1;
385 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
386 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
388 for (n
= out
->nsyms
; data
< end
; n
++)
391 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
402 parse_symtab_extension (char *data
, char *end
, struct plugin_symtab
*out
)
405 unsigned char version
;
408 /* FIXME: Issue an error ? */
417 /* Version 1 contains the following data per entry:
422 unsigned long nsyms
= (end
- data
) / 2;
424 for (i
= 0; i
< nsyms
; i
++)
425 data
= parse_table_entry_extension (data
, out
->syms
+ i
+ out
->last_sym
);
427 out
->last_sym
+= nsyms
;
430 /* Free all memory that is no longer needed after writing the symbol
434 free_1 (struct plugin_file_info
*files
, unsigned num_files
)
437 for (i
= 0; i
< num_files
; i
++)
439 struct plugin_file_info
*info
= &files
[i
];
440 struct plugin_symtab
*symtab
= &info
->symtab
;
442 for (j
= 0; j
< symtab
->nsyms
; j
++)
444 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
446 free (s
->comdat_key
);
453 /* Free all remaining memory. */
459 for (i
= 0; i
< num_claimed_files
; i
++)
461 struct plugin_file_info
*info
= &claimed_files
[i
];
462 struct plugin_symtab
*symtab
= &info
->symtab
;
467 for (i
= 0; i
< num_output_files
; i
++)
468 free (output_files
[i
]);
471 free (claimed_files
);
472 claimed_files
= NULL
;
473 num_claimed_files
= 0;
475 while (offload_files
)
477 struct plugin_offload_file
*ofld
= offload_files
;
478 offload_files
= offload_files
->next
;
481 num_offload_files
= 0;
483 free (arguments_file_name
);
484 arguments_file_name
= NULL
;
487 /* Dump SYMTAB to resolution file F. */
490 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
494 for (j
= 0; j
< symtab
->nsyms
; j
++)
496 uint32_t slot
= symtab
->aux
[j
].slot
;
497 unsigned int resolution
= symtab
->syms
[j
].resolution
;
499 assert (resolution
!= LDPR_UNKNOWN
);
501 fprintf (f
, "%u %" PRI_LL
"x %s %s\n",
502 (unsigned int) slot
, symtab
->aux
[j
].id
,
503 lto_resolution_str
[resolution
],
504 symtab
->syms
[j
].name
);
508 /* Finish the conflicts' resolution information after the linker resolved
509 the original symbols */
512 finish_conflict_resolution (struct plugin_symtab
*symtab
,
513 struct plugin_symtab
*conflicts
)
517 if (conflicts
->nsyms
== 0)
520 for (i
= 0; i
< symtab
->nsyms
; i
++)
522 char resolution
= LDPR_UNKNOWN
;
524 if (symtab
->aux
[i
].next_conflict
== -1)
527 switch (symtab
->syms
[i
].def
)
530 case LDPK_COMMON
: /* ??? */
531 resolution
= LDPR_RESOLVED_IR
;
534 resolution
= LDPR_PREEMPTED_IR
;
538 resolution
= symtab
->syms
[i
].resolution
;
544 assert (resolution
!= LDPR_UNKNOWN
);
546 for (j
= symtab
->aux
[i
].next_conflict
;
548 j
= conflicts
->aux
[j
].next_conflict
)
549 conflicts
->syms
[j
].resolution
= resolution
;
553 /* Free symbol table SYMTAB. */
556 free_symtab (struct plugin_symtab
*symtab
)
564 /* Writes the relocations to disk. */
567 write_resolution (void)
569 unsigned int i
, included_files
= 0;
572 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
573 f
= fopen (resolution_file
, "w");
574 check (f
, LDPL_FATAL
, "could not open file");
576 for (i
= 0; i
< num_claimed_files
; i
++)
578 struct plugin_file_info
*info
= &claimed_files
[i
];
579 struct plugin_symtab
*symtab
= &info
->symtab
;
580 struct ld_plugin_symbol
*syms
= symtab
->syms
;
582 /* Version 2 of API supports IRONLY_EXP resolution that is
583 accepted by GCC-4.7 and newer.
584 Version 3 can return LDPS_NO_SYMS that means the object
585 will not be used at all. */
588 enum ld_plugin_status status
589 = get_symbols_v3 (info
->handle
, symtab
->nsyms
, syms
);
590 if (status
== LDPS_NO_SYMS
)
592 info
->skip_file
= true;
596 else if (get_symbols_v2
)
597 get_symbols_v2 (info
->handle
, symtab
->nsyms
, syms
);
599 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
603 finish_conflict_resolution (symtab
, &info
->conflicts
);
606 fprintf (f
, "%d\n", included_files
);
608 for (i
= 0; i
< num_claimed_files
; i
++)
610 struct plugin_file_info
*info
= &claimed_files
[i
];
611 struct plugin_symtab
*symtab
= &info
->symtab
;
616 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
617 dump_symtab (f
, symtab
);
618 if (info
->conflicts
.nsyms
)
620 dump_symtab (f
, &info
->conflicts
);
621 free_symtab (&info
->conflicts
);
627 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
631 add_output_files (FILE *f
)
635 const unsigned piece
= 32;
636 char *buf
, *s
= xmalloc (piece
);
641 if (!fgets (buf
, piece
, f
))
647 if (s
[len
- 1] != '\n')
649 s
= xrealloc (s
, len
+ piece
);
657 = xrealloc (output_files
, num_output_files
* sizeof (char *));
658 output_files
[num_output_files
- 1] = s
;
659 add_input_file (output_files
[num_output_files
- 1]);
663 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
667 exec_lto_wrapper (char *argv
[])
673 FILE *wrapper_output
;
678 /* Write argv to a file to avoid a command line that is too long
679 Save the file locally on save-temps. */
680 const char *suffix
= ".lto_wrapper_args";
683 if (save_temps
&& link_output_name
)
684 arguments_file_name
= concat (link_output_name
, suffix
, NULL
);
686 arguments_file_name
= make_temp_file (".lto_wrapper_args");
687 check (arguments_file_name
, LDPL_FATAL
,
688 "Failed to generate a temorary file name");
690 args
= fopen (arguments_file_name
, "w");
691 check (args
, LDPL_FATAL
, "could not open arguments file");
693 t
= writeargv (&argv
[1], args
);
694 check (t
== 0, LDPL_FATAL
, "could not write arguments");
696 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
698 at_args
= concat ("@", arguments_file_name
, NULL
);
699 check (at_args
, LDPL_FATAL
, "could not allocate");
701 for (i
= 1; argv
[i
]; i
++)
704 /* Check the input argument list for a verbose marker too. */
705 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
714 for (i
= 0; argv
[i
]; i
++)
715 fprintf (stderr
, "%s ", argv
[i
]);
716 fprintf (stderr
, "\n");
719 new_argv
[0] = argv
[0];
720 new_argv
[1] = at_args
;
725 for (i
= 0; new_argv
[i
]; i
++)
726 fprintf (stderr
, "%s ", new_argv
[i
]);
727 fprintf (stderr
, "\n");
730 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
731 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
733 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
734 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
735 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
737 wrapper_output
= pex_read_output (pex
, 0);
738 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
740 add_output_files (wrapper_output
);
742 t
= pex_get_status (pex
, 1, &status
);
743 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
744 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
745 "lto-wrapper failed");
752 /* Pass the original files back to the linker. */
755 use_original_files (void)
758 for (i
= 0; i
< num_claimed_files
; i
++)
760 struct plugin_file_info
*info
= &claimed_files
[i
];
761 add_input_file (info
->name
);
766 /* Called by the linker once all symbols have been read. */
768 static enum ld_plugin_status
769 all_symbols_read_handler (void)
771 const unsigned num_lto_args
772 = num_claimed_files
+ lto_wrapper_num_args
+ 2
773 + !linker_output_known
+ !linker_output_auto_nolto_rel
;
776 const char *linker_output_str
= NULL
;
777 const char **lto_arg_ptr
;
778 if (num_claimed_files
+ num_offload_files
== 0)
783 use_original_files ();
789 FILE *objs
= fopen (ltrans_objects
, "r");
790 add_output_files (objs
);
795 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
796 lto_arg_ptr
= (const char **) lto_argv
;
797 assert (lto_wrapper_argv
);
801 free_1 (claimed_files
, num_claimed_files
);
803 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
804 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
806 if (!linker_output_known
)
808 assert (linker_output_set
);
809 switch (linker_output
)
812 if (non_claimed_files
)
814 if (!linker_output_auto_nolto_rel
)
815 message (LDPL_WARNING
, "incremental linking of LTO and non-LTO"
816 " objects; using -flinker-output=nolto-rel which will"
817 " bypass whole program optimization");
818 linker_output_str
= "-flinker-output=nolto-rel";
821 linker_output_str
= "-flinker-output=rel";
824 linker_output_str
= "-flinker-output=dyn";
827 linker_output_str
= "-flinker-output=pie";
830 linker_output_str
= "-flinker-output=exec";
833 message (LDPL_FATAL
, "unsupported linker output %i", linker_output
);
836 *lto_arg_ptr
++ = xstrdup (linker_output_str
);
839 if (num_offload_files
> 0)
843 char *offload_objects_file_name
;
844 struct plugin_offload_file
*ofld
;
845 const char *suffix
= ".ofldlist";
847 if (save_temps
&& link_output_name
)
849 suffix
+= skip_in_suffix
;
850 offload_objects_file_name
= concat (link_output_name
, suffix
, NULL
);
853 offload_objects_file_name
= make_temp_file (suffix
);
854 check (offload_objects_file_name
, LDPL_FATAL
,
855 "Failed to generate a temporary file name");
856 f
= fopen (offload_objects_file_name
, "w");
857 check (f
, LDPL_FATAL
, "could not open file with offload objects");
858 fprintf (f
, "%u\n", num_offload_files
);
860 /* Skip the dummy item at the start of the list. */
861 ofld
= offload_files
->next
;
864 fprintf (f
, "%s\n", ofld
->name
);
869 arg
= concat ("-foffload-objects=", offload_objects_file_name
, NULL
);
870 check (arg
, LDPL_FATAL
, "could not allocate");
871 *lto_arg_ptr
++ = arg
;
874 for (i
= 0; i
< num_claimed_files
; i
++)
876 struct plugin_file_info
*info
= &claimed_files
[i
];
878 if (!info
->skip_file
)
879 *lto_arg_ptr
++ = info
->name
;
882 *lto_arg_ptr
++ = NULL
;
883 exec_lto_wrapper (lto_argv
);
887 /* --pass-through is not needed when using gold 1.11 or later. */
888 if (pass_through_items
&& gold_version
< 111)
891 for (i
= 0; i
< num_pass_through_items
; i
++)
893 if (startswith (pass_through_items
[i
], "-l"))
894 add_input_library (pass_through_items
[i
] + 2);
896 add_input_file (pass_through_items
[i
]);
897 free (pass_through_items
[i
]);
898 pass_through_items
[i
] = NULL
;
900 free (pass_through_items
);
901 pass_through_items
= NULL
;
907 /* Helper, as used in collect2. */
909 file_exists (const char *name
)
911 return access (name
, R_OK
) == 0;
914 /* Unlink FILE unless we have save-temps set.
915 Note that we're saving files if verbose output is set. */
918 maybe_unlink (const char *file
)
920 if (save_temps
&& file_exists (file
))
923 fprintf (stderr
, "[Leaving %s]\n", file
);
927 unlink_if_ordinary (file
);
930 /* Remove temporary files at the end of the link. */
932 static enum ld_plugin_status
933 cleanup_handler (void)
940 if (arguments_file_name
)
941 maybe_unlink (arguments_file_name
);
943 for (i
= 0; i
< num_output_files
; i
++)
944 maybe_unlink (output_files
[i
]);
950 #define SWAP(type, a, b) \
951 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
953 /* Compare two hash table entries */
955 static int eq_sym (const void *a
, const void *b
)
957 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
958 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
960 return !strcmp (as
->name
, bs
->name
);
965 static hashval_t
hash_sym (const void *a
)
967 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
969 return htab_hash_string (as
->name
);
972 /* Determine how strong a symbol is */
974 static int symbol_strength (struct ld_plugin_symbol
*s
)
988 /* In the ld -r case we can get dups in the LTO symbol tables, where
989 the same symbol can have different resolutions (e.g. undefined and defined).
991 We have to keep that in the LTO symbol tables, but the dups confuse
992 gold and then finally gcc by supplying incorrect resolutions.
994 Problem is that the main gold symbol table doesn't know about subids
995 and does not distingush the same symbols in different states.
997 So we drop duplicates from the linker visible symbol table
998 and keep them in a private table. Then later do own symbol
999 resolution for the duplicated based on the results for the
1002 Then when writing out the resolution file readd the dropped symbols.
1004 XXX how to handle common? */
1007 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
1009 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
1015 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
1016 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
1018 /* Move all duplicate symbols into the auxiliary conflicts table. */
1020 for (i
= 0; i
< t
->nsyms
; i
++)
1022 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
1023 struct sym_aux
*aux
= &t
->aux
[i
];
1026 slot
= htab_find_slot (symtab
, s
, INSERT
);
1030 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
1031 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
1033 /* Always let the linker resolve the strongest symbol */
1034 if (symbol_strength (orig
) < symbol_strength (s
))
1036 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
1037 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
1038 SWAP (unsigned long long, orig_aux
->id
, aux
->id
);
1039 /* Don't swap conflict chain pointer */
1042 /* Move current symbol into the conflicts table */
1043 cnf
= conflicts
->nsyms
++;
1044 conflicts
->syms
[cnf
] = *s
;
1045 conflicts
->aux
[cnf
] = *aux
;
1046 aux
= &conflicts
->aux
[cnf
];
1048 /* Update conflicts chain of the original symbol */
1049 aux
->next_conflict
= orig_aux
->next_conflict
;
1050 orig_aux
->next_conflict
= cnf
;
1055 /* Remove previous duplicates in the main table */
1062 /* Put original into the hash table */
1063 *slot
= &t
->syms
[out
];
1067 assert (conflicts
->nsyms
<= outlen
);
1068 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
1071 htab_delete (symtab
);
1074 /* Process one section of an object file. */
1077 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
1079 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1081 char *secdatastart
, *secdata
;
1083 if (!startswith (name
, ".gnu.lto_.symtab"))
1086 s
= strrchr (name
, '.');
1088 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1089 secdata
= secdatastart
= xmalloc (length
);
1090 offset
+= obj
->file
->offset
;
1091 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1096 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1104 else if (errno
!= EINTR
)
1111 translate (secdatastart
, secdata
, obj
->out
);
1113 free (secdatastart
);
1118 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1119 /* Force claim_file_handler to abandon this file. */
1121 free (secdatastart
);
1125 /* Process one section of an object file. */
1128 process_symtab_extension (void *data
, const char *name
, off_t offset
,
1131 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1133 char *secdatastart
, *secdata
;
1135 if (!startswith (name
, ".gnu.lto_.ext_symtab"))
1138 s
= strrchr (name
, '.');
1140 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1141 secdata
= secdatastart
= xmalloc (length
);
1142 offset
+= obj
->file
->offset
;
1143 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1148 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1156 else if (errno
!= EINTR
)
1163 parse_symtab_extension (secdatastart
, secdata
, obj
->out
);
1165 free (secdatastart
);
1170 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1171 /* Force claim_file_handler to abandon this file. */
1173 free (secdatastart
);
1178 /* Find an offload section of an object file. */
1181 process_offload_section (void *data
, const char *name
, off_t offset
, off_t len
)
1183 if (startswith (name
, ".gnu.offload_lto_.opts"))
1185 struct plugin_objfile
*obj
= (struct plugin_objfile
*) data
;
1186 obj
->offload
= true;
1193 /* Callback used by a linker to check if the plugin will claim FILE. Writes
1194 the result in CLAIMED. */
1196 static enum ld_plugin_status
1197 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
1199 enum ld_plugin_status status
;
1200 struct plugin_objfile obj
;
1201 struct plugin_file_info lto_file
;
1205 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
1207 if (file
->offset
!= 0)
1209 /* We pass the offset of the actual file, not the archive header.
1210 Can't use PRIx64, because that's C99, so we have to print the
1211 64-bit hex int as two 32-bit ones. Use xasprintf instead of
1212 asprintf because asprintf doesn't work as expected on some older
1215 lo
= file
->offset
& 0xffffffff;
1216 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
1217 lto_file
.name
= hi
? xasprintf ("%s@0x%x%08x", file
->name
, hi
, lo
)
1218 : xasprintf ("%s@0x%x", file
->name
, lo
);
1222 lto_file
.name
= xstrdup (file
->name
);
1224 lto_file
.handle
= file
->handle
;
1229 obj
.offload
= false;
1230 obj
.out
= <o_file
.symtab
;
1232 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
1234 /* No file, but also no error code means unrecognized format; just skip it. */
1235 if (!obj
.objfile
&& !err
)
1240 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
,
1242 /* Parsing symtab extension should be done only for add_symbols_v2 and
1244 if (!errmsg
&& add_symbols_v2
!= NULL
)
1246 obj
.out
->last_sym
= 0;
1247 errmsg
= simple_object_find_sections (obj
.objfile
,
1248 process_symtab_extension
,
1253 if (!obj
.objfile
|| errmsg
)
1256 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
1259 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
1264 simple_object_find_sections (obj
.objfile
, process_offload_section
,
1267 if (obj
.found
== 0 && !obj
.offload
)
1271 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
1276 status
= add_symbols_v2 (file
->handle
, lto_file
.symtab
.nsyms
,
1277 lto_file
.symtab
.syms
);
1279 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
1280 lto_file
.symtab
.syms
);
1281 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
1284 num_claimed_files
++;
1286 xrealloc (claimed_files
,
1287 num_claimed_files
* sizeof (struct plugin_file_info
));
1288 claimed_files
[num_claimed_files
- 1] = lto_file
;
1295 if (offload_files
== NULL
)
1297 /* Add dummy item to the start of the list. */
1298 offload_files
= xmalloc (sizeof (struct plugin_offload_file
));
1299 offload_files
->name
= NULL
;
1300 offload_files
->next
= NULL
;
1301 offload_files_last
= offload_files
;
1304 /* If this is an LTO file without offload, and it is the first LTO file, save
1305 the pointer to the last offload file in the list. Further offload LTO
1306 files will be inserted after it, if any. */
1307 if (*claimed
&& !obj
.offload
&& offload_files_last_lto
== NULL
)
1308 offload_files_last_lto
= offload_files_last
;
1312 /* Add file to the list. The order must be exactly the same as the final
1313 order after recompilation and linking, otherwise host and target tables
1314 with addresses wouldn't match. If a static library contains both LTO
1315 and non-LTO objects, ld and gold link them in a different order. */
1316 struct plugin_offload_file
*ofld
1317 = xmalloc (sizeof (struct plugin_offload_file
));
1318 ofld
->name
= lto_file
.name
;
1321 if (*claimed
&& offload_files_last_lto
== NULL
&& file
->offset
!= 0
1322 && gold_version
== -1)
1324 /* ld only: insert first LTO file from the archive after the last real
1325 object file immediately preceding the archive, or at the begin of
1326 the list if there was no real objects before archives. */
1327 if (offload_files_last_obj
!= NULL
)
1329 ofld
->next
= offload_files_last_obj
->next
;
1330 offload_files_last_obj
->next
= ofld
;
1334 ofld
->next
= offload_files
->next
;
1335 offload_files
->next
= ofld
;
1338 else if (*claimed
&& offload_files_last_lto
!= NULL
)
1340 /* Insert LTO file after the last LTO file in the list. */
1341 ofld
->next
= offload_files_last_lto
->next
;
1342 offload_files_last_lto
->next
= ofld
;
1345 /* Add non-LTO file or first non-archive LTO file to the end of the
1347 offload_files_last
->next
= ofld
;
1349 if (ofld
->next
== NULL
)
1350 offload_files_last
= ofld
;
1351 if (file
->offset
== 0)
1352 offload_files_last_obj
= ofld
;
1354 offload_files_last_lto
= ofld
;
1355 num_offload_files
++;
1364 non_claimed_files
++;
1366 free (lto_file
.name
);
1370 simple_object_release_read (obj
.objfile
);
1375 /* Parse the plugin options. */
1378 process_option (const char *option
)
1380 if (strcmp (option
, "-linker-output-known") == 0)
1381 linker_output_known
= true;
1382 /* Also accept "notlo" for backwards compatibility. */
1383 else if ((strcmp (option
, "-linker-output-auto-nolto-rel") == 0)
1384 || (strcmp (option
, "-linker-output-auto-notlo-rel") == 0))
1385 linker_output_auto_nolto_rel
= true;
1386 else if (strcmp (option
, "-debug") == 0)
1388 else if ((strcmp (option
, "-v") == 0)
1389 || (strcmp (option
, "--verbose") == 0))
1391 else if (strcmp (option
, "-save-temps") == 0)
1393 else if (strcmp (option
, "-nop") == 0)
1395 else if (startswith (option
, "-pass-through="))
1397 num_pass_through_items
++;
1398 pass_through_items
= xrealloc (pass_through_items
,
1399 num_pass_through_items
* sizeof (char *));
1400 pass_through_items
[num_pass_through_items
- 1] =
1401 xstrdup (option
+ strlen ("-pass-through="));
1403 else if (startswith (option
, "-sym-style="))
1405 switch (option
[sizeof ("-sym-style=") - 1])
1408 sym_style
= ss_win32
;
1411 sym_style
= ss_uscore
;
1414 sym_style
= ss_none
;
1418 else if (startswith (option
, "-ltrans-objects="))
1419 ltrans_objects
= xstrdup (option
+ strlen ("-ltrans-objects="));
1423 char *opt
= xstrdup (option
);
1424 lto_wrapper_num_args
+= 1;
1425 size
= lto_wrapper_num_args
* sizeof (char *);
1426 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
1427 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
1428 if (startswith (option
, "-fresolution="))
1429 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
1431 save_temps
= save_temps
|| debug
;
1432 verbose
= verbose
|| debug
;
1435 /* Negotiate linker API version. */
1438 negotiate_api_version (void)
1440 const char *linker_identifier
;
1441 const char *linker_version
;
1443 enum linker_api_version supported_api
= LAPI_V0
;
1444 #if HAVE_PTHREAD_LOCKING
1445 supported_api
= LAPI_V1
;
1448 api_version
= get_api_version ("GCC", BASE_VERSION
, LAPI_V0
,
1449 supported_api
, &linker_identifier
, &linker_version
);
1450 if (api_version
> supported_api
)
1452 fprintf (stderr
, "requested an unsupported API version (%d)\n", api_version
);
1456 switch (api_version
)
1461 check (get_symbols_v3
, LDPL_FATAL
,
1462 "get_symbols_v3 required for API version 1");
1463 check (add_symbols_v2
, LDPL_FATAL
,
1464 "add_symbols_v2 required for API version 1");
1467 fprintf (stderr
, "unsupported API version (%d)\n", api_version
);
1472 /* Called by a linker after loading the plugin. TV is the transfer vector. */
1474 enum ld_plugin_status
1475 onload (struct ld_plugin_tv
*tv
)
1477 struct ld_plugin_tv
*p
;
1478 enum ld_plugin_status status
;
1480 #if HAVE_PTHREAD_LOCKING
1481 if (pthread_mutex_init (&plugin_lock
, NULL
) != 0)
1483 fprintf (stderr
, "mutex init failed\n");
1494 message
= p
->tv_u
.tv_message
;
1496 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1497 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
1499 case LDPT_ADD_SYMBOLS_V2
:
1500 add_symbols_v2
= p
->tv_u
.tv_add_symbols
;
1502 case LDPT_ADD_SYMBOLS
:
1503 add_symbols
= p
->tv_u
.tv_add_symbols
;
1505 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1506 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
1508 case LDPT_GET_SYMBOLS_V3
:
1509 get_symbols_v3
= p
->tv_u
.tv_get_symbols
;
1511 case LDPT_GET_SYMBOLS_V2
:
1512 get_symbols_v2
= p
->tv_u
.tv_get_symbols
;
1514 case LDPT_GET_SYMBOLS
:
1515 get_symbols
= p
->tv_u
.tv_get_symbols
;
1517 case LDPT_REGISTER_CLEANUP_HOOK
:
1518 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
1520 case LDPT_ADD_INPUT_FILE
:
1521 add_input_file
= p
->tv_u
.tv_add_input_file
;
1523 case LDPT_ADD_INPUT_LIBRARY
:
1524 add_input_library
= p
->tv_u
.tv_add_input_library
;
1527 process_option (p
->tv_u
.tv_string
);
1529 case LDPT_GOLD_VERSION
:
1530 gold_version
= p
->tv_u
.tv_val
;
1532 case LDPT_LINKER_OUTPUT
:
1533 linker_output
= (enum ld_plugin_output_file_type
) p
->tv_u
.tv_val
;
1534 linker_output_set
= true;
1536 case LDPT_OUTPUT_NAME
:
1537 /* We only use this to make user-friendly temp file names. */
1538 link_output_name
= p
->tv_u
.tv_string
;
1540 case LDPT_GET_API_VERSION
:
1541 get_api_version
= p
->tv_u
.tv_get_api_version
;
1549 if (get_api_version
)
1550 negotiate_api_version ();
1552 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1553 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1554 status
= register_claim_file (claim_file_handler
);
1555 check (status
== LDPS_OK
, LDPL_FATAL
,
1556 "could not register the claim_file callback");
1558 if (register_cleanup
)
1560 status
= register_cleanup (cleanup_handler
);
1561 check (status
== LDPS_OK
, LDPL_FATAL
,
1562 "could not register the cleanup callback");
1565 if (register_all_symbols_read
)
1567 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1568 status
= register_all_symbols_read (all_symbols_read_handler
);
1569 check (status
== LDPS_OK
, LDPL_FATAL
,
1570 "could not register the all_symbols_read callback");
1573 char *collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1574 if (collect_gcc_options
)
1576 /* Support -fno-use-linker-plugin by failing to load the plugin
1577 for the case where it is auto-loaded by BFD. */
1578 if (strstr (collect_gcc_options
, "'-fno-use-linker-plugin'"))
1581 if (strstr (collect_gcc_options
, "'-save-temps'"))
1584 if (strstr (collect_gcc_options
, "'-v'")
1585 || strstr (collect_gcc_options
, "'--verbose'"))
1589 if ((p
= strstr (collect_gcc_options
, "'-dumpdir'")))
1591 p
+= sizeof ("'-dumpdir'");
1594 const char *start
= p
;
1595 int ticks
= 0, escapes
= 0;
1596 /* Count ticks (') and escaped (\.) characters. Stop at the
1597 end of the options or at a blank after an even number of
1598 ticks (not counting escaped ones. */
1599 for (p
= start
; *p
; p
++)
1606 else if ((ticks
% 2) != 0)
1620 /* Now allocate a new link_output_name and decode dumpdir
1621 into it. The loop uses the same logic, except it counts
1622 ticks and escapes backwards (so ticks is adjusted if we
1623 find an odd number of them), and it copies characters
1624 that are escaped or not otherwise skipped. */
1625 int len
= p
- start
- ticks
- escapes
+ 1;
1626 char *q
= xmalloc (len
);
1627 link_output_name
= q
;
1628 int oddticks
= (ticks
% 2);
1630 for (p
= start
; *p
; p
++)
1637 else if ((ticks
% 2) != 0)
1652 assert (escapes
== 0);
1653 assert (ticks
== oddticks
);
1654 assert (q
- link_output_name
== len
- 1);
1655 skip_in_suffix
= true;