bfd/plugin.c

   1 /* Plugin support for BFD.
   2    Copyright (C) 2009-2025 Free Software Foundation, Inc.
   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
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23
  24 #if BFD_SUPPORTS_PLUGINS
  25
  26 #include <assert.h>
  27 #ifdef HAVE_DLFCN_H
  28 #include <dlfcn.h>
  29 #elif defined (HAVE_WINDOWS_H)
  30 #include <windows.h>
  31 #else
  32 #error Unknown how to handle dynamic-load-libraries.
  33 #endif
  34 #include <stdarg.h>
  35 #include "plugin-api.h"
  36 #include "plugin.h"
  37 #include "libbfd.h"
  38 #include "libiberty.h"
  39 #include <dirent.h>
  40
  41 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
  42
  43 #define RTLD_NOW 0      /* Dummy value.  */
  44
  45 static void *
  46 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
  47 {
  48   return LoadLibrary (file);
  49 }
  50
  51 static void *
  52 dlsym (void *handle, const char *name)
  53 {
  54   return GetProcAddress (handle, name);
  55 }
  56
  57 static int ATTRIBUTE_UNUSED
  58 dlclose (void *handle)
  59 {
  60   FreeLibrary (handle);
  61   return 0;
  62 }
  63
  64 static const char *
  65 dlerror (void)
  66 {
  67   return "Unable to load DLL.";
  68 }
  69
  70 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
  71
  72 #define bfd_plugin_close_and_cleanup                  _bfd_generic_close_and_cleanup
  73 #define bfd_plugin_bfd_free_cached_info               _bfd_generic_bfd_free_cached_info
  74 #define bfd_plugin_new_section_hook                   _bfd_generic_new_section_hook
  75 #define bfd_plugin_get_section_contents               _bfd_generic_get_section_contents
  76 #define bfd_plugin_init_private_section_data          _bfd_generic_init_private_section_data
  77 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  78 #define bfd_plugin_bfd_merge_private_bfd_data         _bfd_generic_bfd_merge_private_bfd_data
  79 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  80 #define bfd_plugin_bfd_set_private_flags              _bfd_generic_bfd_set_private_flags
  81 #define bfd_plugin_core_file_matches_executable_p     generic_core_file_matches_executable_p
  82 #define bfd_plugin_bfd_is_local_label_name            _bfd_nosymbols_bfd_is_local_label_name
  83 #define bfd_plugin_bfd_is_target_special_symbol       _bfd_bool_bfd_asymbol_false
  84 #define bfd_plugin_get_lineno                         _bfd_nosymbols_get_lineno
  85 #define bfd_plugin_find_nearest_line                  _bfd_nosymbols_find_nearest_line
  86 #define bfd_plugin_find_nearest_line_with_alt         _bfd_nosymbols_find_nearest_line_with_alt
  87 #define bfd_plugin_find_line                          _bfd_nosymbols_find_line
  88 #define bfd_plugin_find_inliner_info                  _bfd_nosymbols_find_inliner_info
  89 #define bfd_plugin_get_symbol_version_string          _bfd_nosymbols_get_symbol_version_string
  90 #define bfd_plugin_bfd_make_debug_symbol              _bfd_nosymbols_bfd_make_debug_symbol
  91 #define bfd_plugin_read_minisymbols                   _bfd_generic_read_minisymbols
  92 #define bfd_plugin_minisymbol_to_symbol               _bfd_generic_minisymbol_to_symbol
  93 #define bfd_plugin_set_arch_mach                      bfd_default_set_arch_mach
  94 #define bfd_plugin_set_section_contents               _bfd_generic_set_section_contents
  95 #define bfd_plugin_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
  96 #define bfd_plugin_bfd_relax_section                  bfd_generic_relax_section
  97 #define bfd_plugin_bfd_link_hash_table_create         _bfd_generic_link_hash_table_create
  98 #define bfd_plugin_bfd_link_add_symbols               _bfd_generic_link_add_symbols
  99 #define bfd_plugin_bfd_link_just_syms                 _bfd_generic_link_just_syms
 100 #define bfd_plugin_bfd_final_link                     _bfd_generic_final_link
 101 #define bfd_plugin_bfd_link_split_section             _bfd_generic_link_split_section
 102 #define bfd_plugin_bfd_gc_sections                    bfd_generic_gc_sections
 103 #define bfd_plugin_bfd_lookup_section_flags           bfd_generic_lookup_section_flags
 104 #define bfd_plugin_bfd_merge_sections                 bfd_generic_merge_sections
 105 #define bfd_plugin_bfd_is_group_section               bfd_generic_is_group_section
 106 #define bfd_plugin_bfd_group_name                     bfd_generic_group_name
 107 #define bfd_plugin_bfd_discard_group                  bfd_generic_discard_group
 108 #define bfd_plugin_section_already_linked             _bfd_generic_section_already_linked
 109 #define bfd_plugin_bfd_define_common_symbol           bfd_generic_define_common_symbol
 110 #define bfd_plugin_bfd_link_hide_symbol               _bfd_generic_link_hide_symbol
 111 #define bfd_plugin_bfd_define_start_stop              bfd_generic_define_start_stop
 112 #define bfd_plugin_bfd_copy_link_hash_symbol_type     _bfd_generic_copy_link_hash_symbol_type
 113 #define bfd_plugin_bfd_link_check_relocs              _bfd_generic_link_check_relocs
 114
 115 static enum ld_plugin_status
 116 message (int level ATTRIBUTE_UNUSED,
 117          const char * format, ...)
 118 {
 119   va_list args;
 120   va_start (args, format);
 121   printf ("bfd plugin: ");
 122   vprintf (format, args);
 123   putchar ('\n');
 124   va_end (args);
 125   return LDPS_OK;
 126 }
 127
 128 struct plugin_list_entry
 129 {
 130   /* These must be initialized for each IR object with LTO wrapper.  */
 131   ld_plugin_claim_file_handler claim_file;
 132   ld_plugin_claim_file_handler_v2 claim_file_v2;
 133   ld_plugin_all_symbols_read_handler all_symbols_read;
 134   ld_plugin_all_symbols_read_handler cleanup_handler;
 135   bool has_symbol_type;
 136
 137   struct plugin_list_entry *next;
 138
 139   /* These can be reused for all IR objects.  */
 140   const char *plugin_name;
 141 };
 142
 143 static const char *plugin_program_name;
 144
 145 void
 146 bfd_plugin_set_program_name (const char *program_name)
 147 {
 148   plugin_program_name = program_name;
 149 }
 150
 151 static struct plugin_list_entry *plugin_list = NULL;
 152 static struct plugin_list_entry *current_plugin = NULL;
 153
 154 /* Register a claim-file handler. */
 155
 156 static enum ld_plugin_status
 157 register_claim_file (ld_plugin_claim_file_handler handler)
 158 {
 159   current_plugin->claim_file = handler;
 160   return LDPS_OK;
 161 }
 162
 163 static asection bfd_plugin_fake_text_section
 164   = BFD_FAKE_SECTION (bfd_plugin_fake_text_section, NULL, "plug", 0,
 165                       SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 166 static asection bfd_plugin_fake_data_section
 167   = BFD_FAKE_SECTION (bfd_plugin_fake_data_section, NULL, "plug", 0,
 168                       SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS);
 169 static asection bfd_plugin_fake_bss_section
 170   = BFD_FAKE_SECTION (bfd_plugin_fake_bss_section, NULL, "plug", 0,
 171                       SEC_ALLOC);
 172 static asection bfd_plugin_fake_common_section
 173   = BFD_FAKE_SECTION (bfd_plugin_fake_common_section, NULL, NULL,
 174                       0, SEC_IS_COMMON);
 175
 176 /* Get symbols from object only section.  */
 177
 178 static void
 179 bfd_plugin_get_symbols_in_object_only (bfd *abfd)
 180 {
 181   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 182   const char *object_only_file;
 183   bfd *nbfd;
 184   long storage;
 185   long object_only_nsyms, added_nsyms, i;
 186   asymbol **object_only_syms, **added_syms;
 187
 188   plugin_data->object_only_syms = NULL;
 189   plugin_data->object_only_nsyms = 0;
 190
 191   if (abfd->sections == NULL && abfd->my_archive == NULL)
 192     {
 193       nbfd = bfd_openr (abfd->filename, NULL);
 194       if (nbfd == NULL)
 195         {
 196           (*_bfd_error_handler)
 197             (_("%s: failed to open to extract object only section: %s"),
 198              abfd->filename, bfd_errmsg (bfd_get_error ()));
 199           return;
 200         }
 201       else if (!bfd_check_format (nbfd, bfd_object))
 202         {
 203           /* There is no object only section if it isn't a bfd_object
 204              file.  */
 205           bfd_close (nbfd);
 206           return;
 207         }
 208     }
 209   else
 210     {
 211       if (!bfd_check_format (abfd, bfd_object))
 212         {
 213           (*_bfd_error_handler)
 214             (_("%pB: invalid file to extract object only section: %s"),
 215              abfd, bfd_errmsg (bfd_get_error ()));
 216           return;
 217         }
 218       nbfd = abfd;
 219     }
 220
 221   if (nbfd->lto_type == lto_mixed_object
 222       && (nbfd->flags & HAS_SYMS) != 0)
 223     {
 224       object_only_file = bfd_extract_object_only_section (nbfd);
 225       if (object_only_file == NULL)
 226         (*_bfd_error_handler)
 227           (_("%pB: failed to extract object only section: %s"),
 228            abfd, bfd_errmsg (bfd_get_error ()));
 229     }
 230   else
 231     object_only_file = NULL;
 232
 233   /* Close the new bfd we just opened.  */
 234   if (nbfd != abfd)
 235     bfd_close (nbfd);
 236
 237   /* Return if there is no object only section or there is no
 238      symbol in object only section.  */
 239   if (!object_only_file)
 240     return;
 241
 242   /* Open the file containing object only section.  */
 243   nbfd = bfd_openr (object_only_file, NULL);
 244   if (!bfd_check_format (nbfd, bfd_object))
 245     {
 246       (*_bfd_error_handler)
 247         (_("%pB: failed to open object only section: %s"),
 248          abfd, bfd_errmsg (bfd_get_error ()));
 249       goto quit;
 250     }
 251
 252   storage = bfd_get_symtab_upper_bound (nbfd);
 253   if (storage <= 0)
 254     {
 255       if (storage < 0)
 256         (*_bfd_error_handler)
 257           (_("%pB: failed to get symbol table in object only section: %s"),
 258            abfd, bfd_errmsg (bfd_get_error ()));
 259
 260       goto quit;
 261     }
 262
 263   object_only_syms = (asymbol **) bfd_malloc (storage);
 264   object_only_nsyms = bfd_canonicalize_symtab (nbfd, object_only_syms);
 265
 266   /* FIXME: We waste some spaces if not all symbols are copied.  */
 267   added_syms = (asymbol **) bfd_alloc (abfd, storage);
 268   added_nsyms = 0;
 269
 270   /* Copy only global symbols from object only section.  */
 271   for (i = 0; i < object_only_nsyms; i++)
 272     {
 273       asection *sec = object_only_syms[i]->section;
 274       flagword flags = object_only_syms[i]->flags;
 275       asymbol *s;
 276
 277       if (bfd_is_com_section (sec))
 278         sec = &bfd_plugin_fake_common_section;
 279       else if (bfd_is_und_section (sec))
 280         ;
 281       else if ((flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0)
 282         {
 283           if ((sec->flags & SEC_CODE) != 0)
 284             sec = &bfd_plugin_fake_text_section;
 285           else if ((sec->flags & SEC_LOAD) != 0)
 286             sec = &bfd_plugin_fake_data_section;
 287           else
 288             sec = &bfd_plugin_fake_bss_section;
 289         }
 290       else
 291         continue;
 292
 293       s = bfd_alloc (abfd, sizeof (asymbol));
 294       BFD_ASSERT (s);
 295       added_syms[added_nsyms++] = s;
 296
 297       s->section = sec;
 298       s->the_bfd = abfd;
 299       s->name = xstrdup (object_only_syms[i]->name);
 300       s->value = 0;
 301       s->flags = flags;
 302       s->udata.p = NULL;
 303     }
 304
 305   plugin_data->object_only_syms = added_syms;
 306   plugin_data->object_only_nsyms = added_nsyms;
 307
 308   free (object_only_syms);
 309
 310 quit:
 311   /* Close and remove the object only section file.  */
 312   bfd_close (nbfd);
 313   unlink (object_only_file);
 314 }
 315
 316 /* Register a claim-file handler, version 2. */
 317
 318 static enum ld_plugin_status
 319 register_claim_file_v2 (ld_plugin_claim_file_handler_v2 handler)
 320 {
 321   current_plugin->claim_file_v2 = handler;
 322   return LDPS_OK;
 323 }
 324
 325 static enum ld_plugin_status
 326 add_symbols (void * handle,
 327              int nsyms,
 328              const struct ld_plugin_symbol * syms)
 329 {
 330   bfd *abfd = handle;
 331   struct plugin_data_struct *plugin_data =
 332     bfd_alloc (abfd, sizeof (plugin_data_struct));
 333
 334   if (!plugin_data)
 335     return LDPS_ERR;
 336
 337   plugin_data->nsyms = nsyms;
 338   plugin_data->syms = syms;
 339
 340   abfd->tdata.plugin_data = plugin_data;
 341
 342   bfd_plugin_get_symbols_in_object_only (abfd);
 343
 344   if ((nsyms + plugin_data->object_only_nsyms) != 0)
 345     abfd->flags |= HAS_SYMS;
 346
 347   return LDPS_OK;
 348 }
 349
 350 static enum ld_plugin_status
 351 add_symbols_v2 (void *handle, int nsyms,
 352                 const struct ld_plugin_symbol *syms)
 353 {
 354   current_plugin->has_symbol_type = true;
 355   return add_symbols (handle, nsyms, syms);
 356 }
 357
 358 int
 359 bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
 360 {
 361   bfd *iobfd;
 362   int fd;
 363
 364   iobfd = ibfd;
 365   while (iobfd->my_archive
 366          && !bfd_is_thin_archive (iobfd->my_archive))
 367     iobfd = iobfd->my_archive;
 368   file->name = bfd_get_filename (iobfd);
 369
 370   if (!iobfd->iostream && !bfd_open_file (iobfd))
 371     return 0;
 372
 373   /* Reuse the archive plugin file descriptor.  */
 374   if (iobfd != ibfd)
 375     fd = iobfd->archive_plugin_fd;
 376   else
 377     fd = -1;
 378
 379   if (fd < 0)
 380     {
 381       /* The plugin API expects that the file descriptor won't be closed
 382          and reused as done by the bfd file cache.  So open it again.
 383          dup isn't good enough.  plugin IO uses lseek/read while BFD uses
 384          fseek/fread.  It isn't wise to mix the unistd and stdio calls on
 385          the same underlying file descriptor.  */
 386       fd = open (file->name, O_RDONLY | O_BINARY);
 387       if (fd < 0)
 388         {
 389 #ifndef EMFILE
 390           return 0;
 391 #else
 392           if (errno != EMFILE)
 393             return 0;
 394
 395 #ifdef HAVE_GETRLIMIT
 396           struct rlimit lim;
 397
 398           /* Complicated links involving lots of files and/or large
 399              archives can exhaust the number of file descriptors
 400              available to us.  If possible, try to allocate more
 401              descriptors.  */
 402           if (getrlimit (RLIMIT_NOFILE, & lim) == 0
 403               && lim.rlim_cur < lim.rlim_max)
 404             {
 405               lim.rlim_cur = lim.rlim_max;
 406               if (setrlimit (RLIMIT_NOFILE, &lim) == 0)
 407                 fd = open (file->name, O_RDONLY | O_BINARY);
 408             }
 409
 410           if (fd < 0)
 411 #endif
 412             {
 413               _bfd_error_handler (_("plugin framework: out of file descriptors. Try using fewer objects/archives\n"));
 414               return 0;
 415             }
 416 #endif
 417         }
 418     }
 419
 420   if (iobfd == ibfd)
 421     {
 422       struct stat stat_buf;
 423
 424       if (fstat (fd, &stat_buf))
 425         {
 426           close (fd);
 427           return 0;
 428         }
 429
 430       file->offset = 0;
 431       file->filesize = stat_buf.st_size;
 432     }
 433   else
 434     {
 435       /* Cache the archive plugin file descriptor.  */
 436       iobfd->archive_plugin_fd = fd;
 437       iobfd->archive_plugin_fd_open_count++;
 438
 439       file->offset = ibfd->origin;
 440       file->filesize = arelt_size (ibfd);
 441     }
 442
 443   file->fd = fd;
 444   return 1;
 445 }
 446
 447 /* Close the plugin file descriptor FD.  If ABFD isn't NULL, it is an
 448    archive member.   */
 449
 450 void
 451 bfd_plugin_close_file_descriptor (bfd *abfd, int fd)
 452 {
 453   if (abfd == NULL)
 454     close (fd);
 455   else
 456     {
 457       while (abfd->my_archive
 458              && !bfd_is_thin_archive (abfd->my_archive))
 459         abfd = abfd->my_archive;
 460
 461       /* Close the file descriptor if there is no archive plugin file
 462          descriptor.  */
 463       if (abfd->archive_plugin_fd == -1)
 464         {
 465           close (fd);
 466           return;
 467         }
 468
 469       abfd->archive_plugin_fd_open_count--;
 470       /* Dup the archive plugin file descriptor for later use, which
 471          will be closed by _bfd_archive_close_and_cleanup.  */
 472       if (abfd->archive_plugin_fd_open_count == 0)
 473         {
 474           abfd->archive_plugin_fd = dup (fd);
 475           close (fd);
 476         }
 477     }
 478 }
 479
 480 static int
 481 try_claim (bfd *abfd)
 482 {
 483   int claimed = 0;
 484   struct ld_plugin_input_file file;
 485
 486   file.handle = abfd;
 487   if (bfd_plugin_open_input (abfd, &file))
 488     {
 489       bool claim_file_called = false;
 490       if (current_plugin->claim_file_v2)
 491         {
 492           current_plugin->claim_file_v2 (&file, &claimed, false);
 493           claim_file_called = true;
 494         }
 495       else if (current_plugin->claim_file)
 496         {
 497           current_plugin->claim_file (&file, &claimed);
 498           claim_file_called = true;
 499         }
 500       if (claim_file_called)
 501         bfd_plugin_close_file_descriptor ((abfd->my_archive != NULL
 502                                            ? abfd : NULL),
 503                                           file.fd);
 504     }
 505
 506   return claimed;
 507 }
 508
 509 static bool
 510 try_load_plugin (const char *pname,
 511                  struct plugin_list_entry *plugin_list_iter,
 512                  bfd *abfd,
 513                  bool build_list_p)
 514 {
 515   void *plugin_handle;
 516   struct ld_plugin_tv tv[6];
 517   int i;
 518   ld_plugin_onload onload;
 519   enum ld_plugin_status status;
 520   bool result = false;
 521
 522   /* NB: Each object is independent.  Reuse the previous plugin from
 523      the last run will lead to wrong result.  */
 524   if (current_plugin)
 525     memset (current_plugin, 0,
 526             offsetof (struct plugin_list_entry, next));
 527
 528   if (plugin_list_iter)
 529     pname = plugin_list_iter->plugin_name;
 530
 531   plugin_handle = dlopen (pname, RTLD_NOW);
 532   if (!plugin_handle)
 533     {
 534       /* If we are building a list of viable plugins, then
 535          we do not bother the user with the details of any
 536          plugins that cannot be loaded.  */
 537       if (! build_list_p)
 538         _bfd_error_handler ("Failed to load plugin '%s', reason: %s\n",
 539                             pname, dlerror ());
 540       return false;
 541     }
 542
 543   if (plugin_list_iter == NULL)
 544     {
 545       size_t length_plugin_name = strlen (pname) + 1;
 546       char *plugin_name = bfd_malloc (length_plugin_name);
 547
 548       if (plugin_name == NULL)
 549         goto short_circuit;
 550       plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 551       if (plugin_list_iter == NULL)
 552         {
 553           free (plugin_name);
 554           goto short_circuit;
 555         }
 556       /* Make a copy of PNAME since PNAME from load_plugin () will be
 557          freed.  */
 558       memcpy (plugin_name, pname, length_plugin_name);
 559       memset (plugin_list_iter, 0, sizeof (*plugin_list_iter));
 560       plugin_list_iter->plugin_name = plugin_name;
 561       plugin_list_iter->next = plugin_list;
 562       plugin_list = plugin_list_iter;
 563     }
 564
 565   current_plugin = plugin_list_iter;
 566   if (build_list_p)
 567     goto short_circuit;
 568
 569   onload = dlsym (plugin_handle, "onload");
 570   if (!onload)
 571     goto short_circuit;
 572
 573   i = 0;
 574   tv[i].tv_tag = LDPT_MESSAGE;
 575   tv[i].tv_u.tv_message = message;
 576
 577   ++i;
 578   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 579   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 580
 581   ++i;
 582   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK_V2;
 583   tv[i].tv_u.tv_register_claim_file_v2 = register_claim_file_v2;
 584
 585   ++i;
 586   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 587   tv[i].tv_u.tv_add_symbols = add_symbols;
 588
 589   ++i;
 590   tv[i].tv_tag = LDPT_ADD_SYMBOLS_V2;
 591   tv[i].tv_u.tv_add_symbols = add_symbols_v2;
 592
 593   ++i;
 594   tv[i].tv_tag = LDPT_NULL;
 595   tv[i].tv_u.tv_val = 0;
 596
 597   /* LTO plugin will call handler hooks to set up plugin handlers.  */
 598   status = (*onload)(tv);
 599
 600   if (status != LDPS_OK)
 601     goto short_circuit;
 602
 603   abfd->plugin_format = bfd_plugin_no;
 604
 605   if (!current_plugin->claim_file)
 606     goto short_circuit;
 607
 608   if (!try_claim (abfd))
 609     goto short_circuit;
 610
 611   abfd->plugin_format = bfd_plugin_yes;
 612   result = true;
 613
 614  short_circuit:
 615   dlclose (plugin_handle);
 616   return result;
 617 }
 618
 619 /* There may be plugin libraries in lib/bfd-plugins.  */
 620 static int has_plugin_list = -1;
 621
 622 static bfd_cleanup (*ld_plugin_object_p) (bfd *, bool);
 623
 624 static const char *plugin_name;
 625
 626 void
 627 bfd_plugin_set_plugin (const char *p)
 628 {
 629   plugin_name = p;
 630 }
 631
 632 /* Return TRUE if a plugin library is used.  */
 633
 634 bool
 635 bfd_plugin_specified_p (void)
 636 {
 637   return plugin_list != NULL;
 638 }
 639
 640 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 641
 642 bool
 643 bfd_link_plugin_object_p (bfd *abfd)
 644 {
 645   if (ld_plugin_object_p)
 646     return ld_plugin_object_p (abfd, false) != NULL;
 647   return false;
 648 }
 649
 650 extern const bfd_target plugin_vec;
 651
 652 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 653
 654 bool
 655 bfd_plugin_target_p (const bfd_target *target)
 656 {
 657   return target == &plugin_vec;
 658 }
 659
 660 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 661
 662 void
 663 register_ld_plugin_object_p (bfd_cleanup (*object_p) (bfd *, bool))
 664 {
 665   ld_plugin_object_p = object_p;
 666 }
 667
 668 static void
 669 build_plugin_list (bfd *abfd)
 670 {
 671   /* The intent was to search ${libdir}/bfd-plugins for plugins, but
 672      unfortunately the original implementation wasn't precisely that
 673      when configuring binutils using --libdir.  Search in the proper
 674      path first, then the old one for backwards compatibility.  */
 675   static const char *path[]
 676     = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
 677   struct stat last_st;
 678   unsigned int i;
 679
 680   if (has_plugin_list >= 0)
 681     return;
 682
 683   /* Try not to search the same dir twice, by looking at st_dev and
 684      st_ino for the dir.  If we are on a file system that always sets
 685      st_ino to zero or the actual st_ino is zero we might waste some
 686      time, but that doesn't matter too much.  */
 687   last_st.st_dev = 0;
 688   last_st.st_ino = 0;
 689   for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
 690     {
 691       char *plugin_dir = make_relative_prefix (plugin_program_name,
 692                                                BINDIR,
 693                                                path[i]);
 694       if (plugin_dir)
 695         {
 696           struct stat st;
 697           DIR *d;
 698
 699           if (stat (plugin_dir, &st) == 0
 700               && S_ISDIR (st.st_mode)
 701               && !(last_st.st_dev == st.st_dev
 702                    && last_st.st_ino == st.st_ino
 703                    && st.st_ino != 0)
 704               && (d = opendir (plugin_dir)) != NULL)
 705             {
 706               struct dirent *ent;
 707
 708               last_st.st_dev = st.st_dev;
 709               last_st.st_ino = st.st_ino;
 710               while ((ent = readdir (d)) != NULL)
 711                 {
 712                   char *full_name;
 713
 714                   full_name = concat (plugin_dir, "/", ent->d_name, NULL);
 715                   if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
 716                     (void) try_load_plugin (full_name, NULL, abfd, true);
 717                   free (full_name);
 718                 }
 719               closedir (d);
 720             }
 721           free (plugin_dir);
 722         }
 723     }
 724
 725   has_plugin_list = plugin_list != NULL;
 726 }
 727
 728 static bool
 729 load_plugin (bfd *abfd)
 730 {
 731   struct plugin_list_entry *plugin_list_iter;
 732
 733   if (plugin_name)
 734     return try_load_plugin (plugin_name, plugin_list, abfd, false);
 735
 736   if (plugin_program_name == NULL)
 737     return false;
 738
 739   build_plugin_list (abfd);
 740
 741   for (plugin_list_iter = plugin_list;
 742        plugin_list_iter;
 743        plugin_list_iter = plugin_list_iter->next)
 744     if (try_load_plugin (NULL, plugin_list_iter, abfd, false))
 745       return true;
 746
 747   return false;
 748 }
 749
 750
 751 static bfd_cleanup
 752 bfd_plugin_object_p (bfd *abfd)
 753 {
 754   /* Since ld_plugin_object_p is called only for linker command-line input
 755      objects, pass true to ld_plugin_object_p so that the same input IR
 756      file won't be included twice if the LDPT_REGISTER_CLAIM_FILE_HOOK_V2
 757      isn't used.  */
 758   if (ld_plugin_object_p)
 759     return ld_plugin_object_p (abfd, true);
 760
 761   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 762     return NULL;
 763
 764   return abfd->plugin_format == bfd_plugin_yes ? _bfd_no_cleanup : NULL;
 765 }
 766
 767 /* Copy any private info we understand from the input bfd
 768    to the output bfd.  */
 769
 770 static bool
 771 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 772                                       bfd *obfd ATTRIBUTE_UNUSED)
 773 {
 774   BFD_ASSERT (0);
 775   return true;
 776 }
 777
 778 /* Copy any private info we understand from the input section
 779    to the output section.  */
 780
 781 static bool
 782 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 783                                           asection *isection ATTRIBUTE_UNUSED,
 784                                           bfd *obfd ATTRIBUTE_UNUSED,
 785                                           asection *osection ATTRIBUTE_UNUSED)
 786 {
 787   BFD_ASSERT (0);
 788   return true;
 789 }
 790
 791 /* Copy any private info we understand from the input symbol
 792    to the output symbol.  */
 793
 794 static bool
 795 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 796                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 797                                          bfd *obfd ATTRIBUTE_UNUSED,
 798                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 799 {
 800   BFD_ASSERT (0);
 801   return true;
 802 }
 803
 804 static bool
 805 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, void *ptr ATTRIBUTE_UNUSED)
 806 {
 807   BFD_ASSERT (0);
 808   return true;
 809 }
 810
 811 static char *
 812 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 813 {
 814   BFD_ASSERT (0);
 815   return NULL;
 816 }
 817
 818 static int
 819 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 820 {
 821   BFD_ASSERT (0);
 822   return 0;
 823 }
 824
 825 static int
 826 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 827 {
 828   BFD_ASSERT (0);
 829   return 0;
 830 }
 831
 832 static long
 833 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 834 {
 835   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 836   /* Add symbols from object only section.  */
 837   long nsyms = plugin_data->nsyms + plugin_data->object_only_nsyms;
 838
 839   BFD_ASSERT (nsyms >= 0);
 840
 841   return ((nsyms + 1) * sizeof (asymbol *));
 842 }
 843
 844 static flagword
 845 convert_flags (const struct ld_plugin_symbol *sym)
 846 {
 847  switch (sym->def)
 848    {
 849    case LDPK_DEF:
 850    case LDPK_COMMON:
 851    case LDPK_UNDEF:
 852      return BSF_GLOBAL;
 853
 854    case LDPK_WEAKUNDEF:
 855    case LDPK_WEAKDEF:
 856      return BSF_GLOBAL | BSF_WEAK;
 857
 858    default:
 859      BFD_ASSERT (0);
 860      return 0;
 861    }
 862 }
 863
 864 static long
 865 bfd_plugin_canonicalize_symtab (bfd *abfd,
 866                                 asymbol **alocation)
 867 {
 868   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 869   long nsyms = plugin_data->nsyms;
 870   const struct ld_plugin_symbol *syms = plugin_data->syms;
 871   int i, j;
 872
 873   for (i = 0; i < nsyms; i++)
 874     {
 875       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 876
 877       BFD_ASSERT (s);
 878       alocation[i] = s;
 879
 880       s->the_bfd = abfd;
 881       s->name = syms[i].name;
 882       s->value = 0;
 883       s->flags = convert_flags (&syms[i]);
 884       s->udata.p = NULL;
 885       switch (syms[i].def)
 886         {
 887         case LDPK_COMMON:
 888           s->section = &bfd_plugin_fake_common_section;
 889           break;
 890         case LDPK_UNDEF:
 891         case LDPK_WEAKUNDEF:
 892           s->section = bfd_und_section_ptr;
 893           break;
 894         case LDPK_DEF:
 895         case LDPK_WEAKDEF:
 896           if (current_plugin->has_symbol_type)
 897             switch (syms[i].symbol_type)
 898               {
 899               default:
 900                 /* FIXME: Should we issue an error here ?  */
 901               case LDST_UNKNOWN:
 902                 /* What is the best fake section for LDST_UNKNOWN?  */
 903               case LDST_FUNCTION:
 904                 s->section = &bfd_plugin_fake_text_section;
 905                 break;
 906               case LDST_VARIABLE:
 907                 if (syms[i].section_kind == LDSSK_BSS)
 908                   s->section = &bfd_plugin_fake_bss_section;
 909                 else
 910                   s->section = &bfd_plugin_fake_data_section;
 911                 break;
 912               }
 913           else
 914             s->section = &bfd_plugin_fake_text_section;
 915           break;
 916         default:
 917           BFD_ASSERT (0);
 918         }
 919     }
 920
 921   /* Copy symbols from object only section.  */
 922   nsyms += plugin_data->object_only_nsyms;
 923   for (j = 0; j < plugin_data->object_only_nsyms; j++, i++)
 924     alocation[i] = plugin_data->object_only_syms[j];
 925
 926   return nsyms;
 927 }
 928
 929 static void
 930 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 931                          void *afile ATTRIBUTE_UNUSED,
 932                          asymbol *symbol ATTRIBUTE_UNUSED,
 933                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
 934 {
 935   BFD_ASSERT (0);
 936 }
 937
 938 static void
 939 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 940                             asymbol *symbol,
 941                             symbol_info *ret)
 942 {
 943   bfd_symbol_info (symbol, ret);
 944 }
 945
 946 /* Make an empty symbol. */
 947
 948 static asymbol *
 949 bfd_plugin_make_empty_symbol (bfd *abfd)
 950 {
 951   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
 952   if (new_symbol == NULL)
 953     return new_symbol;
 954   new_symbol->the_bfd = abfd;
 955   return new_symbol;
 956 }
 957
 958 static int
 959 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
 960                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
 961 {
 962   BFD_ASSERT (0);
 963   return 0;
 964 }
 965
 966 const bfd_target plugin_vec =
 967 {
 968   "plugin",                     /* Name.  */
 969   bfd_target_unknown_flavour,
 970   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
 971   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
 972   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 973    HAS_LINENO | HAS_DEBUG |
 974    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 975   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 976    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 977   0,                            /* symbol_leading_char.  */
 978   '/',                          /* ar_pad_char.  */
 979   15,                           /* ar_max_namelen.  */
 980   255,                          /* match priority.  */
 981   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 982
 983   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 984   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 985   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
 986   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 987   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 988   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
 989
 990   {                             /* bfd_check_format.  */
 991     _bfd_dummy_target,
 992     bfd_plugin_object_p,
 993     bfd_generic_archive_p,
 994     _bfd_dummy_target
 995   },
 996   {                             /* bfd_set_format.  */
 997     _bfd_bool_bfd_false_error,
 998     _bfd_bool_bfd_false_error,
 999     _bfd_generic_mkarchive,
1000     _bfd_bool_bfd_false_error,
1001   },
1002   {                             /* bfd_write_contents.  */
1003     _bfd_bool_bfd_false_error,
1004     _bfd_bool_bfd_false_error,
1005     _bfd_write_archive_contents,
1006     _bfd_bool_bfd_false_error,
1007   },
1008
1009   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
1010   BFD_JUMP_TABLE_COPY (bfd_plugin),
1011   BFD_JUMP_TABLE_CORE (bfd_plugin),
1012 #ifdef USE_64_BIT_ARCHIVE
1013   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
1014 #else
1015   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1016 #endif
1017   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
1018   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1019   BFD_JUMP_TABLE_WRITE (bfd_plugin),
1020   BFD_JUMP_TABLE_LINK (bfd_plugin),
1021   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1022
1023   NULL,
1024
1025   NULL                          /* backend_data.  */
1026 };
1027 #endif /* BFD_SUPPORTS_PLUGINS */