1 /* LTO plugin for gold and/or GNU ld.
2 Copyright (C) 2009-2020 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. Gold passes it an array of
20 function that the plugin uses to communicate back to gold.
22 With the functions provided by gold, the plugin can be notified when
23 gold first analyzes a file and pass a symbol table back to gold. 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 -sym-style={none,win32,underscore|uscore}
54 #include <sys/types.h>
55 #ifdef HAVE_SYS_WAIT_H
59 #define WIFEXITED(S) (((S) & 0xff) == 0)
62 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
64 #include <libiberty.h>
66 #include "../gcc/lto/common.h"
67 #include "simple-object.h"
68 #include "plugin-api.h"
70 /* We need to use I64 instead of ll width-specifier on native Windows.
71 The reason for this is that older MS-runtimes don't support the ll. */
78 /* Handle opening elf files on hosts, such as Windows, that may use
79 text file handling that will break binary access. */
84 /* Segment name for LTO sections. This is only used for Mach-O.
85 FIXME: This needs to be kept in sync with darwin.c. */
87 #define LTO_SEGMENT_NAME "__GNU_LTO"
89 /* LTO magic section name. */
91 #define LTO_SYMTAB_PREFIX ".gnu.lto_.symtab"
92 #define LTO_SYMTAB_PREFIX_LEN (sizeof (LTO_SYMTAB_PREFIX) - 1)
93 #define LTO_SYMTAB_EXT_PREFIX ".gnu.lto_.ext_symtab"
94 #define LTO_SYMTAB_EXT_PREFIX_LEN (sizeof (LTO_SYMTAB_EXT_PREFIX) - 1)
95 #define LTO_LTO_PREFIX ".gnu.lto_.lto"
96 #define LTO_LTO_PREFIX_LEN (sizeof (LTO_LTO_PREFIX) - 1)
97 #define OFFLOAD_SECTION ".gnu.offload_lto_.opts"
98 #define OFFLOAD_SECTION_LEN (sizeof (OFFLOAD_SECTION) - 1)
100 /* The part of the symbol table the plugin has to keep track of. Note that we
101 must keep SYMS until all_symbols_read is called to give the linker time to
102 copy the symbol information.
103 The id must be 64bit to minimze collisions. */
108 unsigned long long id
;
109 unsigned next_conflict
;
116 struct ld_plugin_symbol
*syms
;
117 unsigned long long id
;
120 /* Encapsulates object file data during symbol scan. */
121 struct plugin_objfile
125 simple_object_read
*objfile
;
126 struct plugin_symtab
*out
;
127 const struct ld_plugin_input_file
*file
;
130 /* All that we have to remember about a file. */
132 struct plugin_file_info
136 struct plugin_symtab symtab
;
137 struct plugin_symtab conflicts
;
140 /* List item with name of the file with offloading. */
142 struct plugin_offload_file
145 struct plugin_offload_file
*next
;
148 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
149 stdio file streams, we do simple label translation here. */
153 ss_none
, /* No underscore prefix. */
154 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
155 ss_uscore
, /* Underscore prefix all symbols. */
158 static char *arguments_file_name
;
159 static ld_plugin_register_claim_file register_claim_file
;
160 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
161 static ld_plugin_get_symbols get_symbols
, get_symbols_v2
;
162 static ld_plugin_register_cleanup register_cleanup
;
163 static ld_plugin_add_input_file add_input_file
;
164 static ld_plugin_add_input_library add_input_library
;
165 static ld_plugin_message message
;
166 static ld_plugin_add_symbols add_symbols
, add_symbols_v2
;
168 static struct plugin_file_info
*claimed_files
= NULL
;
169 static unsigned int num_claimed_files
= 0;
170 static unsigned int non_claimed_files
= 0;
172 /* List of files with offloading. */
173 static struct plugin_offload_file
*offload_files
;
174 /* Last file in the list. */
175 static struct plugin_offload_file
*offload_files_last
;
176 /* Last non-archive file in the list. */
177 static struct plugin_offload_file
*offload_files_last_obj
;
178 /* Last LTO file in the list. */
179 static struct plugin_offload_file
*offload_files_last_lto
;
180 /* Total number of files with offloading. */
181 static unsigned num_offload_files
;
183 static char **output_files
= NULL
;
184 static unsigned int num_output_files
= 0;
186 static char **lto_wrapper_argv
;
187 static int lto_wrapper_num_args
;
189 static char **pass_through_items
= NULL
;
190 static unsigned int num_pass_through_items
;
193 static bool save_temps
;
196 static char *resolution_file
= NULL
;
197 static enum ld_plugin_output_file_type linker_output
;
198 static int linker_output_set
;
199 static int linker_output_known
;
200 static const char *link_output_name
= NULL
;
202 /* The version of gold being used, or -1 if not gold. The number is
203 MAJOR * 100 + MINOR. */
204 static int gold_version
= -1;
206 /* Not used by default, but can be overridden at runtime
207 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
208 (in fact, only first letter of style arg is checked.) */
209 static enum symbol_style sym_style
= ss_none
;
212 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
218 message (level
, text
);
221 /* If there is no nicer way to inform the user, fallback to stderr. */
222 fprintf (stderr
, "%s\n", text
);
223 if (level
== LDPL_FATAL
)
228 /* This little wrapper allows check to be called with a non-integer
229 first argument, such as a pointer that must be non-NULL. We can't
230 use c99 bool type to coerce it into range, so we explicitly test. */
231 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
233 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
234 by P and the result is written in ENTRY. The slot number is stored in SLOT.
235 Returns the address of the next entry. */
238 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
242 enum ld_plugin_symbol_kind translate_kind
[] =
251 enum ld_plugin_symbol_visibility translate_visibility
[] =
264 /* cf. Duff's device. */
266 entry
->name
= xstrdup (p
);
271 entry
->name
= concat ("_", p
, NULL
);
274 check (0, LDPL_FATAL
, "invalid symbol style requested");
281 entry
->version
= NULL
;
283 entry
->comdat_key
= p
;
288 if (strlen (entry
->comdat_key
) == 0)
289 entry
->comdat_key
= NULL
;
291 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
293 entry
->unused
= entry
->section_kind
= entry
->symbol_type
= 0;
296 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
297 entry
->def
= translate_kind
[t
];
301 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
302 entry
->visibility
= translate_visibility
[t
];
305 memcpy (&entry
->size
, p
, sizeof (uint64_t));
308 memcpy (&aux
->slot
, p
, sizeof (uint32_t));
311 entry
->resolution
= LDPR_UNKNOWN
;
313 aux
->next_conflict
= -1;
318 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
319 by P and the result is written in ENTRY. The slot number is stored in SLOT.
320 Returns the address of the next entry. */
323 parse_table_entry_extension (char *p
, struct ld_plugin_symbol
*entry
)
326 enum ld_plugin_symbol_type symbol_types
[] =
334 check (t
<= 2, LDPL_FATAL
, "invalid symbol type found");
335 entry
->symbol_type
= symbol_types
[t
];
337 entry
->section_kind
= *p
;
344 /* Translate the IL symbol table located between DATA and END. Append the
345 slots and symbols to OUT. */
348 translate (char *data
, char *end
, struct plugin_symtab
*out
)
351 struct ld_plugin_symbol
*syms
= NULL
;
354 /* This overestimates the output buffer sizes, but at least
355 the algorithm is O(1) now. */
357 len
= (end
- data
)/8 + out
->nsyms
+ 1;
358 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
359 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
361 for (n
= out
->nsyms
; data
< end
; n
++)
364 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
375 parse_symtab_extension (char *data
, char *end
, struct plugin_symtab
*out
)
379 unsigned char version
= *data
;
382 /* Version 1 contains the following data per entry:
388 for (i
= 0; i
< out
->nsyms
; i
++)
389 data
= parse_table_entry_extension (data
, &out
->syms
[i
]);
392 /* Free all memory that is no longer needed after writing the symbol
396 free_1 (struct plugin_file_info
*files
, unsigned num_files
)
399 for (i
= 0; i
< num_files
; i
++)
401 struct plugin_file_info
*info
= &files
[i
];
402 struct plugin_symtab
*symtab
= &info
->symtab
;
404 for (j
= 0; j
< symtab
->nsyms
; j
++)
406 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
408 free (s
->comdat_key
);
415 /* Free all remaining memory. */
421 for (i
= 0; i
< num_claimed_files
; i
++)
423 struct plugin_file_info
*info
= &claimed_files
[i
];
424 struct plugin_symtab
*symtab
= &info
->symtab
;
429 for (i
= 0; i
< num_output_files
; i
++)
430 free (output_files
[i
]);
433 free (claimed_files
);
434 claimed_files
= NULL
;
435 num_claimed_files
= 0;
437 while (offload_files
)
439 struct plugin_offload_file
*ofld
= offload_files
;
440 offload_files
= offload_files
->next
;
443 num_offload_files
= 0;
445 free (arguments_file_name
);
446 arguments_file_name
= NULL
;
449 /* Dump SYMTAB to resolution file F. */
452 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
456 for (j
= 0; j
< symtab
->nsyms
; j
++)
458 uint32_t slot
= symtab
->aux
[j
].slot
;
459 unsigned int resolution
= symtab
->syms
[j
].resolution
;
461 assert (resolution
!= LDPR_UNKNOWN
);
463 fprintf (f
, "%u %" PRI_LL
"x %s %s\n",
464 (unsigned int) slot
, symtab
->aux
[j
].id
,
465 lto_resolution_str
[resolution
],
466 symtab
->syms
[j
].name
);
470 /* Finish the conflicts' resolution information after the linker resolved
471 the original symbols */
474 finish_conflict_resolution (struct plugin_symtab
*symtab
,
475 struct plugin_symtab
*conflicts
)
479 if (conflicts
->nsyms
== 0)
482 for (i
= 0; i
< symtab
->nsyms
; i
++)
484 char resolution
= LDPR_UNKNOWN
;
486 if (symtab
->aux
[i
].next_conflict
== -1)
489 switch (symtab
->syms
[i
].def
)
492 case LDPK_COMMON
: /* ??? */
493 resolution
= LDPR_RESOLVED_IR
;
496 resolution
= LDPR_PREEMPTED_IR
;
500 resolution
= symtab
->syms
[i
].resolution
;
506 assert (resolution
!= LDPR_UNKNOWN
);
508 for (j
= symtab
->aux
[i
].next_conflict
;
510 j
= conflicts
->aux
[j
].next_conflict
)
511 conflicts
->syms
[j
].resolution
= resolution
;
515 /* Free symbol table SYMTAB. */
518 free_symtab (struct plugin_symtab
*symtab
)
526 /* Writes the relocations to disk. */
529 write_resolution (void)
534 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
535 f
= fopen (resolution_file
, "w");
536 check (f
, LDPL_FATAL
, "could not open file");
538 fprintf (f
, "%d\n", num_claimed_files
);
540 for (i
= 0; i
< num_claimed_files
; i
++)
542 struct plugin_file_info
*info
= &claimed_files
[i
];
543 struct plugin_symtab
*symtab
= &info
->symtab
;
544 struct ld_plugin_symbol
*syms
= symtab
->syms
;
546 /* Version 2 of API supports IRONLY_EXP resolution that is
547 accepted by GCC-4.7 and newer. */
549 get_symbols_v2 (info
->handle
, symtab
->nsyms
, syms
);
551 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
553 finish_conflict_resolution (symtab
, &info
->conflicts
);
555 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
556 dump_symtab (f
, symtab
);
557 if (info
->conflicts
.nsyms
)
559 dump_symtab (f
, &info
->conflicts
);
560 free_symtab (&info
->conflicts
);
566 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
570 add_output_files (FILE *f
)
574 const unsigned piece
= 32;
575 char *buf
, *s
= xmalloc (piece
);
580 if (!fgets (buf
, piece
, f
))
586 if (s
[len
- 1] != '\n')
588 s
= xrealloc (s
, len
+ piece
);
596 = xrealloc (output_files
, num_output_files
* sizeof (char *));
597 output_files
[num_output_files
- 1] = s
;
598 add_input_file (output_files
[num_output_files
- 1]);
602 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
606 exec_lto_wrapper (char *argv
[])
612 FILE *wrapper_output
;
617 /* Write argv to a file to avoid a command line that is too long
618 Save the file locally on save-temps. */
619 if (save_temps
&& link_output_name
)
621 arguments_file_name
= (char *) xmalloc (strlen (link_output_name
)
622 + sizeof (".lto_wrapper_args") + 1);
623 strcpy (arguments_file_name
, link_output_name
);
624 strcat (arguments_file_name
, ".lto_wrapper_args");
627 arguments_file_name
= make_temp_file (".lto_wrapper_args");
628 check (arguments_file_name
, LDPL_FATAL
,
629 "Failed to generate a temorary file name");
631 args
= fopen (arguments_file_name
, "w");
632 check (args
, LDPL_FATAL
, "could not open arguments file");
634 t
= writeargv (&argv
[1], args
);
635 check (t
== 0, LDPL_FATAL
, "could not write arguments");
637 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
639 at_args
= concat ("@", arguments_file_name
, NULL
);
640 check (at_args
, LDPL_FATAL
, "could not allocate");
642 for (i
= 1; argv
[i
]; i
++)
645 /* Check the input argument list for a verbose marker too. */
646 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
655 for (i
= 0; argv
[i
]; i
++)
656 fprintf (stderr
, "%s ", argv
[i
]);
657 fprintf (stderr
, "\n");
660 new_argv
[0] = argv
[0];
661 new_argv
[1] = at_args
;
666 for (i
= 0; new_argv
[i
]; i
++)
667 fprintf (stderr
, "%s ", new_argv
[i
]);
668 fprintf (stderr
, "\n");
671 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
672 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
674 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
675 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
676 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
678 wrapper_output
= pex_read_output (pex
, 0);
679 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
681 add_output_files (wrapper_output
);
683 t
= pex_get_status (pex
, 1, &status
);
684 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
685 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
686 "lto-wrapper failed");
693 /* Pass the original files back to the linker. */
696 use_original_files (void)
699 for (i
= 0; i
< num_claimed_files
; i
++)
701 struct plugin_file_info
*info
= &claimed_files
[i
];
702 add_input_file (info
->name
);
707 /* Called by the linker once all symbols have been read. */
709 static enum ld_plugin_status
710 all_symbols_read_handler (void)
713 unsigned num_lto_args
= num_claimed_files
+ lto_wrapper_num_args
+ 2
714 + !linker_output_known
;
716 const char *linker_output_str
= NULL
;
717 const char **lto_arg_ptr
;
718 if (num_claimed_files
+ num_offload_files
== 0)
723 use_original_files ();
727 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
728 lto_arg_ptr
= (const char **) lto_argv
;
729 assert (lto_wrapper_argv
);
733 free_1 (claimed_files
, num_claimed_files
);
735 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
736 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
738 if (!linker_output_known
)
740 assert (linker_output_set
);
741 switch (linker_output
)
744 if (non_claimed_files
)
746 message (LDPL_WARNING
, "incremental linking of LTO and non-LTO "
747 "objects; using -flinker-output=nolto-rel which will "
748 "bypass whole program optimization");
749 linker_output_str
= "-flinker-output=nolto-rel";
752 linker_output_str
= "-flinker-output=rel";
755 linker_output_str
= "-flinker-output=dyn";
758 linker_output_str
= "-flinker-output=pie";
761 linker_output_str
= "-flinker-output=exec";
764 message (LDPL_FATAL
, "unsupported linker output %i", linker_output
);
767 *lto_arg_ptr
++ = xstrdup (linker_output_str
);
770 if (num_offload_files
> 0)
774 char *offload_objects_file_name
;
775 struct plugin_offload_file
*ofld
;
777 offload_objects_file_name
= make_temp_file (".ofldlist");
778 check (offload_objects_file_name
, LDPL_FATAL
,
779 "Failed to generate a temporary file name");
780 f
= fopen (offload_objects_file_name
, "w");
781 check (f
, LDPL_FATAL
, "could not open file with offload objects");
782 fprintf (f
, "%u\n", num_offload_files
);
784 /* Skip the dummy item at the start of the list. */
785 ofld
= offload_files
->next
;
788 fprintf (f
, "%s\n", ofld
->name
);
793 arg
= concat ("-foffload-objects=", offload_objects_file_name
, NULL
);
794 check (arg
, LDPL_FATAL
, "could not allocate");
795 *lto_arg_ptr
++ = arg
;
798 for (i
= 0; i
< num_claimed_files
; i
++)
800 struct plugin_file_info
*info
= &claimed_files
[i
];
802 *lto_arg_ptr
++ = info
->name
;
805 *lto_arg_ptr
++ = NULL
;
806 exec_lto_wrapper (lto_argv
);
810 /* --pass-through is not needed when using gold 1.11 or later. */
811 if (pass_through_items
&& gold_version
< 111)
814 for (i
= 0; i
< num_pass_through_items
; i
++)
816 if (strncmp (pass_through_items
[i
], "-l", 2) == 0)
817 add_input_library (pass_through_items
[i
] + 2);
819 add_input_file (pass_through_items
[i
]);
820 free (pass_through_items
[i
]);
821 pass_through_items
[i
] = NULL
;
823 free (pass_through_items
);
824 pass_through_items
= NULL
;
830 /* Helper, as used in collect2. */
832 file_exists (const char *name
)
834 return access (name
, R_OK
) == 0;
837 /* Unlink FILE unless we have save-temps set.
838 Note that we're saving files if verbose output is set. */
841 maybe_unlink (const char *file
)
843 if (save_temps
&& file_exists (file
))
846 fprintf (stderr
, "[Leaving %s]\n", file
);
850 unlink_if_ordinary (file
);
853 /* Remove temporary files at the end of the link. */
855 static enum ld_plugin_status
856 cleanup_handler (void)
863 if (arguments_file_name
)
864 maybe_unlink (arguments_file_name
);
866 for (i
= 0; i
< num_output_files
; i
++)
867 maybe_unlink (output_files
[i
]);
873 #define SWAP(type, a, b) \
874 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
876 /* Compare two hash table entries */
878 static int eq_sym (const void *a
, const void *b
)
880 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
881 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
883 return !strcmp (as
->name
, bs
->name
);
888 static hashval_t
hash_sym (const void *a
)
890 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
892 return htab_hash_string (as
->name
);
895 /* Determine how strong a symbol is */
897 static int symbol_strength (struct ld_plugin_symbol
*s
)
911 /* In the ld -r case we can get dups in the LTO symbol tables, where
912 the same symbol can have different resolutions (e.g. undefined and defined).
914 We have to keep that in the LTO symbol tables, but the dups confuse
915 gold and then finally gcc by supplying incorrect resolutions.
917 Problem is that the main gold symbol table doesn't know about subids
918 and does not distingush the same symbols in different states.
920 So we drop duplicates from the linker visible symbol table
921 and keep them in a private table. Then later do own symbol
922 resolution for the duplicated based on the results for the
925 Then when writing out the resolution file readd the dropped symbols.
927 XXX how to handle common? */
930 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
932 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
938 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
939 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
941 /* Move all duplicate symbols into the auxiliary conflicts table. */
943 for (i
= 0; i
< t
->nsyms
; i
++)
945 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
946 struct sym_aux
*aux
= &t
->aux
[i
];
949 slot
= htab_find_slot (symtab
, s
, INSERT
);
953 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
954 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
956 /* Always let the linker resolve the strongest symbol */
957 if (symbol_strength (orig
) < symbol_strength (s
))
959 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
960 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
961 SWAP (unsigned long long, orig_aux
->id
, aux
->id
);
962 /* Don't swap conflict chain pointer */
965 /* Move current symbol into the conflicts table */
966 cnf
= conflicts
->nsyms
++;
967 conflicts
->syms
[cnf
] = *s
;
968 conflicts
->aux
[cnf
] = *aux
;
969 aux
= &conflicts
->aux
[cnf
];
971 /* Update conflicts chain of the original symbol */
972 aux
->next_conflict
= orig_aux
->next_conflict
;
973 orig_aux
->next_conflict
= cnf
;
978 /* Remove previous duplicates in the main table */
985 /* Put original into the hash table */
986 *slot
= &t
->syms
[out
];
990 assert (conflicts
->nsyms
<= outlen
);
991 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
994 htab_delete (symtab
);
997 /* Process one section of an object file. */
1000 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
1002 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1004 char *secdatastart
, *secdata
;
1006 if (strncmp (name
, LTO_SYMTAB_PREFIX
, LTO_SYMTAB_PREFIX_LEN
) != 0)
1009 s
= strrchr (name
, '.');
1011 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1012 secdata
= secdatastart
= xmalloc (length
);
1013 offset
+= obj
->file
->offset
;
1014 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1019 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1027 else if (errno
!= EINTR
)
1034 translate (secdatastart
, secdata
, obj
->out
);
1036 free (secdatastart
);
1041 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1042 /* Force claim_file_handler to abandon this file. */
1044 free (secdatastart
);
1048 /* Process one section of an object file. */
1051 process_symtab_extension (void *data
, const char *name
, off_t offset
,
1054 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
1056 char *secdatastart
, *secdata
;
1058 if (strncmp (name
, LTO_SYMTAB_EXT_PREFIX
, LTO_SYMTAB_EXT_PREFIX_LEN
) != 0)
1061 s
= strrchr (name
, '.');
1063 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
1064 secdata
= secdatastart
= xmalloc (length
);
1065 offset
+= obj
->file
->offset
;
1066 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
1071 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
1079 else if (errno
!= EINTR
)
1086 parse_symtab_extension (secdatastart
, secdata
, obj
->out
);
1088 free (secdatastart
);
1093 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
1094 /* Force claim_file_handler to abandon this file. */
1096 free (secdatastart
);
1101 /* Find an offload section of an object file. */
1104 process_offload_section (void *data
, const char *name
, off_t offset
, off_t len
)
1106 if (!strncmp (name
, OFFLOAD_SECTION
, OFFLOAD_SECTION_LEN
))
1108 struct plugin_objfile
*obj
= (struct plugin_objfile
*) data
;
1116 /* Callback used by gold to check if the plugin will claim FILE. Writes
1117 the result in CLAIMED. */
1119 static enum ld_plugin_status
1120 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
1122 enum ld_plugin_status status
;
1123 struct plugin_objfile obj
;
1124 struct plugin_file_info lto_file
;
1128 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
1130 if (file
->offset
!= 0)
1132 /* We pass the offset of the actual file, not the archive header.
1133 Can't use PRIx64, because that's C99, so we have to print the
1134 64-bit hex int as two 32-bit ones. Use xasprintf instead of
1135 asprintf because asprintf doesn't work as expected on some older
1138 lo
= file
->offset
& 0xffffffff;
1139 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
1140 lto_file
.name
= hi
? xasprintf ("%s@0x%x%08x", file
->name
, hi
, lo
)
1141 : xasprintf ("%s@0x%x", file
->name
, lo
);
1145 lto_file
.name
= xstrdup (file
->name
);
1147 lto_file
.handle
= file
->handle
;
1153 obj
.out
= <o_file
.symtab
;
1155 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
1157 /* No file, but also no error code means unrecognized format; just skip it. */
1158 if (!obj
.objfile
&& !err
)
1163 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
,
1165 /* Parsing symtab extension should be done only for add_symbols_v2 and
1167 if (!errmsg
&& add_symbols_v2
!= NULL
)
1168 errmsg
= simple_object_find_sections (obj
.objfile
,
1169 process_symtab_extension
,
1173 if (!obj
.objfile
|| errmsg
)
1176 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
1179 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
1184 simple_object_find_sections (obj
.objfile
, process_offload_section
,
1187 if (obj
.found
== 0 && obj
.offload
== 0)
1191 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
1196 status
= add_symbols_v2 (file
->handle
, lto_file
.symtab
.nsyms
,
1197 lto_file
.symtab
.syms
);
1199 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
1200 lto_file
.symtab
.syms
);
1201 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
1203 num_claimed_files
++;
1205 xrealloc (claimed_files
,
1206 num_claimed_files
* sizeof (struct plugin_file_info
));
1207 claimed_files
[num_claimed_files
- 1] = lto_file
;
1212 if (offload_files
== NULL
)
1214 /* Add dummy item to the start of the list. */
1215 offload_files
= xmalloc (sizeof (struct plugin_offload_file
));
1216 offload_files
->name
= NULL
;
1217 offload_files
->next
= NULL
;
1218 offload_files_last
= offload_files
;
1221 /* If this is an LTO file without offload, and it is the first LTO file, save
1222 the pointer to the last offload file in the list. Further offload LTO
1223 files will be inserted after it, if any. */
1224 if (*claimed
&& obj
.offload
== 0 && offload_files_last_lto
== NULL
)
1225 offload_files_last_lto
= offload_files_last
;
1227 if (obj
.offload
== 1)
1229 /* Add file to the list. The order must be exactly the same as the final
1230 order after recompilation and linking, otherwise host and target tables
1231 with addresses wouldn't match. If a static library contains both LTO
1232 and non-LTO objects, ld and gold link them in a different order. */
1233 struct plugin_offload_file
*ofld
1234 = xmalloc (sizeof (struct plugin_offload_file
));
1235 ofld
->name
= lto_file
.name
;
1238 if (*claimed
&& offload_files_last_lto
== NULL
&& file
->offset
!= 0
1239 && gold_version
== -1)
1241 /* ld only: insert first LTO file from the archive after the last real
1242 object file immediately preceding the archive, or at the begin of
1243 the list if there was no real objects before archives. */
1244 if (offload_files_last_obj
!= NULL
)
1246 ofld
->next
= offload_files_last_obj
->next
;
1247 offload_files_last_obj
->next
= ofld
;
1251 ofld
->next
= offload_files
->next
;
1252 offload_files
->next
= ofld
;
1255 else if (*claimed
&& offload_files_last_lto
!= NULL
)
1257 /* Insert LTO file after the last LTO file in the list. */
1258 ofld
->next
= offload_files_last_lto
->next
;
1259 offload_files_last_lto
->next
= ofld
;
1262 /* Add non-LTO file or first non-archive LTO file to the end of the
1264 offload_files_last
->next
= ofld
;
1266 if (ofld
->next
== NULL
)
1267 offload_files_last
= ofld
;
1268 if (file
->offset
== 0)
1269 offload_files_last_obj
= ofld
;
1271 offload_files_last_lto
= ofld
;
1272 num_offload_files
++;
1278 non_claimed_files
++;
1279 free (lto_file
.name
);
1283 simple_object_release_read (obj
.objfile
);
1288 /* Parse the plugin options. */
1291 process_option (const char *option
)
1293 if (strcmp (option
, "-linker-output-known") == 0)
1294 linker_output_known
= 1;
1295 if (strcmp (option
, "-debug") == 0)
1297 else if ((strcmp (option
, "-v") == 0)
1298 || (strcmp (option
, "--verbose") == 0))
1300 else if (strcmp (option
, "-save-temps") == 0)
1302 else if (strcmp (option
, "-nop") == 0)
1304 else if (!strncmp (option
, "-pass-through=", strlen("-pass-through=")))
1306 num_pass_through_items
++;
1307 pass_through_items
= xrealloc (pass_through_items
,
1308 num_pass_through_items
* sizeof (char *));
1309 pass_through_items
[num_pass_through_items
- 1] =
1310 xstrdup (option
+ strlen ("-pass-through="));
1312 else if (!strncmp (option
, "-sym-style=", sizeof ("-sym-style=") - 1))
1314 switch (option
[sizeof ("-sym-style=") - 1])
1317 sym_style
= ss_win32
;
1320 sym_style
= ss_uscore
;
1323 sym_style
= ss_none
;
1330 char *opt
= xstrdup (option
);
1331 lto_wrapper_num_args
+= 1;
1332 size
= lto_wrapper_num_args
* sizeof (char *);
1333 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
1334 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
1335 if (strncmp (option
, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
1336 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
1338 save_temps
= save_temps
|| debug
;
1339 verbose
= verbose
|| debug
;
1342 /* Called by gold after loading the plugin. TV is the transfer vector. */
1344 enum ld_plugin_status
1345 onload (struct ld_plugin_tv
*tv
)
1347 struct ld_plugin_tv
*p
;
1348 enum ld_plugin_status status
;
1356 message
= p
->tv_u
.tv_message
;
1358 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1359 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
1361 case LDPT_ADD_SYMBOLS_V2
:
1362 add_symbols_v2
= p
->tv_u
.tv_add_symbols
;
1364 case LDPT_ADD_SYMBOLS
:
1365 add_symbols
= p
->tv_u
.tv_add_symbols
;
1367 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1368 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
1370 case LDPT_GET_SYMBOLS_V2
:
1371 get_symbols_v2
= p
->tv_u
.tv_get_symbols
;
1373 case LDPT_GET_SYMBOLS
:
1374 get_symbols
= p
->tv_u
.tv_get_symbols
;
1376 case LDPT_REGISTER_CLEANUP_HOOK
:
1377 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
1379 case LDPT_ADD_INPUT_FILE
:
1380 add_input_file
= p
->tv_u
.tv_add_input_file
;
1382 case LDPT_ADD_INPUT_LIBRARY
:
1383 add_input_library
= p
->tv_u
.tv_add_input_library
;
1386 process_option (p
->tv_u
.tv_string
);
1388 case LDPT_GOLD_VERSION
:
1389 gold_version
= p
->tv_u
.tv_val
;
1391 case LDPT_LINKER_OUTPUT
:
1392 linker_output
= (enum ld_plugin_output_file_type
) p
->tv_u
.tv_val
;
1393 linker_output_set
= 1;
1395 case LDPT_OUTPUT_NAME
:
1396 /* We only use this to make user-friendly temp file names. */
1397 link_output_name
= p
->tv_u
.tv_string
;
1405 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1406 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1407 status
= register_claim_file (claim_file_handler
);
1408 check (status
== LDPS_OK
, LDPL_FATAL
,
1409 "could not register the claim_file callback");
1411 if (register_cleanup
)
1413 status
= register_cleanup (cleanup_handler
);
1414 check (status
== LDPS_OK
, LDPL_FATAL
,
1415 "could not register the cleanup callback");
1418 if (register_all_symbols_read
)
1420 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1421 status
= register_all_symbols_read (all_symbols_read_handler
);
1422 check (status
== LDPS_OK
, LDPL_FATAL
,
1423 "could not register the all_symbols_read callback");
1426 char *collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1427 if (collect_gcc_options
)
1429 /* Support -fno-use-linker-plugin by failing to load the plugin
1430 for the case where it is auto-loaded by BFD. */
1431 if (strstr (collect_gcc_options
, "'-fno-use-linker-plugin'"))
1434 if ( strstr (collect_gcc_options
, "'-save-temps'"))
1437 if (strstr (collect_gcc_options
, "'-v'")
1438 || strstr (collect_gcc_options
, "'--verbose'"))