bfd/plugin.c

   1 /* Plugin support for BFD.
   2    Copyright (C) 2009-2024 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
 164 /* Register a claim-file handler, version 2. */
 165
 166 static enum ld_plugin_status
 167 register_claim_file_v2 (ld_plugin_claim_file_handler_v2 handler)
 168 {
 169   current_plugin->claim_file_v2 = handler;
 170   return LDPS_OK;
 171 }
 172
 173 static enum ld_plugin_status
 174 add_symbols (void * handle,
 175              int nsyms,
 176              const struct ld_plugin_symbol * syms)
 177 {
 178   bfd *abfd = handle;
 179   struct plugin_data_struct *plugin_data =
 180     bfd_alloc (abfd, sizeof (plugin_data_struct));
 181
 182   if (!plugin_data)
 183     return LDPS_ERR;
 184
 185   plugin_data->nsyms = nsyms;
 186   plugin_data->syms = syms;
 187
 188   if (nsyms != 0)
 189     abfd->flags |= HAS_SYMS;
 190
 191   abfd->tdata.plugin_data = plugin_data;
 192   return LDPS_OK;
 193 }
 194
 195 static enum ld_plugin_status
 196 add_symbols_v2 (void *handle, int nsyms,
 197                 const struct ld_plugin_symbol *syms)
 198 {
 199   current_plugin->has_symbol_type = true;
 200   return add_symbols (handle, nsyms, syms);
 201 }
 202
 203 int
 204 bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
 205 {
 206   bfd *iobfd;
 207   int fd;
 208
 209   iobfd = ibfd;
 210   while (iobfd->my_archive
 211          && !bfd_is_thin_archive (iobfd->my_archive))
 212     iobfd = iobfd->my_archive;
 213   file->name = bfd_get_filename (iobfd);
 214
 215   if (!iobfd->iostream && !bfd_open_file (iobfd))
 216     return 0;
 217
 218   /* Reuse the archive plugin file descriptor.  */
 219   if (iobfd != ibfd)
 220     fd = iobfd->archive_plugin_fd;
 221   else
 222     fd = -1;
 223
 224   if (fd < 0)
 225     {
 226       /* The plugin API expects that the file descriptor won't be closed
 227          and reused as done by the bfd file cache.  So open it again.
 228          dup isn't good enough.  plugin IO uses lseek/read while BFD uses
 229          fseek/fread.  It isn't wise to mix the unistd and stdio calls on
 230          the same underlying file descriptor.  */
 231       fd = open (file->name, O_RDONLY | O_BINARY);
 232       if (fd < 0)
 233         {
 234 #ifndef EMFILE
 235           return 0;
 236 #else
 237           if (errno != EMFILE)
 238             return 0;
 239
 240 #ifdef HAVE_GETRLIMIT
 241           struct rlimit lim;
 242
 243           /* Complicated links involving lots of files and/or large
 244              archives can exhaust the number of file descriptors
 245              available to us.  If possible, try to allocate more
 246              descriptors.  */
 247           if (getrlimit (RLIMIT_NOFILE, & lim) == 0
 248               && lim.rlim_cur < lim.rlim_max)
 249             {
 250               lim.rlim_cur = lim.rlim_max;
 251               if (setrlimit (RLIMIT_NOFILE, &lim) == 0)
 252                 fd = open (file->name, O_RDONLY | O_BINARY);
 253             }
 254
 255           if (fd < 0)
 256 #endif
 257             {
 258               _bfd_error_handler (_("plugin framework: out of file descriptors. Try using fewer objects/archives\n"));
 259               return 0;
 260             }
 261 #endif
 262         }
 263     }
 264
 265   if (iobfd == ibfd)
 266     {
 267       struct stat stat_buf;
 268
 269       if (fstat (fd, &stat_buf))
 270         {
 271           close (fd);
 272           return 0;
 273         }
 274
 275       file->offset = 0;
 276       file->filesize = stat_buf.st_size;
 277     }
 278   else
 279     {
 280       /* Cache the archive plugin file descriptor.  */
 281       iobfd->archive_plugin_fd = fd;
 282       iobfd->archive_plugin_fd_open_count++;
 283
 284       file->offset = ibfd->origin;
 285       file->filesize = arelt_size (ibfd);
 286     }
 287
 288   file->fd = fd;
 289   return 1;
 290 }
 291
 292 /* Close the plugin file descriptor FD.  If ABFD isn't NULL, it is an
 293    archive member.   */
 294
 295 void
 296 bfd_plugin_close_file_descriptor (bfd *abfd, int fd)
 297 {
 298   if (abfd == NULL)
 299     close (fd);
 300   else
 301     {
 302       while (abfd->my_archive
 303              && !bfd_is_thin_archive (abfd->my_archive))
 304         abfd = abfd->my_archive;
 305
 306       /* Close the file descriptor if there is no archive plugin file
 307          descriptor.  */
 308       if (abfd->archive_plugin_fd == -1)
 309         {
 310           close (fd);
 311           return;
 312         }
 313
 314       abfd->archive_plugin_fd_open_count--;
 315       /* Dup the archive plugin file descriptor for later use, which
 316          will be closed by _bfd_archive_close_and_cleanup.  */
 317       if (abfd->archive_plugin_fd_open_count == 0)
 318         {
 319           abfd->archive_plugin_fd = dup (fd);
 320           close (fd);
 321         }
 322     }
 323 }
 324
 325 static int
 326 try_claim (bfd *abfd)
 327 {
 328   int claimed = 0;
 329   struct ld_plugin_input_file file;
 330
 331   file.handle = abfd;
 332   if (bfd_plugin_open_input (abfd, &file)
 333       && current_plugin->claim_file)
 334     {
 335       current_plugin->claim_file (&file, &claimed);
 336       bfd_plugin_close_file_descriptor ((abfd->my_archive != NULL
 337                                          ? abfd : NULL),
 338                                         file.fd);
 339     }
 340
 341   return claimed;
 342 }
 343
 344 static bool
 345 try_load_plugin (const char *pname,
 346                  struct plugin_list_entry *plugin_list_iter,
 347                  bfd *abfd,
 348                  bool build_list_p)
 349 {
 350   void *plugin_handle;
 351   struct ld_plugin_tv tv[6];
 352   int i;
 353   ld_plugin_onload onload;
 354   enum ld_plugin_status status;
 355   bool result = false;
 356
 357   /* NB: Each object is independent.  Reuse the previous plugin from
 358      the last run will lead to wrong result.  */
 359   if (current_plugin)
 360     memset (current_plugin, 0,
 361             offsetof (struct plugin_list_entry, next));
 362
 363   if (plugin_list_iter)
 364     pname = plugin_list_iter->plugin_name;
 365
 366   plugin_handle = dlopen (pname, RTLD_NOW);
 367   if (!plugin_handle)
 368     {
 369       /* If we are building a list of viable plugins, then
 370          we do not bother the user with the details of any
 371          plugins that cannot be loaded.  */
 372       if (! build_list_p)
 373         _bfd_error_handler ("Failed to load plugin '%s', reason: %s\n",
 374                             pname, dlerror ());
 375       return false;
 376     }
 377
 378   if (plugin_list_iter == NULL)
 379     {
 380       size_t length_plugin_name = strlen (pname) + 1;
 381       char *plugin_name = bfd_malloc (length_plugin_name);
 382
 383       if (plugin_name == NULL)
 384         goto short_circuit;
 385       plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 386       if (plugin_list_iter == NULL)
 387         {
 388           free (plugin_name);
 389           goto short_circuit;
 390         }
 391       /* Make a copy of PNAME since PNAME from load_plugin () will be
 392          freed.  */
 393       memcpy (plugin_name, pname, length_plugin_name);
 394       memset (plugin_list_iter, 0, sizeof (*plugin_list_iter));
 395       plugin_list_iter->plugin_name = plugin_name;
 396       plugin_list_iter->next = plugin_list;
 397       plugin_list = plugin_list_iter;
 398     }
 399
 400   current_plugin = plugin_list_iter;
 401   if (build_list_p)
 402     goto short_circuit;
 403
 404   onload = dlsym (plugin_handle, "onload");
 405   if (!onload)
 406     goto short_circuit;
 407
 408   i = 0;
 409   tv[i].tv_tag = LDPT_MESSAGE;
 410   tv[i].tv_u.tv_message = message;
 411
 412   ++i;
 413   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 414   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 415
 416   ++i;
 417   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK_V2;
 418   tv[i].tv_u.tv_register_claim_file_v2 = register_claim_file_v2;
 419
 420   ++i;
 421   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 422   tv[i].tv_u.tv_add_symbols = add_symbols;
 423
 424   ++i;
 425   tv[i].tv_tag = LDPT_ADD_SYMBOLS_V2;
 426   tv[i].tv_u.tv_add_symbols = add_symbols_v2;
 427
 428   ++i;
 429   tv[i].tv_tag = LDPT_NULL;
 430   tv[i].tv_u.tv_val = 0;
 431
 432   /* LTO plugin will call handler hooks to set up plugin handlers.  */
 433   status = (*onload)(tv);
 434
 435   if (status != LDPS_OK)
 436     goto short_circuit;
 437
 438   abfd->plugin_format = bfd_plugin_no;
 439
 440   if (!current_plugin->claim_file)
 441     goto short_circuit;
 442
 443   if (!try_claim (abfd))
 444     goto short_circuit;
 445
 446   abfd->plugin_format = bfd_plugin_yes;
 447   result = true;
 448
 449  short_circuit:
 450   dlclose (plugin_handle);
 451   return result;
 452 }
 453
 454 /* There may be plugin libraries in lib/bfd-plugins.  */
 455 static int has_plugin_list = -1;
 456
 457 static bfd_cleanup (*ld_plugin_object_p) (bfd *, bool);
 458
 459 static const char *plugin_name;
 460
 461 void
 462 bfd_plugin_set_plugin (const char *p)
 463 {
 464   plugin_name = p;
 465 }
 466
 467 /* Return TRUE if a plugin library is used.  */
 468
 469 bool
 470 bfd_plugin_specified_p (void)
 471 {
 472   return plugin_list != NULL;
 473 }
 474
 475 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 476
 477 bool
 478 bfd_link_plugin_object_p (bfd *abfd)
 479 {
 480   if (ld_plugin_object_p)
 481     return ld_plugin_object_p (abfd, false) != NULL;
 482   return false;
 483 }
 484
 485 extern const bfd_target plugin_vec;
 486
 487 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 488
 489 bool
 490 bfd_plugin_target_p (const bfd_target *target)
 491 {
 492   return target == &plugin_vec;
 493 }
 494
 495 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 496
 497 void
 498 register_ld_plugin_object_p (bfd_cleanup (*object_p) (bfd *, bool))
 499 {
 500   ld_plugin_object_p = object_p;
 501 }
 502
 503 static void
 504 build_plugin_list (bfd *abfd)
 505 {
 506   /* The intent was to search ${libdir}/bfd-plugins for plugins, but
 507      unfortunately the original implementation wasn't precisely that
 508      when configuring binutils using --libdir.  Search in the proper
 509      path first, then the old one for backwards compatibility.  */
 510   static const char *path[]
 511     = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
 512   struct stat last_st;
 513   unsigned int i;
 514
 515   if (has_plugin_list >= 0)
 516     return;
 517
 518   /* Try not to search the same dir twice, by looking at st_dev and
 519      st_ino for the dir.  If we are on a file system that always sets
 520      st_ino to zero or the actual st_ino is zero we might waste some
 521      time, but that doesn't matter too much.  */
 522   last_st.st_dev = 0;
 523   last_st.st_ino = 0;
 524   for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
 525     {
 526       char *plugin_dir = make_relative_prefix (plugin_program_name,
 527                                                BINDIR,
 528                                                path[i]);
 529       if (plugin_dir)
 530         {
 531           struct stat st;
 532           DIR *d;
 533
 534           if (stat (plugin_dir, &st) == 0
 535               && S_ISDIR (st.st_mode)
 536               && !(last_st.st_dev == st.st_dev
 537                    && last_st.st_ino == st.st_ino
 538                    && st.st_ino != 0)
 539               && (d = opendir (plugin_dir)) != NULL)
 540             {
 541               struct dirent *ent;
 542
 543               last_st.st_dev = st.st_dev;
 544               last_st.st_ino = st.st_ino;
 545               while ((ent = readdir (d)) != NULL)
 546                 {
 547                   char *full_name;
 548
 549                   full_name = concat (plugin_dir, "/", ent->d_name, NULL);
 550                   if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
 551                     (void) try_load_plugin (full_name, NULL, abfd, true);
 552                   free (full_name);
 553                 }
 554               closedir (d);
 555             }
 556           free (plugin_dir);
 557         }
 558     }
 559
 560   has_plugin_list = plugin_list != NULL;
 561 }
 562
 563 static bool
 564 load_plugin (bfd *abfd)
 565 {
 566   struct plugin_list_entry *plugin_list_iter;
 567
 568   if (plugin_name)
 569     return try_load_plugin (plugin_name, plugin_list, abfd, false);
 570
 571   if (plugin_program_name == NULL)
 572     return false;
 573
 574   build_plugin_list (abfd);
 575
 576   for (plugin_list_iter = plugin_list;
 577        plugin_list_iter;
 578        plugin_list_iter = plugin_list_iter->next)
 579     if (try_load_plugin (NULL, plugin_list_iter, abfd, false))
 580       return true;
 581
 582   return false;
 583 }
 584
 585
 586 static bfd_cleanup
 587 bfd_plugin_object_p (bfd *abfd)
 588 {
 589   if (ld_plugin_object_p)
 590     return ld_plugin_object_p (abfd, false);
 591
 592   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 593     return NULL;
 594
 595   return abfd->plugin_format == bfd_plugin_yes ? _bfd_no_cleanup : NULL;
 596 }
 597
 598 /* Copy any private info we understand from the input bfd
 599    to the output bfd.  */
 600
 601 static bool
 602 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 603                                       bfd *obfd ATTRIBUTE_UNUSED)
 604 {
 605   BFD_ASSERT (0);
 606   return true;
 607 }
 608
 609 /* Copy any private info we understand from the input section
 610    to the output section.  */
 611
 612 static bool
 613 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 614                                           asection *isection ATTRIBUTE_UNUSED,
 615                                           bfd *obfd ATTRIBUTE_UNUSED,
 616                                           asection *osection ATTRIBUTE_UNUSED)
 617 {
 618   BFD_ASSERT (0);
 619   return true;
 620 }
 621
 622 /* Copy any private info we understand from the input symbol
 623    to the output symbol.  */
 624
 625 static bool
 626 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 627                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 628                                          bfd *obfd ATTRIBUTE_UNUSED,
 629                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 630 {
 631   BFD_ASSERT (0);
 632   return true;
 633 }
 634
 635 static bool
 636 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, void *ptr ATTRIBUTE_UNUSED)
 637 {
 638   BFD_ASSERT (0);
 639   return true;
 640 }
 641
 642 static char *
 643 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 644 {
 645   BFD_ASSERT (0);
 646   return NULL;
 647 }
 648
 649 static int
 650 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 651 {
 652   BFD_ASSERT (0);
 653   return 0;
 654 }
 655
 656 static int
 657 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 658 {
 659   BFD_ASSERT (0);
 660   return 0;
 661 }
 662
 663 static long
 664 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 665 {
 666   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 667   long nsyms = plugin_data->nsyms;
 668
 669   BFD_ASSERT (nsyms >= 0);
 670
 671   return ((nsyms + 1) * sizeof (asymbol *));
 672 }
 673
 674 static flagword
 675 convert_flags (const struct ld_plugin_symbol *sym)
 676 {
 677  switch (sym->def)
 678    {
 679    case LDPK_DEF:
 680    case LDPK_COMMON:
 681    case LDPK_UNDEF:
 682      return BSF_GLOBAL;
 683
 684    case LDPK_WEAKUNDEF:
 685    case LDPK_WEAKDEF:
 686      return BSF_GLOBAL | BSF_WEAK;
 687
 688    default:
 689      BFD_ASSERT (0);
 690      return 0;
 691    }
 692 }
 693
 694 static long
 695 bfd_plugin_canonicalize_symtab (bfd *abfd,
 696                                 asymbol **alocation)
 697 {
 698   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 699   long nsyms = plugin_data->nsyms;
 700   const struct ld_plugin_symbol *syms = plugin_data->syms;
 701   static asection fake_text_section
 702     = BFD_FAKE_SECTION (fake_text_section, NULL, "plug", 0,
 703                         SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 704   static asection fake_data_section
 705     = BFD_FAKE_SECTION (fake_data_section, NULL, "plug", 0,
 706                         SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS);
 707   static asection fake_bss_section
 708     = BFD_FAKE_SECTION (fake_bss_section, NULL, "plug", 0,
 709                         SEC_ALLOC);
 710   static asection fake_common_section
 711     = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
 712   int i;
 713
 714   for (i = 0; i < nsyms; i++)
 715     {
 716       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 717
 718       BFD_ASSERT (s);
 719       alocation[i] = s;
 720
 721       s->the_bfd = abfd;
 722       s->name = syms[i].name;
 723       s->value = 0;
 724       s->flags = convert_flags (&syms[i]);
 725       switch (syms[i].def)
 726         {
 727         case LDPK_COMMON:
 728           s->section = &fake_common_section;
 729           break;
 730         case LDPK_UNDEF:
 731         case LDPK_WEAKUNDEF:
 732           s->section = bfd_und_section_ptr;
 733           break;
 734         case LDPK_DEF:
 735         case LDPK_WEAKDEF:
 736           if (current_plugin->has_symbol_type)
 737             switch (syms[i].symbol_type)
 738               {
 739               default:
 740                 /* FIXME: Should we issue an error here ?  */
 741               case LDST_UNKNOWN:
 742                 /* What is the best fake section for LDST_UNKNOWN?  */
 743               case LDST_FUNCTION:
 744                 s->section = &fake_text_section;
 745                 break;
 746               case LDST_VARIABLE:
 747                 if (syms[i].section_kind == LDSSK_BSS)
 748                   s->section = &fake_bss_section;
 749                 else
 750                   s->section = &fake_data_section;
 751                 break;
 752               }
 753           else
 754             s->section = &fake_text_section;
 755           break;
 756         default:
 757           BFD_ASSERT (0);
 758         }
 759
 760       s->udata.p = (void *) &syms[i];
 761     }
 762
 763   return nsyms;
 764 }
 765
 766 static void
 767 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 768                          void *afile ATTRIBUTE_UNUSED,
 769                          asymbol *symbol ATTRIBUTE_UNUSED,
 770                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
 771 {
 772   BFD_ASSERT (0);
 773 }
 774
 775 static void
 776 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 777                             asymbol *symbol,
 778                             symbol_info *ret)
 779 {
 780   bfd_symbol_info (symbol, ret);
 781 }
 782
 783 /* Make an empty symbol. */
 784
 785 static asymbol *
 786 bfd_plugin_make_empty_symbol (bfd *abfd)
 787 {
 788   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
 789   if (new_symbol == NULL)
 790     return new_symbol;
 791   new_symbol->the_bfd = abfd;
 792   return new_symbol;
 793 }
 794
 795 static int
 796 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
 797                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
 798 {
 799   BFD_ASSERT (0);
 800   return 0;
 801 }
 802
 803 const bfd_target plugin_vec =
 804 {
 805   "plugin",                     /* Name.  */
 806   bfd_target_unknown_flavour,
 807   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
 808   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
 809   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 810    HAS_LINENO | HAS_DEBUG |
 811    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 812   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 813    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 814   0,                            /* symbol_leading_char.  */
 815   '/',                          /* ar_pad_char.  */
 816   15,                           /* ar_max_namelen.  */
 817   255,                          /* match priority.  */
 818   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 819
 820   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 821   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 822   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
 823   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 824   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 825   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
 826
 827   {                             /* bfd_check_format.  */
 828     _bfd_dummy_target,
 829     bfd_plugin_object_p,
 830     bfd_generic_archive_p,
 831     _bfd_dummy_target
 832   },
 833   {                             /* bfd_set_format.  */
 834     _bfd_bool_bfd_false_error,
 835     _bfd_bool_bfd_false_error,
 836     _bfd_generic_mkarchive,
 837     _bfd_bool_bfd_false_error,
 838   },
 839   {                             /* bfd_write_contents.  */
 840     _bfd_bool_bfd_false_error,
 841     _bfd_bool_bfd_false_error,
 842     _bfd_write_archive_contents,
 843     _bfd_bool_bfd_false_error,
 844   },
 845
 846   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
 847   BFD_JUMP_TABLE_COPY (bfd_plugin),
 848   BFD_JUMP_TABLE_CORE (bfd_plugin),
 849 #ifdef USE_64_BIT_ARCHIVE
 850   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
 851 #else
 852   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 853 #endif
 854   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
 855   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 856   BFD_JUMP_TABLE_WRITE (bfd_plugin),
 857   BFD_JUMP_TABLE_LINK (bfd_plugin),
 858   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 859
 860   NULL,
 861
 862   NULL                          /* backend_data.  */
 863 };
 864 #endif /* BFD_SUPPORTS_PLUGINS */