Adding myself to gdb/MAINTAINERS
[deliverable/binutils-gdb.git] / bfd / plugin.c
CommitLineData
ce3c775b 1/* Plugin support for BFD.
b3adc24a 2 Copyright (C) 2009-2020 Free Software Foundation, Inc.
ce3c775b
NC
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
691bf19c 21#include "sysdep.h"
98950613
AM
22#include "bfd.h"
23
24#if BFD_SUPPORTS_PLUGINS
25
ce3c775b 26#include <assert.h>
17d5dae2 27#ifdef HAVE_DLFCN_H
ce3c775b 28#include <dlfcn.h>
17d5dae2
KT
29#elif defined (HAVE_WINDOWS_H)
30#include <windows.h>
31#else
32#error Unknown how to handle dynamic-load-libraries.
33#endif
ce3c775b
NC
34#include <stdarg.h>
35#include "plugin-api.h"
ce3c775b
NC
36#include "plugin.h"
37#include "libbfd.h"
38#include "libiberty.h"
39#include <dirent.h>
40
17d5dae2
KT
41#if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
42
43#define RTLD_NOW 0 /* Dummy value. */
44
45static void *
46dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
47{
48 return LoadLibrary (file);
49}
50
51static void *
52dlsym (void *handle, const char *name)
53{
54 return GetProcAddress (handle, name);
55}
56
57static int ATTRIBUTE_UNUSED
58dlclose (void *handle)
59{
60 FreeLibrary (handle);
61 return 0;
62}
63
64static const char *
65dlerror (void)
66{
67 return "Unable to load DLL.";
68}
69
70#endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */
71
07d6d2b8
AM
72#define bfd_plugin_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
73#define bfd_plugin_new_section_hook _bfd_generic_new_section_hook
74#define bfd_plugin_get_section_contents _bfd_generic_get_section_contents
ce3c775b 75#define bfd_plugin_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
07d6d2b8
AM
76#define bfd_plugin_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
77#define bfd_plugin_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
78#define bfd_plugin_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
79#define bfd_plugin_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
ce3c775b 80#define bfd_plugin_core_file_matches_executable_p generic_core_file_matches_executable_p
07d6d2b8 81#define bfd_plugin_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
d00dd7dc 82#define bfd_plugin_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false
07d6d2b8
AM
83#define bfd_plugin_get_lineno _bfd_nosymbols_get_lineno
84#define bfd_plugin_find_nearest_line _bfd_nosymbols_find_nearest_line
85#define bfd_plugin_find_line _bfd_nosymbols_find_line
86#define bfd_plugin_find_inliner_info _bfd_nosymbols_find_inliner_info
60bb06bc 87#define bfd_plugin_get_symbol_version_string _bfd_nosymbols_get_symbol_version_string
07d6d2b8
AM
88#define bfd_plugin_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
89#define bfd_plugin_read_minisymbols _bfd_generic_read_minisymbols
90#define bfd_plugin_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
91#define bfd_plugin_set_arch_mach bfd_default_set_arch_mach
92#define bfd_plugin_set_section_contents _bfd_generic_set_section_contents
ce3c775b 93#define bfd_plugin_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
07d6d2b8
AM
94#define bfd_plugin_bfd_relax_section bfd_generic_relax_section
95#define bfd_plugin_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
96#define bfd_plugin_bfd_link_add_symbols _bfd_generic_link_add_symbols
97#define bfd_plugin_bfd_link_just_syms _bfd_generic_link_just_syms
98#define bfd_plugin_bfd_final_link _bfd_generic_final_link
99#define bfd_plugin_bfd_link_split_section _bfd_generic_link_split_section
100#define bfd_plugin_bfd_gc_sections bfd_generic_gc_sections
101#define bfd_plugin_bfd_lookup_section_flags bfd_generic_lookup_section_flags
102#define bfd_plugin_bfd_merge_sections bfd_generic_merge_sections
103#define bfd_plugin_bfd_is_group_section bfd_generic_is_group_section
cb7f4b29 104#define bfd_plugin_bfd_group_name bfd_generic_group_name
07d6d2b8
AM
105#define bfd_plugin_bfd_discard_group bfd_generic_discard_group
106#define bfd_plugin_section_already_linked _bfd_generic_section_already_linked
107#define bfd_plugin_bfd_define_common_symbol bfd_generic_define_common_symbol
34a87bb0 108#define bfd_plugin_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
07d6d2b8 109#define bfd_plugin_bfd_define_start_stop bfd_generic_define_start_stop
69a630b5 110#define bfd_plugin_bfd_copy_link_hash_symbol_type _bfd_generic_copy_link_hash_symbol_type
07d6d2b8 111#define bfd_plugin_bfd_link_check_relocs _bfd_generic_link_check_relocs
ce3c775b
NC
112
113static enum ld_plugin_status
114message (int level ATTRIBUTE_UNUSED,
115 const char * format, ...)
116{
117 va_list args;
118 va_start (args, format);
119 printf ("bfd plugin: ");
120 vprintf (format, args);
d9b21463 121 putchar ('\n');
ce3c775b
NC
122 va_end (args);
123 return LDPS_OK;
124}
125
0aa99dcd
L
126struct plugin_list_entry
127{
128 /* These must be initialized for each IR object with LTO wrapper. */
129 void *handle;
130 ld_plugin_claim_file_handler claim_file;
131 ld_plugin_all_symbols_read_handler all_symbols_read;
132 ld_plugin_all_symbols_read_handler cleanup_handler;
133 char *resolution_file;
134 char *resolution_option;
135 bfd *real_bfd;
136 long real_nsyms;
137 asymbol **real_syms;
138 int lto_nsyms;
139 const struct ld_plugin_symbol *lto_syms;
140
141 struct plugin_list_entry *next;
142
143 /* These can be reused for all IR objects. */
144 const char *plugin_name;
145 char *gcc;
146 char *lto_wrapper;
147 char *gcc_env;
148 bfd_boolean initialized;
149};
150
151/* Use GCC LTO wrapper to covert LTO IR object to the real object. */
152
153static bfd_boolean
154get_lto_wrapper (struct plugin_list_entry *plugin)
155{
156 struct stat st;
157 const char *real_name;
158 const char *base_name;
159 size_t length;
160 const char *target_start = NULL;
161 const char *target_end = NULL;
162 size_t target_length = 0;
163 char *gcc_name;
164 char *wrapper_name;
165 char *p;
166 char dir_seperator = '\0';
167 char *resolution_file;
168
169 if (plugin->initialized)
170 {
171 if (plugin->lto_wrapper)
172 {
173 resolution_file = make_temp_file (".res");
174 if (resolution_file)
175 {
176 plugin->resolution_file = resolution_file;
177 plugin->resolution_option = concat ("-fresolution=",
178 resolution_file, NULL);
179 return TRUE;
180 }
181 else
182 {
183 /* Something is wrong. Give up. */
184 free (plugin->gcc);
185 free (plugin->lto_wrapper);
186 free (plugin->gcc_env);
187 plugin->gcc = NULL;
188 plugin->gcc_env = NULL;
189 plugin->lto_wrapper = NULL;
190 }
191 }
192
193 return FALSE;
194 }
195
196 plugin->initialized = TRUE;
197
198 /* Check for PREFIX/libexec/gcc/TARGET/VERSION/liblto_plugin.so. */
199 real_name = lrealpath (plugin->plugin_name);
200 base_name = lbasename (real_name);
201
202 /* The directory length in plugin pathname. */
203 length = base_name - real_name;
204
205 /* Skip if there is no PREFIX. */
206 if (!length)
207 return FALSE;
208
209 p = (char *) real_name + length - 1;
210 if (IS_DIR_SEPARATOR (*p))
211 {
212 int level = 0;
213 for (; p != real_name; p--)
214 if (IS_DIR_SEPARATOR (*p))
215 {
216 level++;
217 if (level == 2)
218 target_end = p;
219 else if (level == 3)
220 {
221 target_start = p + 1;
222 target_length = target_end - target_start;
223 }
224 else if (level == 5)
225 {
226 dir_seperator = *p;
227 break;
228 }
229 }
230 }
231
232 /* Skip if there is no TARGET nor PREFIX. */
233 if (!target_length || !dir_seperator)
234 return FALSE;
235
236#ifdef HAVE_EXECUTABLE_SUFFIX
237# define GCC_EXECUTABLE "gcc" EXECUTABLE_SUFFIX
238# define LTO_WRAPPER_EXECUTABLE "lto-wrapper" EXECUTABLE_SUFFIX
239#else
240# define GCC_EXECUTABLE "gcc"
241# define LTO_WRAPPER_EXECUTABLE "lto-wrapper"
242#endif
243 gcc_name = bfd_malloc (length + target_length
244 + sizeof (GCC_EXECUTABLE));
245 if (gcc_name == NULL)
246 return FALSE;
247 memcpy (gcc_name, real_name, length);
248
249 /* Get PREFIX/bin/. */
250 p += gcc_name - real_name;
251 memcpy (p + 1, "bin", 3);
252 p[4] = dir_seperator;
253
254 /* Try PREFIX/bin/TARGET-gcc first. */
255 memcpy (p + 5, target_start, target_length);
256 p[5 + target_length] = '-';
257 memcpy (p + 5 + target_length + 1, GCC_EXECUTABLE,
258 sizeof (GCC_EXECUTABLE));
259 if (stat (gcc_name, &st) != 0 || !S_ISREG (st.st_mode))
260 {
261 /* Then try PREFIX/bin/gcc. */
262 memcpy (p + 5, GCC_EXECUTABLE, sizeof (GCC_EXECUTABLE));
263 if (stat (gcc_name, &st) != 0 || !S_ISREG (st.st_mode))
264 {
265 free (gcc_name);
266 return FALSE;
267 }
268 }
269
270 /* lto-wrapper should be in the same directory with LTO plugin. */
271 wrapper_name = bfd_malloc (length + sizeof (LTO_WRAPPER_EXECUTABLE));
272 if (wrapper_name == NULL)
273 {
274 free (gcc_name);
275 return FALSE;
276 }
277 memcpy (wrapper_name, real_name, length);
278 memcpy (wrapper_name + length, LTO_WRAPPER_EXECUTABLE,
279 sizeof (LTO_WRAPPER_EXECUTABLE));
280 if (stat (wrapper_name, &st) == 0 && S_ISREG (st.st_mode))
281 {
282 resolution_file = make_temp_file (".res");
283 if (resolution_file)
284 {
285 plugin->gcc = gcc_name;
286 plugin->lto_wrapper = wrapper_name;
287 plugin->gcc_env = concat ("COLLECT_GCC=", gcc_name, NULL);
288 plugin->resolution_file = resolution_file;
289 plugin->resolution_option = concat ("-fresolution=",
290 resolution_file, NULL);
291 return TRUE;
292 }
293 }
294
295 free (gcc_name);
296 free (wrapper_name);
297 return FALSE;
298}
299
300/* Set environment variables for GCC LTO wrapper to covert LTO IR
301 object to the real object. */
302
303static int
304setup_lto_wrapper_env (struct plugin_list_entry *plugin)
305{
306 return (putenv (plugin->gcc_env)
307 || putenv ("COLLECT_GCC_OPTIONS="));
308}
309
310static struct plugin_list_entry *plugin_list = NULL;
311static struct plugin_list_entry *current_plugin = NULL;
312
ce3c775b 313/* Register a claim-file handler. */
ce3c775b
NC
314
315static enum ld_plugin_status
316register_claim_file (ld_plugin_claim_file_handler handler)
317{
0aa99dcd
L
318 current_plugin->claim_file = handler;
319 return LDPS_OK;
320}
321
322/* Register an all-symbols-read handler. */
323
324static enum ld_plugin_status
325register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
326{
327 current_plugin->all_symbols_read = handler;
328 return LDPS_OK;
329}
330
331/* Register a cleanup handler. */
332
333static enum ld_plugin_status
334register_cleanup (ld_plugin_all_symbols_read_handler handler)
335{
336 current_plugin->cleanup_handler = handler;
337 return LDPS_OK;
338}
339
340/* Get the symbol resolution info for a plugin-claimed input file. */
341
342static enum ld_plugin_status
343get_symbols (const void *handle ATTRIBUTE_UNUSED, int nsyms,
344 struct ld_plugin_symbol *syms)
345{
346 if (syms)
347 {
348 int n;
349 for (n = 0; n < nsyms; n++)
350 {
351 switch (syms[n].def)
352 {
353 default:
354 BFD_ASSERT (0);
355 break;
356 case LDPK_UNDEF:
357 case LDPK_WEAKUNDEF:
358 syms[n].resolution = LDPR_UNDEF;
359 break;
360 case LDPK_DEF:
361 case LDPK_WEAKDEF:
362 case LDPK_COMMON:
363 /* Tell plugin that LTO symbol has references from regular
364 object code. */
365 syms[n].resolution = LDPR_PREVAILING_DEF;
366 break;
367 }
368 }
369 }
370
371 return LDPS_OK;
372}
373
374/* Add a new (real) input file generated by a plugin. */
375
376static enum ld_plugin_status
377add_input_file (const char *pathname)
378{
379 /* Get symbols from the real LTO object. */
380 char **matching;
381 long real_symsize;
382 long real_nsyms;
383 asymbol **real_syms;
384 int lto_nsyms;
385 bfd_boolean lto_symbol_found = FALSE;
386 const struct ld_plugin_symbol *lto_syms;
387 bfd *rbfd;
388 int i, j;
389
390 rbfd = bfd_openr (pathname, NULL);
391 if (!bfd_check_format_matches (rbfd, bfd_object, &matching))
392 BFD_ASSERT (0);
393
394 real_symsize = bfd_get_symtab_upper_bound (rbfd);
395 if (real_symsize < 0)
396 BFD_ASSERT (0);
397
398 real_syms = (asymbol **) bfd_malloc (real_symsize);
399 if (real_syms)
400 {
401 real_nsyms = bfd_canonicalize_symtab (rbfd, real_syms);
402 if (real_nsyms < 0)
403 BFD_ASSERT (0);
404
405 /* NB: LTO plugin may generate more than one real object from one
406 LTO IR object. We use the one which contains LTO symbols. */
407 lto_syms = current_plugin->lto_syms;
408 lto_nsyms = current_plugin->lto_nsyms;
409 for (i = 0; i < lto_nsyms; i++)
410 for (j = 0; j < real_nsyms; j++)
411 if (real_syms[j]->name
412 && strcmp (lto_syms[i].name, real_syms[j]->name) == 0)
413 {
414 lto_symbol_found = TRUE;
415 break;
416 }
417 }
418
419 if (lto_symbol_found)
420 {
421 current_plugin->real_nsyms = real_nsyms;
422 current_plugin->real_syms = real_syms;
423 /* NB: We can't close RBFD which own the real symbol info. */
424 current_plugin->real_bfd = rbfd;
425 }
426 else
427 {
428 bfd_close (rbfd);
429 free (real_syms);
430 }
431
ce3c775b
NC
432 return LDPS_OK;
433}
434
435static enum ld_plugin_status
436add_symbols (void * handle,
437 int nsyms,
438 const struct ld_plugin_symbol * syms)
439{
440 bfd *abfd = handle;
441 struct plugin_data_struct *plugin_data =
5bb3703f 442 bfd_alloc (abfd, sizeof (plugin_data_struct));
ce3c775b 443
0aa99dcd
L
444 if (plugin_data)
445 {
446 struct ld_plugin_symbol *sym_info;
447 char *strtab;
448 size_t sym_info_size, name_length;
449 int i;
450
1d07a805
L
451 memset (plugin_data, 0, sizeof (*plugin_data));
452
0aa99dcd
L
453 abfd->tdata.plugin_data = plugin_data;
454
455 /* NB: LTO symbols are owned by LTO plugin. Create a copy so
456 that we can use it in bfd_plugin_canonicalize_symtab. */
457 sym_info_size = nsyms * sizeof (*syms);
458
459 /* Allocate a string table */
460 for (i = 0; i < nsyms; i++)
461 sym_info_size += strlen (syms[i].name) + 1;
462
463 sym_info = bfd_alloc (abfd, sym_info_size);
464 if (sym_info)
465 {
466 /* Copy symbol table. */
467 memcpy (sym_info, syms, nsyms * sizeof (*syms));
468
469 /* Copy symbol names in symbol table. */
470 strtab = (char *) (sym_info + nsyms);
471 for (i = 0; i < nsyms; i++)
472 {
473 name_length = strlen (syms[i].name);
474 memcpy (strtab, syms[i].name, name_length + 1);
475 sym_info[i].name = strtab;
476 strtab += name_length + 1;
477 }
478
479 plugin_data->nsyms = nsyms;
480 plugin_data->syms = sym_info;
481
482 current_plugin->lto_nsyms = nsyms;
483 current_plugin->lto_syms = sym_info;
484 }
485 }
ce3c775b
NC
486
487 if (nsyms != 0)
488 abfd->flags |= HAS_SYMS;
489
ce3c775b
NC
490 return LDPS_OK;
491}
492
fc579192
NC
493static const char *plugin_program_name;
494
495void
496bfd_plugin_set_program_name (const char *program_name)
497{
498 plugin_program_name = program_name;
499}
ce3c775b 500
7d0b9ebc
AM
501int
502bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
ce3c775b 503{
e44f5bef
MT
504 bfd *iobfd;
505
7d0b9ebc 506 iobfd = ibfd;
27b07675
AM
507 while (iobfd->my_archive
508 && !bfd_is_thin_archive (iobfd->my_archive))
509 iobfd = iobfd->my_archive;
7d0b9ebc 510 file->name = iobfd->filename;
e44f5bef
MT
511
512 if (!iobfd->iostream && !bfd_open_file (iobfd))
513 return 0;
514
27b07675
AM
515 /* The plugin API expects that the file descriptor won't be closed
516 and reused as done by the bfd file cache. So open it again.
517 dup isn't good enough. plugin IO uses lseek/read while BFD uses
518 fseek/fread. It isn't wise to mix the unistd and stdio calls on
519 the same underlying file descriptor. */
520 file->fd = open (file->name, O_RDONLY | O_BINARY);
521 if (file->fd < 0)
522 return 0;
e44f5bef 523
7d0b9ebc 524 if (iobfd == ibfd)
e44f5bef
MT
525 {
526 struct stat stat_buf;
103da91b 527
7d0b9ebc 528 if (fstat (file->fd, &stat_buf))
103da91b
NC
529 {
530 close(file->fd);
531 return 0;
532 }
533
7d0b9ebc
AM
534 file->offset = 0;
535 file->filesize = stat_buf.st_size;
536 }
537 else
538 {
539 file->offset = ibfd->origin;
540 file->filesize = arelt_size (ibfd);
e44f5bef 541 }
7d0b9ebc
AM
542 return 1;
543}
544
545static int
546try_claim (bfd *abfd)
547{
548 int claimed = 0;
549 struct ld_plugin_input_file file;
e44f5bef 550
27b07675 551 file.handle = abfd;
22fe7df8
L
552 if (bfd_plugin_open_input (abfd, &file)
553 && current_plugin->claim_file)
0aa99dcd
L
554 {
555 current_plugin->claim_file (&file, &claimed);
556 if (claimed)
557 {
558 if (current_plugin->all_symbols_read)
559 {
560 struct plugin_data_struct *plugin_data
561 = abfd->tdata.plugin_data;
562 if (plugin_data)
563 {
564 /* Get real symbols from LTO wrapper. */
565 current_plugin->all_symbols_read ();
566
567 /* Copy real symbols to plugin_data. */
568 plugin_data->real_bfd = current_plugin->real_bfd;
569 plugin_data->real_nsyms = current_plugin->real_nsyms;
570 plugin_data->real_syms = current_plugin->real_syms;
571
572 /* Clean up LTO plugin. */
573 if (current_plugin->cleanup_handler)
574 current_plugin->cleanup_handler ();
575 }
576 }
577 }
578
22fe7df8 579 close (file.fd);
0aa99dcd 580 }
22fe7df8
L
581
582 if (current_plugin->lto_wrapper)
583 {
584 /* Clean up for LTO wrapper. NB: Resolution file and option
585 have been created regardless if an IR object is claimed or
586 not. */
587 unlink (current_plugin->resolution_file);
588 free (current_plugin->resolution_option);
589 }
590
7d0b9ebc 591 return claimed;
e44f5bef
MT
592}
593
594static int
5ae0078c 595try_load_plugin (const char *pname, bfd *abfd, int *has_plugin_p)
e44f5bef 596{
103da91b 597 void *plugin_handle = NULL;
0aa99dcd 598 struct ld_plugin_tv tv[12];
ce3c775b
NC
599 int i;
600 ld_plugin_onload onload;
601 enum ld_plugin_status status;
b0ceb98a 602 struct plugin_list_entry *plugin_list_iter;
103da91b 603
5ae0078c
L
604 *has_plugin_p = 0;
605
22fe7df8
L
606 /* NB: Each object is independent. Reuse the previous plugin from
607 the last run will lead to wrong result. */
608 if (current_plugin)
0aa99dcd 609 {
22fe7df8
L
610 if (current_plugin->handle)
611 dlclose (current_plugin->handle);
0aa99dcd
L
612 memset (current_plugin, 0,
613 offsetof (struct plugin_list_entry, next));
22fe7df8 614 current_plugin = NULL;
0aa99dcd
L
615 }
616
ce3c775b
NC
617 plugin_handle = dlopen (pname, RTLD_NOW);
618 if (!plugin_handle)
619 {
4eca0228 620 _bfd_error_handler ("%s\n", dlerror ());
ce3c775b
NC
621 return 0;
622 }
623
b0ceb98a
Z
624 for (plugin_list_iter = plugin_list;
625 plugin_list_iter;
626 plugin_list_iter = plugin_list_iter->next)
22fe7df8
L
627 if (strcmp (plugin_list_iter->plugin_name, pname) == 0)
628 break;
629
630 if (plugin_list_iter == NULL)
b0ceb98a 631 {
22fe7df8
L
632 size_t length_plugin_name = strlen (pname) + 1;
633 char *plugin_name = bfd_malloc (length_plugin_name);
634 if (plugin_name == NULL)
635 return 0;
636 plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
637 if (plugin_list_iter == NULL)
4b24dd1a 638 {
22fe7df8
L
639 free (plugin_name);
640 return 0;
4b24dd1a 641 }
22fe7df8
L
642 /* Make a copy of PNAME since PNAME from load_plugin () will be
643 freed. */
644 memcpy (plugin_name, pname, length_plugin_name);
645 memset (plugin_list_iter, 0, sizeof (*plugin_list_iter));
646 plugin_list_iter->plugin_name = plugin_name;
647 plugin_list_iter->next = plugin_list;
648 plugin_list = plugin_list_iter;
b0ceb98a
Z
649 }
650
0aa99dcd
L
651 plugin_list_iter->handle = plugin_handle;
652
ce3c775b
NC
653 onload = dlsym (plugin_handle, "onload");
654 if (!onload)
b0ceb98a 655 return 0;
ce3c775b
NC
656
657 i = 0;
658 tv[i].tv_tag = LDPT_MESSAGE;
659 tv[i].tv_u.tv_message = message;
660
661 ++i;
662 tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
663 tv[i].tv_u.tv_register_claim_file = register_claim_file;
664
665 ++i;
666 tv[i].tv_tag = LDPT_ADD_SYMBOLS;
667 tv[i].tv_u.tv_add_symbols = add_symbols;
668
0aa99dcd
L
669 if (get_lto_wrapper (plugin_list_iter))
670 {
671 ++i;
672 tv[i].tv_tag = LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK;
673 tv[i].tv_u.tv_register_all_symbols_read = register_all_symbols_read;
674
675 ++i;
676 tv[i].tv_tag = LDPT_REGISTER_CLEANUP_HOOK;
677 tv[i].tv_u.tv_register_cleanup = register_cleanup;
678
679 ++i;
680 tv[i].tv_tag = LDPT_GET_SYMBOLS;
681 tv[i].tv_u.tv_get_symbols = get_symbols;
682
683 ++i;
684 tv[i].tv_tag = LDPT_GET_SYMBOLS_V2;
685 tv[i].tv_u.tv_get_symbols = get_symbols;
686
687 ++i;
688 tv[i].tv_tag = LDPT_OPTION;
689 tv[i].tv_u.tv_string = plugin_list_iter->lto_wrapper;
690
691 ++i;
692 tv[i].tv_tag = LDPT_OPTION;
693 tv[i].tv_u.tv_string = plugin_list_iter->resolution_option;
694
695 ++i;
696 tv[i].tv_tag = LDPT_LINKER_OUTPUT;
697 tv[i].tv_u.tv_val = LDPO_EXEC;
698
699 ++i;
700 tv[i].tv_tag = LDPT_ADD_INPUT_FILE;
701 tv[i].tv_u.tv_add_input_file = add_input_file;
702 }
703
ce3c775b
NC
704 ++i;
705 tv[i].tv_tag = LDPT_NULL;
706 tv[i].tv_u.tv_val = 0;
707
0aa99dcd
L
708 current_plugin = plugin_list_iter;
709
710 /* LTO plugin will call handler hooks to set up plugin handlers. */
ce3c775b
NC
711 status = (*onload)(tv);
712
713 if (status != LDPS_OK)
b0ceb98a
Z
714 return 0;
715
0aa99dcd
L
716 if (current_plugin->lto_wrapper
717 && setup_lto_wrapper_env (current_plugin))
718 return 0;
ce3c775b 719
5ae0078c
L
720 *has_plugin_p = 1;
721
722 abfd->plugin_format = bfd_plugin_no;
723
0aa99dcd 724 if (!current_plugin->claim_file)
b0ceb98a 725 return 0;
ce3c775b 726
e44f5bef 727 if (!try_claim (abfd))
b0ceb98a 728 return 0;
e44f5bef 729
5ae0078c 730 abfd->plugin_format = bfd_plugin_yes;
ce3c775b 731 return 1;
ce3c775b
NC
732}
733
5ae0078c
L
734/* There may be plugin libraries in lib/bfd-plugins. */
735
736static int has_plugin = -1;
737
738static const bfd_target *(*ld_plugin_object_p) (bfd *);
739
ce3c775b
NC
740static const char *plugin_name;
741
742void
743bfd_plugin_set_plugin (const char *p)
744{
745 plugin_name = p;
5ae0078c
L
746 has_plugin = p != NULL;
747}
748
749/* Return TRUE if a plugin library is used. */
750
751bfd_boolean
752bfd_plugin_specified_p (void)
753{
754 return has_plugin > 0;
755}
756
7dc3990e
L
757/* Return TRUE if ABFD can be claimed by linker LTO plugin. */
758
759bfd_boolean
760bfd_link_plugin_object_p (bfd *abfd)
761{
762 if (ld_plugin_object_p)
763 return ld_plugin_object_p (abfd) != NULL;
764 return FALSE;
765}
766
5ae0078c
L
767extern const bfd_target plugin_vec;
768
769/* Return TRUE if TARGET is a pointer to plugin_vec. */
770
771bfd_boolean
772bfd_plugin_target_p (const bfd_target *target)
773{
774 return target == &plugin_vec;
775}
776
777/* Register OBJECT_P to be used by bfd_plugin_object_p. */
778
779void
780register_ld_plugin_object_p (const bfd_target *(*object_p) (bfd *))
781{
782 ld_plugin_object_p = object_p;
ce3c775b
NC
783}
784
785static int
e44f5bef 786load_plugin (bfd *abfd)
ce3c775b 787{
41f37a6f
AM
788 /* The intent was to search ${libdir}/bfd-plugins for plugins, but
789 unfortunately the original implementation wasn't precisely that
790 when configuring binutils using --libdir. Search in the proper
791 path first, then the old one for backwards compatibility. */
792 static const char *path[]
793 = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
794 struct stat last_st;
ce3c775b 795 int found = 0;
41f37a6f 796 unsigned int i;
ce3c775b 797
5ae0078c
L
798 if (!has_plugin)
799 return found;
800
ce3c775b 801 if (plugin_name)
5ae0078c 802 return try_load_plugin (plugin_name, abfd, &has_plugin);
ce3c775b 803
fc579192 804 if (plugin_program_name == NULL)
5ae0078c 805 return found;
ce3c775b 806
41f37a6f
AM
807 /* Try not to search the same dir twice, by looking at st_dev and
808 st_ino for the dir. If we are on a file system that always sets
809 st_ino to zero or the actual st_ino is zero we might waste some
810 time, but that doesn't matter too much. */
811 last_st.st_dev = 0;
812 last_st.st_ino = 0;
813 for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
ce3c775b 814 {
41f37a6f
AM
815 char *plugin_dir = make_relative_prefix (plugin_program_name,
816 BINDIR,
817 path[i]);
818 if (plugin_dir)
819 {
820 struct stat st;
821 DIR *d;
822
823 if (stat (plugin_dir, &st) == 0
824 && S_ISDIR (st.st_mode)
825 && !(last_st.st_dev == st.st_dev
826 && last_st.st_ino == st.st_ino
827 && st.st_ino != 0)
828 && (d = opendir (plugin_dir)) != NULL)
829 {
830 struct dirent *ent;
831
832 last_st.st_dev = st.st_dev;
833 last_st.st_ino = st.st_ino;
834 while ((ent = readdir (d)) != NULL)
835 {
836 char *full_name;
837
838 full_name = concat (plugin_dir, "/", ent->d_name, NULL);
839 if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
840 {
841 int valid_plugin;
842
843 found = try_load_plugin (full_name, abfd, &valid_plugin);
844 if (has_plugin <= 0)
845 has_plugin = valid_plugin;
846 }
847 free (full_name);
848 if (found)
849 break;
850 }
851 closedir (d);
852 }
853 free (plugin_dir);
854 }
ce3c775b
NC
855 if (found)
856 break;
857 }
858
ce3c775b
NC
859 return found;
860}
861
862
863static const bfd_target *
864bfd_plugin_object_p (bfd *abfd)
865{
5ae0078c
L
866 if (ld_plugin_object_p)
867 return ld_plugin_object_p (abfd);
868
49f30d83 869 if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
ce3c775b
NC
870 return NULL;
871
5ae0078c 872 return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL;
ce3c775b
NC
873}
874
875/* Copy any private info we understand from the input bfd
876 to the output bfd. */
877
878static bfd_boolean
879bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
880 bfd *obfd ATTRIBUTE_UNUSED)
881{
882 BFD_ASSERT (0);
883 return TRUE;
884}
885
886/* Copy any private info we understand from the input section
887 to the output section. */
888
889static bfd_boolean
890bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
891 asection *isection ATTRIBUTE_UNUSED,
892 bfd *obfd ATTRIBUTE_UNUSED,
893 asection *osection ATTRIBUTE_UNUSED)
894{
895 BFD_ASSERT (0);
896 return TRUE;
897}
898
899/* Copy any private info we understand from the input symbol
900 to the output symbol. */
901
902static bfd_boolean
903bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
904 asymbol *isymbol ATTRIBUTE_UNUSED,
905 bfd *obfd ATTRIBUTE_UNUSED,
906 asymbol *osymbol ATTRIBUTE_UNUSED)
907{
908 BFD_ASSERT (0);
909 return TRUE;
910}
911
912static bfd_boolean
913bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED)
914{
915 BFD_ASSERT (0);
916 return TRUE;
917}
918
919static char *
920bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
921{
922 BFD_ASSERT (0);
923 return NULL;
924}
925
926static int
927bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
261b8d08
PA
928{
929 BFD_ASSERT (0);
930 return 0;
931}
932
933static int
934bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
ce3c775b
NC
935{
936 BFD_ASSERT (0);
937 return 0;
938}
939
940static long
941bfd_plugin_get_symtab_upper_bound (bfd *abfd)
942{
943 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
944 long nsyms = plugin_data->nsyms;
945
946 BFD_ASSERT (nsyms >= 0);
947
948 return ((nsyms + 1) * sizeof (asymbol *));
949}
950
951static flagword
952convert_flags (const struct ld_plugin_symbol *sym)
953{
954 switch (sym->def)
68ffbac6 955 {
ce3c775b
NC
956 case LDPK_DEF:
957 case LDPK_COMMON:
958 case LDPK_UNDEF:
959 return BSF_GLOBAL;
960
961 case LDPK_WEAKUNDEF:
962 case LDPK_WEAKDEF:
963 return BSF_GLOBAL | BSF_WEAK;
964
965 default:
966 BFD_ASSERT (0);
967 return 0;
968 }
969}
970
971static long
972bfd_plugin_canonicalize_symtab (bfd *abfd,
973 asymbol **alocation)
974{
975 struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
976 long nsyms = plugin_data->nsyms;
977 const struct ld_plugin_symbol *syms = plugin_data->syms;
a288c270
AM
978 static asection fake_section
979 = BFD_FAKE_SECTION (fake_section, NULL, "plug", 0,
980 SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
981 static asection fake_common_section
982 = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
0aa99dcd
L
983 int i, j;
984 long real_nsyms;
985 asymbol **real_syms;
986
987 real_syms = plugin_data->real_syms;
988 if (real_syms)
989 real_nsyms = plugin_data->real_nsyms;
990 else
991 real_nsyms = 0;
ce3c775b 992
ce3c775b
NC
993 for (i = 0; i < nsyms; i++)
994 {
68ffbac6 995 asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
ce3c775b
NC
996
997 BFD_ASSERT (s);
998 alocation[i] = s;
999
1000 s->the_bfd = abfd;
1001 s->name = syms[i].name;
1002 s->value = 0;
1003 s->flags = convert_flags (&syms[i]);
1004 switch (syms[i].def)
1005 {
1006 case LDPK_COMMON:
1007 s->section = &fake_common_section;
1008 break;
1009 case LDPK_UNDEF:
1010 case LDPK_WEAKUNDEF:
1011 s->section = bfd_und_section_ptr;
1012 break;
1013 case LDPK_DEF:
1014 case LDPK_WEAKDEF:
1015 s->section = &fake_section;
0aa99dcd
L
1016 if (real_nsyms)
1017 /* Use real LTO symbols if possible. */
1018 for (j = 0; j < real_nsyms; j++)
1019 if (real_syms[j]->name
1020 && strcmp (syms[i].name, real_syms[j]->name) == 0)
1021 {
1022 s->section = real_syms[j]->section;
1023 break;
1024 }
ce3c775b
NC
1025 break;
1026 default:
1027 BFD_ASSERT (0);
1028 }
1029
1030 s->udata.p = (void *) &syms[i];
1031 }
1032
1033 return nsyms;
1034}
1035
1036static void
1037bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1038 PTR afile ATTRIBUTE_UNUSED,
1039 asymbol *symbol ATTRIBUTE_UNUSED,
1040 bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1041{
1042 BFD_ASSERT (0);
1043}
1044
1045static void
1046bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1047 asymbol *symbol,
1048 symbol_info *ret)
1049{
1050 bfd_symbol_info (symbol, ret);
1051}
1052
1053/* Make an empty symbol. */
1054
1055static asymbol *
1056bfd_plugin_make_empty_symbol (bfd *abfd)
1057{
d3ce72d0
NC
1058 asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
1059 if (new_symbol == NULL)
1060 return new_symbol;
1061 new_symbol->the_bfd = abfd;
1062 return new_symbol;
ce3c775b
NC
1063}
1064
1065static int
1066bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
1067 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1068{
1069 BFD_ASSERT (0);
1070 return 0;
1071}
1072
0aa99dcd
L
1073static bfd_boolean
1074bfd_plugin_close_and_cleanup (bfd *abfd)
1075{
1076 struct plugin_data_struct *plugin_data;
1077
1078 if (abfd->format != bfd_archive
1079 && (plugin_data = abfd->tdata.plugin_data))
1080 {
1081 if (plugin_data->real_bfd)
1082 bfd_close (plugin_data->real_bfd);
1083
1084 if (plugin_data->real_syms)
1085 free (plugin_data->real_syms);
1086 }
1087
1088 return _bfd_generic_close_and_cleanup (abfd);
1089}
1090
ce3c775b
NC
1091const bfd_target plugin_vec =
1092{
1093 "plugin", /* Name. */
1094 bfd_target_unknown_flavour,
1095 BFD_ENDIAN_LITTLE, /* Target byte order. */
1096 BFD_ENDIAN_LITTLE, /* Target headers byte order. */
1097 (HAS_RELOC | EXEC_P | /* Object flags. */
1098 HAS_LINENO | HAS_DEBUG |
1099 HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1100 (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1101 | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags. */
1102 0, /* symbol_leading_char. */
1103 '/', /* ar_pad_char. */
1104 15, /* ar_max_namelen. */
64bfc258 1105 255, /* match priority. */
ce3c775b
NC
1106
1107 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1108 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1109 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
1110 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1111 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1112 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
1113
1114 { /* bfd_check_format. */
1115 _bfd_dummy_target,
1116 bfd_plugin_object_p,
1117 bfd_generic_archive_p,
1118 _bfd_dummy_target
1119 },
1120 { /* bfd_set_format. */
d00dd7dc
AM
1121 _bfd_bool_bfd_false_error,
1122 _bfd_bool_bfd_false_error,
ce3c775b 1123 _bfd_generic_mkarchive,
d00dd7dc 1124 _bfd_bool_bfd_false_error,
ce3c775b
NC
1125 },
1126 { /* bfd_write_contents. */
d00dd7dc
AM
1127 _bfd_bool_bfd_false_error,
1128 _bfd_bool_bfd_false_error,
ce3c775b 1129 _bfd_write_archive_contents,
d00dd7dc 1130 _bfd_bool_bfd_false_error,
ce3c775b
NC
1131 },
1132
1133 BFD_JUMP_TABLE_GENERIC (bfd_plugin),
1134 BFD_JUMP_TABLE_COPY (bfd_plugin),
1135 BFD_JUMP_TABLE_CORE (bfd_plugin),
e6cc316a
L
1136#ifdef USE_64_BIT_ARCHIVE
1137 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
1138#else
ce3c775b 1139 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
e6cc316a 1140#endif
ce3c775b
NC
1141 BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
1142 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1143 BFD_JUMP_TABLE_WRITE (bfd_plugin),
1144 BFD_JUMP_TABLE_LINK (bfd_plugin),
1145 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1146
1147 NULL,
1148
07d6d2b8 1149 NULL /* backend_data. */
ce3c775b 1150};
98950613 1151#endif /* BFD_SUPPORTS_PLUGIN */
This page took 0.713678 seconds and 4 git commands to generate.