1 /* LTO plugin for gold and/or GNU ld.
2 Copyright (C) 2009, 2010 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 2 options of its 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. */
50 #include <sys/types.h>
51 #ifdef HAVE_SYS_WAIT_H
55 #define WIFEXITED(S) (((S) & 0xff) == 0)
58 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
60 #include <libiberty.h>
62 #include "../gcc/lto/common.h"
63 #include "simple-object.h"
64 #include "plugin-api.h"
66 /* We need to use I64 instead of ll width-specifier on native Windows.
67 The reason for this is that older MS-runtimes don't support the ll. */
74 /* Handle opening elf files on hosts, such as Windows, that may use
75 text file handling that will break binary access. */
80 /* Segment name for LTO sections. This is only used for Mach-O.
81 FIXME: This needs to be kept in sync with darwin.c. */
83 #define LTO_SEGMENT_NAME "__GNU_LTO"
85 /* LTO magic section name. */
87 #define LTO_SECTION_PREFIX ".gnu.lto_.symtab"
88 #define LTO_SECTION_PREFIX_LEN (sizeof (LTO_SECTION_PREFIX) - 1)
89 #define OFFLOAD_SECTION ".gnu.offload_lto_.opts"
90 #define OFFLOAD_SECTION_LEN (sizeof (OFFLOAD_SECTION) - 1)
92 /* The part of the symbol table the plugin has to keep track of. Note that we
93 must keep SYMS until all_symbols_read is called to give the linker time to
94 copy the symbol information.
95 The id must be 64bit to minimze collisions. */
100 unsigned long long id
;
101 unsigned next_conflict
;
108 struct ld_plugin_symbol
*syms
;
109 unsigned long long id
;
112 /* Encapsulates object file data during symbol scan. */
113 struct plugin_objfile
117 simple_object_read
*objfile
;
118 struct plugin_symtab
*out
;
119 const struct ld_plugin_input_file
*file
;
122 /* All that we have to remember about a file. */
124 struct plugin_file_info
128 struct plugin_symtab symtab
;
129 struct plugin_symtab conflicts
;
132 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
133 stdio file streams, we do simple label translation here. */
137 ss_none
, /* No underscore prefix. */
138 ss_win32
, /* Underscore prefix any symbol not beginning with '@'. */
139 ss_uscore
, /* Underscore prefix all symbols. */
142 static char *arguments_file_name
;
143 static ld_plugin_register_claim_file register_claim_file
;
144 static ld_plugin_register_all_symbols_read register_all_symbols_read
;
145 static ld_plugin_get_symbols get_symbols
, get_symbols_v2
;
146 static ld_plugin_register_cleanup register_cleanup
;
147 static ld_plugin_add_input_file add_input_file
;
148 static ld_plugin_release_input_file release_input_file
;
149 static ld_plugin_add_input_library add_input_library
;
150 static ld_plugin_message message
;
151 static ld_plugin_add_symbols add_symbols
;
153 static struct plugin_file_info
*claimed_files
= NULL
;
154 static unsigned int num_claimed_files
= 0;
156 static struct plugin_file_info
*offload_files
= NULL
;
157 static unsigned int num_offload_files
= 0;
159 static char **output_files
= NULL
;
160 static unsigned int num_output_files
= 0;
162 static char **lto_wrapper_argv
;
163 static int lto_wrapper_num_args
;
165 static char **pass_through_items
= NULL
;
166 static unsigned int num_pass_through_items
;
170 static char *resolution_file
= NULL
;
172 /* The version of gold being used, or -1 if not gold. The number is
173 MAJOR * 100 + MINOR. */
174 static int gold_version
= -1;
176 /* Not used by default, but can be overridden at runtime
177 by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
178 (in fact, only first letter of style arg is checked.) */
179 static enum symbol_style sym_style
= ss_none
;
182 check_1 (int gate
, enum ld_plugin_level level
, const char *text
)
188 message (level
, text
);
191 /* If there is no nicer way to inform the user, fallback to stderr. */
192 fprintf (stderr
, "%s\n", text
);
193 if (level
== LDPL_FATAL
)
198 /* This little wrapper allows check to be called with a non-integer
199 first argument, such as a pointer that must be non-NULL. We can't
200 use c99 bool type to coerce it into range, so we explicitly test. */
201 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
203 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
204 by P and the result is written in ENTRY. The slot number is stored in SLOT.
205 Returns the address of the next entry. */
208 parse_table_entry (char *p
, struct ld_plugin_symbol
*entry
,
212 enum ld_plugin_symbol_kind translate_kind
[] =
221 enum ld_plugin_symbol_visibility translate_visibility
[] =
234 /* cf. Duff's device. */
236 entry
->name
= xstrdup (p
);
241 entry
->name
= concat ("_", p
, NULL
);
244 check (0, LDPL_FATAL
, "invalid symbol style requested");
251 entry
->version
= NULL
;
253 entry
->comdat_key
= p
;
258 if (strlen (entry
->comdat_key
) == 0)
259 entry
->comdat_key
= NULL
;
261 entry
->comdat_key
= xstrdup (entry
->comdat_key
);
264 check (t
<= 4, LDPL_FATAL
, "invalid symbol kind found");
265 entry
->def
= translate_kind
[t
];
269 check (t
<= 3, LDPL_FATAL
, "invalid symbol visibility found");
270 entry
->visibility
= translate_visibility
[t
];
273 memcpy (&entry
->size
, p
, sizeof (uint64_t));
276 memcpy (&aux
->slot
, p
, sizeof (uint32_t));
279 entry
->resolution
= LDPR_UNKNOWN
;
281 aux
->next_conflict
= -1;
286 /* Translate the IL symbol table located between DATA and END. Append the
287 slots and symbols to OUT. */
290 translate (char *data
, char *end
, struct plugin_symtab
*out
)
293 struct ld_plugin_symbol
*syms
= NULL
;
296 /* This overestimates the output buffer sizes, but at least
297 the algorithm is O(1) now. */
299 len
= (end
- data
)/8 + out
->nsyms
+ 1;
300 syms
= xrealloc (out
->syms
, len
* sizeof (struct ld_plugin_symbol
));
301 aux
= xrealloc (out
->aux
, len
* sizeof (struct sym_aux
));
303 for (n
= out
->nsyms
; data
< end
; n
++)
306 data
= parse_table_entry (data
, &syms
[n
], &aux
[n
]);
316 /* Free all memory that is no longer needed after writing the symbol
320 free_1 (struct plugin_file_info
*files
, unsigned num_files
)
323 for (i
= 0; i
< num_files
; i
++)
325 struct plugin_file_info
*info
= &files
[i
];
326 struct plugin_symtab
*symtab
= &info
->symtab
;
328 for (j
= 0; j
< symtab
->nsyms
; j
++)
330 struct ld_plugin_symbol
*s
= &symtab
->syms
[j
];
332 free (s
->comdat_key
);
339 /* Free all remaining memory. */
345 for (i
= 0; i
< num_claimed_files
; i
++)
347 struct plugin_file_info
*info
= &claimed_files
[i
];
348 struct plugin_symtab
*symtab
= &info
->symtab
;
353 for (i
= 0; i
< num_offload_files
; i
++)
355 struct plugin_file_info
*info
= &offload_files
[i
];
356 struct plugin_symtab
*symtab
= &info
->symtab
;
361 for (i
= 0; i
< num_output_files
; i
++)
362 free (output_files
[i
]);
365 free (claimed_files
);
366 claimed_files
= NULL
;
367 num_claimed_files
= 0;
369 free (offload_files
);
370 offload_files
= NULL
;
371 num_offload_files
= 0;
373 free (arguments_file_name
);
374 arguments_file_name
= NULL
;
377 /* Dump SYMTAB to resolution file F. */
380 dump_symtab (FILE *f
, struct plugin_symtab
*symtab
)
384 for (j
= 0; j
< symtab
->nsyms
; j
++)
386 uint32_t slot
= symtab
->aux
[j
].slot
;
387 unsigned int resolution
= symtab
->syms
[j
].resolution
;
389 assert (resolution
!= LDPR_UNKNOWN
);
391 fprintf (f
, "%u %" PRI_LL
"x %s %s\n",
392 (unsigned int) slot
, symtab
->aux
[j
].id
,
393 lto_resolution_str
[resolution
],
394 symtab
->syms
[j
].name
);
398 /* Finish the conflicts' resolution information after the linker resolved
399 the original symbols */
402 finish_conflict_resolution (struct plugin_symtab
*symtab
,
403 struct plugin_symtab
*conflicts
)
407 if (conflicts
->nsyms
== 0)
410 for (i
= 0; i
< symtab
->nsyms
; i
++)
412 int resolution
= LDPR_UNKNOWN
;
414 if (symtab
->aux
[i
].next_conflict
== -1)
417 switch (symtab
->syms
[i
].def
)
420 case LDPK_COMMON
: /* ??? */
421 resolution
= LDPR_RESOLVED_IR
;
424 resolution
= LDPR_PREEMPTED_IR
;
428 resolution
= symtab
->syms
[i
].resolution
;
434 assert (resolution
!= LDPR_UNKNOWN
);
436 for (j
= symtab
->aux
[i
].next_conflict
;
438 j
= conflicts
->aux
[j
].next_conflict
)
439 conflicts
->syms
[j
].resolution
= resolution
;
443 /* Free symbol table SYMTAB. */
446 free_symtab (struct plugin_symtab
*symtab
)
454 /* Writes the relocations to disk. */
457 write_resolution (void)
462 check (resolution_file
, LDPL_FATAL
, "resolution file not specified");
463 f
= fopen (resolution_file
, "w");
464 check (f
, LDPL_FATAL
, "could not open file");
466 fprintf (f
, "%d\n", num_claimed_files
);
468 for (i
= 0; i
< num_claimed_files
; i
++)
470 struct plugin_file_info
*info
= &claimed_files
[i
];
471 struct plugin_symtab
*symtab
= &info
->symtab
;
472 struct ld_plugin_symbol
*syms
= symtab
->syms
;
474 /* Version 2 of API supports IRONLY_EXP resolution that is
475 accepted by GCC-4.7 and newer. */
477 get_symbols_v2 (info
->handle
, symtab
->nsyms
, syms
);
479 get_symbols (info
->handle
, symtab
->nsyms
, syms
);
481 finish_conflict_resolution (symtab
, &info
->conflicts
);
483 fprintf (f
, "%s %d\n", info
->name
, symtab
->nsyms
+ info
->conflicts
.nsyms
);
484 dump_symtab (f
, symtab
);
485 if (info
->conflicts
.nsyms
)
487 dump_symtab (f
, &info
->conflicts
);
488 free_symtab (&info
->conflicts
);
494 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
498 add_output_files (FILE *f
)
502 const unsigned piece
= 32;
503 char *buf
, *s
= xmalloc (piece
);
508 if (!fgets (buf
, piece
, f
))
514 if (s
[len
- 1] != '\n')
516 s
= xrealloc (s
, len
+ piece
);
524 = xrealloc (output_files
, num_output_files
* sizeof (char *));
525 output_files
[num_output_files
- 1] = s
;
526 add_input_file (output_files
[num_output_files
- 1]);
530 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
534 exec_lto_wrapper (char *argv
[])
540 FILE *wrapper_output
;
545 /* Write argv to a file to avoid a command line that is too long. */
546 arguments_file_name
= make_temp_file ("");
547 check (arguments_file_name
, LDPL_FATAL
,
548 "Failed to generate a temorary file name");
550 args
= fopen (arguments_file_name
, "w");
551 check (args
, LDPL_FATAL
, "could not open arguments file");
553 t
= writeargv (&argv
[1], args
);
554 check (t
== 0, LDPL_FATAL
, "could not write arguments");
556 check (t
== 0, LDPL_FATAL
, "could not close arguments file");
558 at_args
= concat ("@", arguments_file_name
, NULL
);
559 check (at_args
, LDPL_FATAL
, "could not allocate");
561 for (i
= 1; argv
[i
]; i
++)
564 if (a
[0] == '-' && a
[1] == 'v' && a
[2] == '\0')
566 for (i
= 0; argv
[i
]; i
++)
567 fprintf (stderr
, "%s ", argv
[i
]);
568 fprintf (stderr
, "\n");
573 new_argv
[0] = argv
[0];
574 new_argv
[1] = at_args
;
579 for (i
= 0; new_argv
[i
]; i
++)
580 fprintf (stderr
, "%s ", new_argv
[i
]);
581 fprintf (stderr
, "\n");
585 pex
= pex_init (PEX_USE_PIPES
, "lto-wrapper", NULL
);
586 check (pex
!= NULL
, LDPL_FATAL
, "could not pex_init lto-wrapper");
588 errmsg
= pex_run (pex
, 0, new_argv
[0], new_argv
, NULL
, NULL
, &t
);
589 check (errmsg
== NULL
, LDPL_FATAL
, "could not run lto-wrapper");
590 check (t
== 0, LDPL_FATAL
, "could not run lto-wrapper");
592 wrapper_output
= pex_read_output (pex
, 0);
593 check (wrapper_output
, LDPL_FATAL
, "could not read lto-wrapper output");
595 add_output_files (wrapper_output
);
597 t
= pex_get_status (pex
, 1, &status
);
598 check (t
== 1, LDPL_FATAL
, "could not get lto-wrapper exit status");
599 check (WIFEXITED (status
) && WEXITSTATUS (status
) == 0, LDPL_FATAL
,
600 "lto-wrapper failed");
607 /* Pass the original files back to the linker. */
610 use_original_files (void)
613 for (i
= 0; i
< num_claimed_files
; i
++)
615 struct plugin_file_info
*info
= &claimed_files
[i
];
616 add_input_file (info
->name
);
621 /* Called by the linker once all symbols have been read. */
623 static enum ld_plugin_status
624 all_symbols_read_handler (void)
627 unsigned num_lto_args
628 = num_claimed_files
+ num_offload_files
+ lto_wrapper_num_args
+ 1;
630 const char **lto_arg_ptr
;
631 if (num_claimed_files
+ num_offload_files
== 0)
636 use_original_files ();
640 lto_argv
= (char **) xcalloc (sizeof (char *), num_lto_args
);
641 lto_arg_ptr
= (const char **) lto_argv
;
642 assert (lto_wrapper_argv
);
646 free_1 (claimed_files
, num_claimed_files
);
647 free_1 (offload_files
, num_offload_files
);
649 for (i
= 0; i
< lto_wrapper_num_args
; i
++)
650 *lto_arg_ptr
++ = lto_wrapper_argv
[i
];
652 for (i
= 0; i
< num_claimed_files
; i
++)
654 struct plugin_file_info
*info
= &claimed_files
[i
];
656 *lto_arg_ptr
++ = info
->name
;
659 for (i
= 0; i
< num_offload_files
; i
++)
661 struct plugin_file_info
*info
= &offload_files
[i
];
663 *lto_arg_ptr
++ = info
->name
;
666 *lto_arg_ptr
++ = NULL
;
667 exec_lto_wrapper (lto_argv
);
671 /* --pass-through is not needed when using gold 1.11 or later. */
672 if (pass_through_items
&& gold_version
< 111)
675 for (i
= 0; i
< num_pass_through_items
; i
++)
677 if (strncmp (pass_through_items
[i
], "-l", 2) == 0)
678 add_input_library (pass_through_items
[i
] + 2);
680 add_input_file (pass_through_items
[i
]);
681 free (pass_through_items
[i
]);
682 pass_through_items
[i
] = NULL
;
684 free (pass_through_items
);
685 pass_through_items
= NULL
;
691 /* Remove temporary files at the end of the link. */
693 static enum ld_plugin_status
694 cleanup_handler (void)
702 if (arguments_file_name
)
704 t
= unlink (arguments_file_name
);
705 check (t
== 0, LDPL_FATAL
, "could not unlink arguments file");
708 for (i
= 0; i
< num_output_files
; i
++)
710 t
= unlink (output_files
[i
]);
711 check (t
== 0, LDPL_FATAL
, "could not unlink output file");
718 #define SWAP(type, a, b) \
719 do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
721 /* Compare two hash table entries */
723 static int eq_sym (const void *a
, const void *b
)
725 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
726 const struct ld_plugin_symbol
*bs
= (const struct ld_plugin_symbol
*)b
;
728 return !strcmp (as
->name
, bs
->name
);
733 static hashval_t
hash_sym (const void *a
)
735 const struct ld_plugin_symbol
*as
= (const struct ld_plugin_symbol
*)a
;
737 return htab_hash_string (as
->name
);
740 /* Determine how strong a symbol is */
742 static int symbol_strength (struct ld_plugin_symbol
*s
)
756 /* In the ld -r case we can get dups in the LTO symbol tables, where
757 the same symbol can have different resolutions (e.g. undefined and defined).
759 We have to keep that in the LTO symbol tables, but the dups confuse
760 gold and then finally gcc by supplying incorrect resolutions.
762 Problem is that the main gold symbol table doesn't know about subids
763 and does not distingush the same symbols in different states.
765 So we drop duplicates from the linker visible symbol table
766 and keep them in a private table. Then later do own symbol
767 resolution for the duplicated based on the results for the
770 Then when writing out the resolution file readd the dropped symbols.
772 XXX how to handle common? */
775 resolve_conflicts (struct plugin_symtab
*t
, struct plugin_symtab
*conflicts
)
777 htab_t symtab
= htab_create (t
->nsyms
, hash_sym
, eq_sym
, NULL
);
783 conflicts
->syms
= xmalloc (sizeof (struct ld_plugin_symbol
) * outlen
);
784 conflicts
->aux
= xmalloc (sizeof (struct sym_aux
) * outlen
);
786 /* Move all duplicate symbols into the auxiliary conflicts table. */
788 for (i
= 0; i
< t
->nsyms
; i
++)
790 struct ld_plugin_symbol
*s
= &t
->syms
[i
];
791 struct sym_aux
*aux
= &t
->aux
[i
];
794 slot
= htab_find_slot (symtab
, s
, INSERT
);
798 struct ld_plugin_symbol
*orig
= (struct ld_plugin_symbol
*)*slot
;
799 struct sym_aux
*orig_aux
= &t
->aux
[orig
- t
->syms
];
801 /* Always let the linker resolve the strongest symbol */
802 if (symbol_strength (orig
) < symbol_strength (s
))
804 SWAP (struct ld_plugin_symbol
, *orig
, *s
);
805 SWAP (uint32_t, orig_aux
->slot
, aux
->slot
);
806 SWAP (unsigned long long, orig_aux
->id
, aux
->id
);
807 /* Don't swap conflict chain pointer */
810 /* Move current symbol into the conflicts table */
811 cnf
= conflicts
->nsyms
++;
812 conflicts
->syms
[cnf
] = *s
;
813 conflicts
->aux
[cnf
] = *aux
;
814 aux
= &conflicts
->aux
[cnf
];
816 /* Update conflicts chain of the original symbol */
817 aux
->next_conflict
= orig_aux
->next_conflict
;
818 orig_aux
->next_conflict
= cnf
;
823 /* Remove previous duplicates in the main table */
830 /* Put original into the hash table */
831 *slot
= &t
->syms
[out
];
835 assert (conflicts
->nsyms
<= outlen
);
836 assert (conflicts
->nsyms
+ out
== t
->nsyms
);
839 htab_delete (symtab
);
842 /* Process one section of an object file. */
845 process_symtab (void *data
, const char *name
, off_t offset
, off_t length
)
847 struct plugin_objfile
*obj
= (struct plugin_objfile
*)data
;
849 char *secdatastart
, *secdata
;
851 if (strncmp (name
, LTO_SECTION_PREFIX
, LTO_SECTION_PREFIX_LEN
) != 0)
854 s
= strrchr (name
, '.');
856 sscanf (s
, ".%" PRI_LL
"x", &obj
->out
->id
);
857 secdata
= secdatastart
= xmalloc (length
);
858 offset
+= obj
->file
->offset
;
859 if (offset
!= lseek (obj
->file
->fd
, offset
, SEEK_SET
))
864 ssize_t got
= read (obj
->file
->fd
, secdata
, length
);
872 else if (errno
!= EINTR
)
879 translate (secdatastart
, secdata
, obj
->out
);
886 message (LDPL_FATAL
, "%s: corrupt object file", obj
->file
->name
);
887 /* Force claim_file_handler to abandon this file. */
893 /* Find an offload section of an object file. */
896 process_offload_section (void *data
, const char *name
, off_t offset
, off_t len
)
898 if (!strncmp (name
, OFFLOAD_SECTION
, OFFLOAD_SECTION_LEN
))
900 struct plugin_objfile
*obj
= (struct plugin_objfile
*) data
;
908 /* Callback used by gold to check if the plugin will claim FILE. Writes
909 the result in CLAIMED. */
911 static enum ld_plugin_status
912 claim_file_handler (const struct ld_plugin_input_file
*file
, int *claimed
)
914 enum ld_plugin_status status
;
915 struct plugin_objfile obj
;
916 struct plugin_file_info lto_file
;
920 memset (<o_file
, 0, sizeof (struct plugin_file_info
));
922 if (file
->offset
!= 0)
925 /* We pass the offset of the actual file, not the archive header.
926 Can't use PRIx64, because that's C99, so we have to print the
927 64-bit hex int as two 32-bit ones. */
929 lo
= file
->offset
& 0xffffffff;
930 hi
= ((int64_t)file
->offset
>> 32) & 0xffffffff;
931 t
= hi
? asprintf (&objname
, "%s@0x%x%08x", file
->name
, lo
, hi
)
932 : asprintf (&objname
, "%s@0x%x", file
->name
, lo
);
933 check (t
>= 0, LDPL_FATAL
, "asprintf failed");
934 lto_file
.name
= objname
;
938 lto_file
.name
= xstrdup (file
->name
);
940 lto_file
.handle
= file
->handle
;
946 obj
.out
= <o_file
.symtab
;
948 obj
.objfile
= simple_object_start_read (file
->fd
, file
->offset
, LTO_SEGMENT_NAME
,
950 /* No file, but also no error code means unrecognized format; just skip it. */
951 if (!obj
.objfile
&& !err
)
955 errmsg
= simple_object_find_sections (obj
.objfile
, process_symtab
, &obj
, &err
);
957 if (!obj
.objfile
|| errmsg
)
960 message (LDPL_FATAL
, "%s: %s: %s", file
->name
, errmsg
,
963 message (LDPL_FATAL
, "%s: %s", file
->name
, errmsg
);
968 simple_object_find_sections (obj
.objfile
, process_offload_section
,
971 if (obj
.found
== 0 && obj
.offload
== 0)
975 resolve_conflicts (<o_file
.symtab
, <o_file
.conflicts
);
979 status
= add_symbols (file
->handle
, lto_file
.symtab
.nsyms
,
980 lto_file
.symtab
.syms
);
981 check (status
== LDPS_OK
, LDPL_FATAL
, "could not add symbols");
985 xrealloc (claimed_files
,
986 num_claimed_files
* sizeof (struct plugin_file_info
));
987 claimed_files
[num_claimed_files
- 1] = lto_file
;
990 if (obj
.found
== 0 && obj
.offload
== 1)
994 xrealloc (offload_files
,
995 num_offload_files
* sizeof (struct plugin_file_info
));
996 offload_files
[num_offload_files
- 1] = lto_file
;
1001 if (release_input_file
)
1002 release_input_file (file
);
1007 free (lto_file
.name
);
1011 simple_object_release_read (obj
.objfile
);
1016 /* Parse the plugin options. */
1019 process_option (const char *option
)
1021 if (strcmp (option
, "-debug") == 0)
1023 else if (strcmp (option
, "-nop") == 0)
1025 else if (!strncmp (option
, "-pass-through=", strlen("-pass-through=")))
1027 num_pass_through_items
++;
1028 pass_through_items
= xrealloc (pass_through_items
,
1029 num_pass_through_items
* sizeof (char *));
1030 pass_through_items
[num_pass_through_items
- 1] =
1031 xstrdup (option
+ strlen ("-pass-through="));
1033 else if (!strncmp (option
, "-sym-style=", sizeof ("-sym-style=") - 1))
1035 switch (option
[sizeof ("-sym-style=") - 1])
1038 sym_style
= ss_win32
;
1041 sym_style
= ss_uscore
;
1044 sym_style
= ss_none
;
1051 char *opt
= xstrdup (option
);
1052 lto_wrapper_num_args
+= 1;
1053 size
= lto_wrapper_num_args
* sizeof (char *);
1054 lto_wrapper_argv
= (char **) xrealloc (lto_wrapper_argv
, size
);
1055 lto_wrapper_argv
[lto_wrapper_num_args
- 1] = opt
;
1056 if (strncmp (option
, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
1057 resolution_file
= opt
+ sizeof ("-fresolution=") - 1;
1061 /* Called by gold after loading the plugin. TV is the transfer vector. */
1063 enum ld_plugin_status
1064 onload (struct ld_plugin_tv
*tv
)
1066 struct ld_plugin_tv
*p
;
1067 enum ld_plugin_status status
;
1075 message
= p
->tv_u
.tv_message
;
1077 case LDPT_REGISTER_CLAIM_FILE_HOOK
:
1078 register_claim_file
= p
->tv_u
.tv_register_claim_file
;
1080 case LDPT_ADD_SYMBOLS
:
1081 add_symbols
= p
->tv_u
.tv_add_symbols
;
1083 case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK
:
1084 register_all_symbols_read
= p
->tv_u
.tv_register_all_symbols_read
;
1086 case LDPT_GET_SYMBOLS_V2
:
1087 get_symbols_v2
= p
->tv_u
.tv_get_symbols
;
1089 case LDPT_GET_SYMBOLS
:
1090 get_symbols
= p
->tv_u
.tv_get_symbols
;
1092 case LDPT_REGISTER_CLEANUP_HOOK
:
1093 register_cleanup
= p
->tv_u
.tv_register_cleanup
;
1095 case LDPT_ADD_INPUT_FILE
:
1096 add_input_file
= p
->tv_u
.tv_add_input_file
;
1098 case LDPT_RELEASE_INPUT_FILE
:
1099 release_input_file
= p
->tv_u
.tv_release_input_file
;
1101 case LDPT_ADD_INPUT_LIBRARY
:
1102 add_input_library
= p
->tv_u
.tv_add_input_library
;
1105 process_option (p
->tv_u
.tv_string
);
1107 case LDPT_GOLD_VERSION
:
1108 gold_version
= p
->tv_u
.tv_val
;
1116 check (register_claim_file
, LDPL_FATAL
, "register_claim_file not found");
1117 check (add_symbols
, LDPL_FATAL
, "add_symbols not found");
1118 status
= register_claim_file (claim_file_handler
);
1119 check (status
== LDPS_OK
, LDPL_FATAL
,
1120 "could not register the claim_file callback");
1122 if (register_cleanup
)
1124 status
= register_cleanup (cleanup_handler
);
1125 check (status
== LDPS_OK
, LDPL_FATAL
,
1126 "could not register the cleanup callback");
1129 if (register_all_symbols_read
)
1131 check (get_symbols
, LDPL_FATAL
, "get_symbols not found");
1132 status
= register_all_symbols_read (all_symbols_read_handler
);
1133 check (status
== LDPS_OK
, LDPL_FATAL
,
1134 "could not register the all_symbols_read callback");
1137 /* Support -fno-use-linker-plugin by failing to load the plugin
1138 for the case where it is auto-loaded by BFD. */
1139 char *collect_gcc_options
= getenv ("COLLECT_GCC_OPTIONS");
1140 if (collect_gcc_options
1141 && strstr (collect_gcc_options
, "'-fno-use-linker-plugin'"))