1 /* LTO plugin for gold and/or GNU ld.
2 Copyright (C) 2009-2019 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_SECTION_PREFIX ".gnu.lto_.symtab"
92 #define LTO_SECTION_PREFIX_LEN (sizeof (LTO_SECTION_PREFIX) - 1)
93 #define OFFLOAD_SECTION ".gnu.offload_lto_.opts"
94 #define OFFLOAD_SECTION_LEN (sizeof (OFFLOAD_SECTION) - 1)
96 /* The part of the symbol table the plugin has to keep track of. Note that we
97 must keep SYMS until all_symbols_read is called to give the linker time to
98 copy the symbol information.
99 The id must be 64bit to minimze collisions. */
104 unsigned long long id
;
105 unsigned next_conflict
;
112 struct ld_plugin_symbol
*syms
;
113 unsigned long long id
;
116 /* Encapsulates object file data during symbol scan. */
117 struct plugin_objfile
121 simple_object_read
*objfile
;
122 struct plugin_symtab
*out
;
123 const struct ld_plugin_input_file
*file
;
126 /* All that we have to remember about a file. */
128 struct plugin_file_info
132 struct plugin_symtab symtab
;
133 struct plugin_symtab conflicts
;
136 /* List item with name of the file with offloading. */
138 struct plugin_offload_file
141 struct plugin_offload_file
*next
;
144 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
145 stdio file streams, we do simple label translation here. */
149 ss_none
, /* No underscore prefix. */
150 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
151 ss_uscore
, /* Underscore prefix all symbols. */
154 static char *arguments_file_name
;
155 static ld_plugin_register_claim_file register_claim_file
;
156 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
157 static ld_plugin_get_symbols get_symbols
, get_symbols_v2
;
158 static ld_plugin_register_cleanup register_cleanup
;
159 static ld_plugin_add_input_file add_input_file
;
160 static ld_plugin_add_input_library add_input_library
;
161 static ld_plugin_message message
;
162 static ld_plugin_add_symbols add_symbols
;
164 static struct plugin_file_info
*claimed_files
= NULL
;
165 static unsigned int num_claimed_files
= 0;
166 static unsigned int non_claimed_files
= 0;
168 /* List of files with offloading. */
169 static struct plugin_offload_file
*offload_files
;
170 /* Last file in the list. */
171 static struct plugin_offload_file
*offload_files_last
;
172 /* Last non-archive file in the list. */
173 static struct plugin_offload_file
*offload_files_last_obj
;
174 /* Last LTO file in the list. */
175 static struct plugin_offload_file
*offload_files_last_lto
;
176 /* Total number of files with offloading. */
177 static unsigned num_offload_files
;
179 static char **output_files
= NULL
;
180 static unsigned int num_output_files
= 0;
182 static char **lto_wrapper_argv
;
183 static int lto_wrapper_num_args
;
185 static char **pass_through_items
= NULL
;
186 static unsigned int num_pass_through_items
;
189 static bool save_temps
;
192 static char *resolution_file
= NULL
;
193 static enum ld_plugin_output_file_type linker_output
;
194 static int linker_output_set
;
195 static int linker_output_known
;
196 static const char *link_output_name
= NULL
;
198 /* The version of gold being used, or -1 if not gold. The number is
199 MAJOR * 100 + MINOR. */
200 static int gold_version
= -1;
202 /* Not used by default, but can be overridden at runtime
203 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
204 (in fact, only first letter of style arg is checked.) */
205 static enum symbol_style sym_style
= ss_none
;
208 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
214 message (level
, text
);
217 /* If there is no nicer way to inform the user, fallback to stderr. */
218 fprintf (stderr
, "%s\n", text
);
219 if (level
== LDPL_FATAL
)
224 /* This little wrapper allows check to be called with a non-integer
225 first argument, such as a pointer that must be non-NULL. We can't
226 use c99 bool type to coerce it into range, so we explicitly test. */
227 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
229 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
230 by P and the result is written in ENTRY. The slot number is stored in SLOT.
231 Returns the address of the next entry. */
234 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
238 enum ld_plugin_symbol_kind translate_kind
[] =
247 enum ld_plugin_symbol_visibility translate_visibility
[] =
260 /* cf. Duff's device. */
262 entry
->name
= xstrdup (p
);
267 entry
->name
= concat ("_", p
, NULL
);
270 check (0, LDPL_FATAL
, "invalid symbol style requested");
277 entry
->version
= NULL
;
279 entry
->comdat_key
= p
;
284 if (strlen (entry
->comdat_key
) == 0)
285 entry
->comdat_key
= NULL
;
287 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
290 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
291 entry
->def
= translate_kind
[t
];
295 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
296 entry
->visibility
= translate_visibility
[t
];
299 memcpy (&entry
->size
, p
, sizeof (uint64_t));
302 memcpy (&aux
->slot
, p
, sizeof (uint32_t));
305 entry
->resolution
= LDPR_UNKNOWN
;
307 aux
->next_conflict
= -1;
312 /* Translate the IL symbol table located between DATA and END. Append the
313 slots and symbols to OUT. */
316 translate (char *data
, char *end
, struct plugin_symtab
*out
)
319 struct ld_plugin_symbol
*syms
= NULL
;
322 /* This overestimates the output buffer sizes, but at least
323 the algorithm is O(1) now. */
325 len
= (end
- data
)/8 + out
->nsyms
+ 1;
326 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
327 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
329 for (n
= out
->nsyms
; data
< end
; n
++)
332 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
342 /* Free all memory that is no longer needed after writing the symbol
346 free_1 (struct plugin_file_info
*files
, unsigned num_files
)
349 for (i
= 0; i
< num_files
; i
++)
351 struct plugin_file_info
*info
= &files
[i
];
352 struct plugin_symtab
*symtab
= &info
->symtab
;
354 for (j
= 0; j
< symtab
->nsyms
; j
++)
356 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
358 free (s
->comdat_key
);
365 /* Free all remaining memory. */
371 for (i
= 0; i
< num_claimed_files
; i
++)
373 struct plugin_file_info
*info
= &claimed_files
[i
];
374 struct plugin_symtab
*symtab
= &info
->symtab
;
379 for (i
= 0; i
< num_output_files
; i
++)
380 free (output_files
[i
]);
383 free (claimed_files
);
384 claimed_files
= NULL
;
385 num_claimed_files
= 0;
387 while (offload_files
)
389 struct plugin_offload_file
*ofld
= offload_files
;
390 offload_files
= offload_files
->next
;
393 num_offload_files
= 0;
395 free (arguments_file_name
);
396 arguments_file_name
= NULL
;
399 /* Dump SYMTAB to resolution file F. */
402 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
406 for (j
= 0; j
< symtab
->nsyms
; j
++)
408 uint32_t slot
= symtab
->aux
[j
].slot
;
409 unsigned int resolution
= symtab
->syms
[j
].resolution
;
411 assert (resolution
!= LDPR_UNKNOWN
);
413 fprintf (f
, "%u %" PRI_LL
"x %s %s\n",
414 (unsigned int) slot
, symtab
->aux
[j
].id
,
415 lto_resolution_str
[resolution
],
416 symtab
->syms
[j
].name
);
420 /* Finish the conflicts' resolution information after the linker resolved
421 the original symbols */
424 finish_conflict_resolution (struct plugin_symtab
*symtab
,
425 struct plugin_symtab
*conflicts
)
429 if (conflicts
->nsyms
== 0)
432 for (i
= 0; i
< symtab
->nsyms
; i
++)
434 int resolution
= LDPR_UNKNOWN
;
436 if (symtab
->aux
[i
].next_conflict
== -1)
439 switch (symtab
->syms
[i
].def
)
442 case LDPK_COMMON
: /* ??? */
443 resolution
= LDPR_RESOLVED_IR
;
446 resolution
= LDPR_PREEMPTED_IR
;
450 resolution
= symtab
->syms
[i
].resolution
;
456 assert (resolution
!= LDPR_UNKNOWN
);
458 for (j
= symtab
->aux
[i
].next_conflict
;
460 j
= conflicts
->aux
[j
].next_conflict
)
461 conflicts
->syms
[j
].resolution
= resolution
;
465 /* Free symbol table SYMTAB. */
468 free_symtab (struct plugin_symtab
*symtab
)
476 /* Writes the relocations to disk. */
479 write_resolution (void)
484 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
485 f
= fopen (resolution_file
, "w");
486 check (f
, LDPL_FATAL
, "could not open file");
488 fprintf (f
, "%d\n", num_claimed_files
);
490 for (i
= 0; i
< num_claimed_files
; i
++)
492 struct plugin_file_info
*info
= &claimed_files
[i
];
493 struct plugin_symtab
*symtab
= &info
->symtab
;
494 struct ld_plugin_symbol
*syms
= symtab
->syms
;
496 /* Version 2 of API supports IRONLY_EXP resolution that is
497 accepted by GCC-4.7 and newer. */
499 get_symbols_v2 (info
->handle
, symtab
->nsyms
, syms
);
501 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
503 finish_conflict_resolution (symtab
, &info
->conflicts
);
505 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
506 dump_symtab (f
, symtab
);
507 if (info
->conflicts
.nsyms
)
509 dump_symtab (f
, &info
->conflicts
);
510 free_symtab (&info
->conflicts
);
516 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
520 add_output_files (FILE *f
)
524 const unsigned piece
= 32;
525 char *buf
, *s
= xmalloc (piece
);
530 if (!fgets (buf
, piece
, f
))
536 if (s
[len
- 1] != '\n')
538 s
= xrealloc (s
, len
+ piece
);
546 = xrealloc (output_files
, num_output_files
* sizeof (char *));
547 output_files
[num_output_files
- 1] = s
;
548 add_input_file (output_files
[num_output_files
- 1]);
552 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
556 exec_lto_wrapper (char *argv
[])
562 FILE *wrapper_output
;
567 /* Write argv to a file to avoid a command line that is too long
568 Save the file locally on save-temps. */
569 if (save_temps
&& link_output_name
)
571 arguments_file_name
= (char *) xmalloc (strlen (link_output_name
)
572 + sizeof (".lto_wrapper_args") + 1);
573 strcpy (arguments_file_name
, link_output_name
);
574 strcat (arguments_file_name
, ".lto_wrapper_args");
577 arguments_file_name
= make_temp_file (".lto_wrapper_args");
578 check (arguments_file_name
, LDPL_FATAL
,
579 "Failed to generate a temorary file name");
581 args
= fopen (arguments_file_name
, "w");
582 check (args
, LDPL_FATAL
, "could not open arguments file");
584 t
= writeargv (&argv
[1], args
);
585 check (t
== 0, LDPL_FATAL
, "could not write arguments");
587 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
589 at_args
= concat ("@", arguments_file_name
, NULL
);
590 check (at_args
, LDPL_FATAL
, "could not allocate");
592 for (i
= 1; argv
[i
]; i
++)
595 /* Check the input argument list for a verbose marker too. */
596 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
605 for (i
= 0; argv
[i
]; i
++)
606 fprintf (stderr
, "%s ", argv
[i
]);
607 fprintf (stderr
, "\n");
610 new_argv
[0] = argv
[0];
611 new_argv
[1] = at_args
;
616 for (i
= 0; new_argv
[i
]; i
++)
617 fprintf (stderr
, "%s ", new_argv
[i
]);
618 fprintf (stderr
, "\n");
621 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
622 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
624 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
625 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
626 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
628 wrapper_output
= pex_read_output (pex
, 0);
629 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
631 add_output_files (wrapper_output
);
633 t
= pex_get_status (pex
, 1, &status
);
634 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
635 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
636 "lto-wrapper failed");
643 /* Pass the original files back to the linker. */
646 use_original_files (void)
649 for (i
= 0; i
< num_claimed_files
; i
++)
651 struct plugin_file_info
*info
= &claimed_files
[i
];
652 add_input_file (info
->name
);
657 /* Called by the linker once all symbols have been read. */
659 static enum ld_plugin_status
660 all_symbols_read_handler (void)
663 unsigned num_lto_args
= num_claimed_files
+ lto_wrapper_num_args
+ 2
664 + !linker_output_known
;
666 const char *linker_output_str
= NULL
;
667 const char **lto_arg_ptr
;
668 if (num_claimed_files
+ num_offload_files
== 0)
673 use_original_files ();
677 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
678 lto_arg_ptr
= (const char **) lto_argv
;
679 assert (lto_wrapper_argv
);
683 free_1 (claimed_files
, num_claimed_files
);
685 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
686 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
688 if (!linker_output_known
)
690 assert (linker_output_set
);
691 switch (linker_output
)
694 if (non_claimed_files
)
696 message (LDPL_WARNING
, "incremental linking of LTO and non-LTO "
697 "objects; using -flinker-output=nolto-rel which will "
698 "bypass whole program optimization");
699 linker_output_str
= "-flinker-output=nolto-rel";
702 linker_output_str
= "-flinker-output=rel";
705 linker_output_str
= "-flinker-output=dyn";
708 linker_output_str
= "-flinker-output=pie";
711 linker_output_str
= "-flinker-output=exec";
714 message (LDPL_FATAL
, "unsupported linker output %i", linker_output
);
717 *lto_arg_ptr
++ = xstrdup (linker_output_str
);
720 if (num_offload_files
> 0)
724 char *offload_objects_file_name
;
725 struct plugin_offload_file
*ofld
;
727 offload_objects_file_name
= make_temp_file (".ofldlist");
728 check (offload_objects_file_name
, LDPL_FATAL
,
729 "Failed to generate a temporary file name");
730 f
= fopen (offload_objects_file_name
, "w");
731 check (f
, LDPL_FATAL
, "could not open file with offload objects");
732 fprintf (f
, "%u\n", num_offload_files
);
734 /* Skip the dummy item at the start of the list. */
735 ofld
= offload_files
->next
;
738 fprintf (f
, "%s\n", ofld
->name
);
743 arg
= concat ("-foffload-objects=", offload_objects_file_name
, NULL
);
744 check (arg
, LDPL_FATAL
, "could not allocate");
745 *lto_arg_ptr
++ = arg
;
748 for (i
= 0; i
< num_claimed_files
; i
++)
750 struct plugin_file_info
*info
= &claimed_files
[i
];
752 *lto_arg_ptr
++ = info
->name
;
755 *lto_arg_ptr
++ = NULL
;
756 exec_lto_wrapper (lto_argv
);
760 /* --pass-through is not needed when using gold 1.11 or later. */
761 if (pass_through_items
&& gold_version
< 111)
764 for (i
= 0; i
< num_pass_through_items
; i
++)
766 if (strncmp (pass_through_items
[i
], "-l", 2) == 0)
767 add_input_library (pass_through_items
[i
] + 2);
769 add_input_file (pass_through_items
[i
]);
770 free (pass_through_items
[i
]);
771 pass_through_items
[i
] = NULL
;
773 free (pass_through_items
);
774 pass_through_items
= NULL
;
780 /* Helper, as used in collect2. */
782 file_exists (const char *name
)
784 return access (name
, R_OK
) == 0;
787 /* Unlink FILE unless we have save-temps set.
788 Note that we're saving files if verbose output is set. */
791 maybe_unlink (const char *file
)
793 if (save_temps
&& file_exists (file
))
796 fprintf (stderr
, "[Leaving %s]\n", file
);
800 unlink_if_ordinary (file
);
803 /* Remove temporary files at the end of the link. */
805 static enum ld_plugin_status
806 cleanup_handler (void)
814 if (arguments_file_name
)
815 maybe_unlink (arguments_file_name
);
817 for (i
= 0; i
< num_output_files
; i
++)
818 maybe_unlink (output_files
[i
]);
824 #define SWAP(type, a, b) \
825 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
827 /* Compare two hash table entries */
829 static int eq_sym (const void *a
, const void *b
)
831 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
832 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
834 return !strcmp (as
->name
, bs
->name
);
839 static hashval_t
hash_sym (const void *a
)
841 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
843 return htab_hash_string (as
->name
);
846 /* Determine how strong a symbol is */
848 static int symbol_strength (struct ld_plugin_symbol
*s
)
862 /* In the ld -r case we can get dups in the LTO symbol tables, where
863 the same symbol can have different resolutions (e.g. undefined and defined).
865 We have to keep that in the LTO symbol tables, but the dups confuse
866 gold and then finally gcc by supplying incorrect resolutions.
868 Problem is that the main gold symbol table doesn't know about subids
869 and does not distingush the same symbols in different states.
871 So we drop duplicates from the linker visible symbol table
872 and keep them in a private table. Then later do own symbol
873 resolution for the duplicated based on the results for the
876 Then when writing out the resolution file readd the dropped symbols.
878 XXX how to handle common? */
881 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
883 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
889 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
890 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
892 /* Move all duplicate symbols into the auxiliary conflicts table. */
894 for (i
= 0; i
< t
->nsyms
; i
++)
896 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
897 struct sym_aux
*aux
= &t
->aux
[i
];
900 slot
= htab_find_slot (symtab
, s
, INSERT
);
904 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
905 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
907 /* Always let the linker resolve the strongest symbol */
908 if (symbol_strength (orig
) < symbol_strength (s
))
910 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
911 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
912 SWAP (unsigned long long, orig_aux
->id
, aux
->id
);
913 /* Don't swap conflict chain pointer */
916 /* Move current symbol into the conflicts table */
917 cnf
= conflicts
->nsyms
++;
918 conflicts
->syms
[cnf
] = *s
;
919 conflicts
->aux
[cnf
] = *aux
;
920 aux
= &conflicts
->aux
[cnf
];
922 /* Update conflicts chain of the original symbol */
923 aux
->next_conflict
= orig_aux
->next_conflict
;
924 orig_aux
->next_conflict
= cnf
;
929 /* Remove previous duplicates in the main table */
936 /* Put original into the hash table */
937 *slot
= &t
->syms
[out
];
941 assert (conflicts
->nsyms
<= outlen
);
942 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
945 htab_delete (symtab
);
948 /* Process one section of an object file. */
951 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
953 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
955 char *secdatastart
, *secdata
;
957 if (strncmp (name
, LTO_SECTION_PREFIX
, LTO_SECTION_PREFIX_LEN
) != 0)
960 s
= strrchr (name
, '.');
962 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
963 secdata
= secdatastart
= xmalloc (length
);
964 offset
+= obj
->file
->offset
;
965 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
970 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
978 else if (errno
!= EINTR
)
985 translate (secdatastart
, secdata
, obj
->out
);
992 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
993 /* Force claim_file_handler to abandon this file. */
999 /* Find an offload section of an object file. */
1002 process_offload_section (void *data
, const char *name
, off_t offset
, off_t len
)
1004 if (!strncmp (name
, OFFLOAD_SECTION
, OFFLOAD_SECTION_LEN
))
1006 struct plugin_objfile
*obj
= (struct plugin_objfile
*) data
;
1014 /* Callback used by gold to check if the plugin will claim FILE. Writes
1015 the result in CLAIMED. */
1017 static enum ld_plugin_status
1018 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
1020 enum ld_plugin_status status
;
1021 struct plugin_objfile obj
;
1022 struct plugin_file_info lto_file
;
1026 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
1028 if (file
->offset
!= 0)
1030 /* We pass the offset of the actual file, not the archive header.
1031 Can't use PRIx64, because that's C99, so we have to print the
1032 64-bit hex int as two 32-bit ones. Use xasprintf instead of
1033 asprintf because asprintf doesn't work as expected on some older
1036 lo
= file
->offset
& 0xffffffff;
1037 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
1038 lto_file
.name
= hi
? xasprintf ("%s@0x%x%08x", file
->name
, hi
, lo
)
1039 : xasprintf ("%s@0x%x", file
->name
, lo
);
1043 lto_file
.name
= xstrdup (file
->name
);
1045 lto_file
.handle
= file
->handle
;
1051 obj
.out
= <o_file
.symtab
;
1053 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
1055 /* No file, but also no error code means unrecognized format; just skip it. */
1056 if (!obj
.objfile
&& !err
)
1060 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
, &err
);
1062 if (!obj
.objfile
|| errmsg
)
1065 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
1068 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
1073 simple_object_find_sections (obj
.objfile
, process_offload_section
,
1076 if (obj
.found
== 0 && obj
.offload
== 0)
1080 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
1084 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
1085 lto_file
.symtab
.syms
);
1086 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
1088 num_claimed_files
++;
1090 xrealloc (claimed_files
,
1091 num_claimed_files
* sizeof (struct plugin_file_info
));
1092 claimed_files
[num_claimed_files
- 1] = lto_file
;
1097 if (offload_files
== NULL
)
1099 /* Add dummy item to the start of the list. */
1100 offload_files
= xmalloc (sizeof (struct plugin_offload_file
));
1101 offload_files
->name
= NULL
;
1102 offload_files
->next
= NULL
;
1103 offload_files_last
= offload_files
;
1106 /* If this is an LTO file without offload, and it is the first LTO file, save
1107 the pointer to the last offload file in the list. Further offload LTO
1108 files will be inserted after it, if any. */
1109 if (*claimed
&& obj
.offload
== 0 && offload_files_last_lto
== NULL
)
1110 offload_files_last_lto
= offload_files_last
;
1112 if (obj
.offload
== 1)
1114 /* Add file to the list. The order must be exactly the same as the final
1115 order after recompilation and linking, otherwise host and target tables
1116 with addresses wouldn't match. If a static library contains both LTO
1117 and non-LTO objects, ld and gold link them in a different order. */
1118 struct plugin_offload_file
*ofld
1119 = xmalloc (sizeof (struct plugin_offload_file
));
1120 ofld
->name
= lto_file
.name
;
1123 if (*claimed
&& offload_files_last_lto
== NULL
&& file
->offset
!= 0
1124 && gold_version
== -1)
1126 /* ld only: insert first LTO file from the archive after the last real
1127 object file immediately preceding the archive, or at the begin of
1128 the list if there was no real objects before archives. */
1129 if (offload_files_last_obj
!= NULL
)
1131 ofld
->next
= offload_files_last_obj
->next
;
1132 offload_files_last_obj
->next
= ofld
;
1136 ofld
->next
= offload_files
->next
;
1137 offload_files
->next
= ofld
;
1140 else if (*claimed
&& offload_files_last_lto
!= NULL
)
1142 /* Insert LTO file after the last LTO file in the list. */
1143 ofld
->next
= offload_files_last_lto
->next
;
1144 offload_files_last_lto
->next
= ofld
;
1147 /* Add non-LTO file or first non-archive LTO file to the end of the
1149 offload_files_last
->next
= ofld
;
1151 if (ofld
->next
== NULL
)
1152 offload_files_last
= ofld
;
1153 if (file
->offset
== 0)
1154 offload_files_last_obj
= ofld
;
1156 offload_files_last_lto
= ofld
;
1157 num_offload_files
++;
1163 non_claimed_files
++;
1164 free (lto_file
.name
);
1168 simple_object_release_read (obj
.objfile
);
1173 /* Parse the plugin options. */
1176 process_option (const char *option
)
1178 if (strcmp (option
, "-linker-output-known") == 0)
1179 linker_output_known
= 1;
1180 if (strcmp (option
, "-debug") == 0)
1182 else if ((strcmp (option
, "-v") == 0)
1183 || (strcmp (option
, "--verbose") == 0))
1185 else if (strcmp (option
, "-save-temps") == 0)
1187 else if (strcmp (option
, "-nop") == 0)
1189 else if (!strncmp (option
, "-pass-through=", strlen("-pass-through=")))
1191 num_pass_through_items
++;
1192 pass_through_items
= xrealloc (pass_through_items
,
1193 num_pass_through_items
* sizeof (char *));
1194 pass_through_items
[num_pass_through_items
- 1] =
1195 xstrdup (option
+ strlen ("-pass-through="));
1197 else if (!strncmp (option
, "-sym-style=", sizeof ("-sym-style=") - 1))
1199 switch (option
[sizeof ("-sym-style=") - 1])
1202 sym_style
= ss_win32
;
1205 sym_style
= ss_uscore
;
1208 sym_style
= ss_none
;
1215 char *opt
= xstrdup (option
);
1216 lto_wrapper_num_args
+= 1;
1217 size
= lto_wrapper_num_args
* sizeof (char *);
1218 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
1219 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
1220 if (strncmp (option
, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
1221 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
1223 save_temps
= save_temps
|| debug
;
1224 verbose
= verbose
|| debug
;
1227 /* Called by gold after loading the plugin. TV is the transfer vector. */
1229 enum ld_plugin_status
1230 onload (struct ld_plugin_tv
*tv
)
1232 struct ld_plugin_tv
*p
;
1233 enum ld_plugin_status status
;
1241 message
= p
->tv_u
.tv_message
;
1243 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1244 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
1246 case LDPT_ADD_SYMBOLS
:
1247 add_symbols
= p
->tv_u
.tv_add_symbols
;
1249 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1250 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
1252 case LDPT_GET_SYMBOLS_V2
:
1253 get_symbols_v2
= p
->tv_u
.tv_get_symbols
;
1255 case LDPT_GET_SYMBOLS
:
1256 get_symbols
= p
->tv_u
.tv_get_symbols
;
1258 case LDPT_REGISTER_CLEANUP_HOOK
:
1259 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
1261 case LDPT_ADD_INPUT_FILE
:
1262 add_input_file
= p
->tv_u
.tv_add_input_file
;
1264 case LDPT_ADD_INPUT_LIBRARY
:
1265 add_input_library
= p
->tv_u
.tv_add_input_library
;
1268 process_option (p
->tv_u
.tv_string
);
1270 case LDPT_GOLD_VERSION
:
1271 gold_version
= p
->tv_u
.tv_val
;
1273 case LDPT_LINKER_OUTPUT
:
1274 linker_output
= (enum ld_plugin_output_file_type
) p
->tv_u
.tv_val
;
1275 linker_output_set
= 1;
1277 case LDPT_OUTPUT_NAME
:
1278 /* We only use this to make user-friendly temp file names. */
1279 link_output_name
= p
->tv_u
.tv_string
;
1287 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1288 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1289 status
= register_claim_file (claim_file_handler
);
1290 check (status
== LDPS_OK
, LDPL_FATAL
,
1291 "could not register the claim_file callback");
1293 if (register_cleanup
)
1295 status
= register_cleanup (cleanup_handler
);
1296 check (status
== LDPS_OK
, LDPL_FATAL
,
1297 "could not register the cleanup callback");
1300 if (register_all_symbols_read
)
1302 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1303 status
= register_all_symbols_read (all_symbols_read_handler
);
1304 check (status
== LDPS_OK
, LDPL_FATAL
,
1305 "could not register the all_symbols_read callback");
1308 char *collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1309 if (collect_gcc_options
)
1311 /* Support -fno-use-linker-plugin by failing to load the plugin
1312 for the case where it is auto-loaded by BFD. */
1313 if (strstr (collect_gcc_options
, "'-fno-use-linker-plugin'"))
1316 if ( strstr (collect_gcc_options
, "'-save-temps'"))
1319 if (strstr (collect_gcc_options
, "'-v'")
1320 || strstr (collect_gcc_options
, "'--verbose'"))