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     {
 334       bool claim_file_called = false;
 335       if (current_plugin->claim_file_v2)
 336         {
 337           current_plugin->claim_file_v2 (&file, &claimed, false);
 338           claim_file_called = true;
 339         }
 340       else if (current_plugin->claim_file)
 341         {
 342           current_plugin->claim_file (&file, &claimed);
 343           claim_file_called = true;
 344         }
 345       if (claim_file_called)
 346         bfd_plugin_close_file_descriptor ((abfd->my_archive != NULL
 347                                            ? abfd : NULL),
 348                                           file.fd);
 349     }
 350
 351   return claimed;
 352 }
 353
 354 static bool
 355 try_load_plugin (const char *pname,
 356                  struct plugin_list_entry *plugin_list_iter,
 357                  bfd *abfd,
 358                  bool build_list_p)
 359 {
 360   void *plugin_handle;
 361   struct ld_plugin_tv tv[6];
 362   int i;
 363   ld_plugin_onload onload;
 364   enum ld_plugin_status status;
 365   bool result = false;
 366
 367   /* NB: Each object is independent.  Reuse the previous plugin from
 368      the last run will lead to wrong result.  */
 369   if (current_plugin)
 370     memset (current_plugin, 0,
 371             offsetof (struct plugin_list_entry, next));
 372
 373   if (plugin_list_iter)
 374     pname = plugin_list_iter->plugin_name;
 375
 376   plugin_handle = dlopen (pname, RTLD_NOW);
 377   if (!plugin_handle)
 378     {
 379       /* If we are building a list of viable plugins, then
 380          we do not bother the user with the details of any
 381          plugins that cannot be loaded.  */
 382       if (! build_list_p)
 383         _bfd_error_handler ("Failed to load plugin '%s', reason: %s\n",
 384                             pname, dlerror ());
 385       return false;
 386     }
 387
 388   if (plugin_list_iter == NULL)
 389     {
 390       size_t length_plugin_name = strlen (pname) + 1;
 391       char *plugin_name = bfd_malloc (length_plugin_name);
 392
 393       if (plugin_name == NULL)
 394         goto short_circuit;
 395       plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 396       if (plugin_list_iter == NULL)
 397         {
 398           free (plugin_name);
 399           goto short_circuit;
 400         }
 401       /* Make a copy of PNAME since PNAME from load_plugin () will be
 402          freed.  */
 403       memcpy (plugin_name, pname, length_plugin_name);
 404       memset (plugin_list_iter, 0, sizeof (*plugin_list_iter));
 405       plugin_list_iter->plugin_name = plugin_name;
 406       plugin_list_iter->next = plugin_list;
 407       plugin_list = plugin_list_iter;
 408     }
 409
 410   current_plugin = plugin_list_iter;
 411   if (build_list_p)
 412     goto short_circuit;
 413
 414   onload = dlsym (plugin_handle, "onload");
 415   if (!onload)
 416     goto short_circuit;
 417
 418   i = 0;
 419   tv[i].tv_tag = LDPT_MESSAGE;
 420   tv[i].tv_u.tv_message = message;
 421
 422   ++i;
 423   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 424   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 425
 426   ++i;
 427   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK_V2;
 428   tv[i].tv_u.tv_register_claim_file_v2 = register_claim_file_v2;
 429
 430   ++i;
 431   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 432   tv[i].tv_u.tv_add_symbols = add_symbols;
 433
 434   ++i;
 435   tv[i].tv_tag = LDPT_ADD_SYMBOLS_V2;
 436   tv[i].tv_u.tv_add_symbols = add_symbols_v2;
 437
 438   ++i;
 439   tv[i].tv_tag = LDPT_NULL;
 440   tv[i].tv_u.tv_val = 0;
 441
 442   /* LTO plugin will call handler hooks to set up plugin handlers.  */
 443   status = (*onload)(tv);
 444
 445   if (status != LDPS_OK)
 446     goto short_circuit;
 447
 448   abfd->plugin_format = bfd_plugin_no;
 449
 450   if (!current_plugin->claim_file)
 451     goto short_circuit;
 452
 453   if (!try_claim (abfd))
 454     goto short_circuit;
 455
 456   abfd->plugin_format = bfd_plugin_yes;
 457   result = true;
 458
 459  short_circuit:
 460   dlclose (plugin_handle);
 461   return result;
 462 }
 463
 464 /* There may be plugin libraries in lib/bfd-plugins.  */
 465 static int has_plugin_list = -1;
 466
 467 static bfd_cleanup (*ld_plugin_object_p) (bfd *, bool);
 468
 469 static const char *plugin_name;
 470
 471 void
 472 bfd_plugin_set_plugin (const char *p)
 473 {
 474   plugin_name = p;
 475 }
 476
 477 /* Return TRUE if a plugin library is used.  */
 478
 479 bool
 480 bfd_plugin_specified_p (void)
 481 {
 482   return plugin_list != NULL;
 483 }
 484
 485 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 486
 487 bool
 488 bfd_link_plugin_object_p (bfd *abfd)
 489 {
 490   if (ld_plugin_object_p)
 491     return ld_plugin_object_p (abfd, false) != NULL;
 492   return false;
 493 }
 494
 495 extern const bfd_target plugin_vec;
 496
 497 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 498
 499 bool
 500 bfd_plugin_target_p (const bfd_target *target)
 501 {
 502   return target == &plugin_vec;
 503 }
 504
 505 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 506
 507 void
 508 register_ld_plugin_object_p (bfd_cleanup (*object_p) (bfd *, bool))
 509 {
 510   ld_plugin_object_p = object_p;
 511 }
 512
 513 static void
 514 build_plugin_list (bfd *abfd)
 515 {
 516   /* The intent was to search ${libdir}/bfd-plugins for plugins, but
 517      unfortunately the original implementation wasn't precisely that
 518      when configuring binutils using --libdir.  Search in the proper
 519      path first, then the old one for backwards compatibility.  */
 520   static const char *path[]
 521     = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
 522   struct stat last_st;
 523   unsigned int i;
 524
 525   if (has_plugin_list >= 0)
 526     return;
 527
 528   /* Try not to search the same dir twice, by looking at st_dev and
 529      st_ino for the dir.  If we are on a file system that always sets
 530      st_ino to zero or the actual st_ino is zero we might waste some
 531      time, but that doesn't matter too much.  */
 532   last_st.st_dev = 0;
 533   last_st.st_ino = 0;
 534   for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
 535     {
 536       char *plugin_dir = make_relative_prefix (plugin_program_name,
 537                                                BINDIR,
 538                                                path[i]);
 539       if (plugin_dir)
 540         {
 541           struct stat st;
 542           DIR *d;
 543
 544           if (stat (plugin_dir, &st) == 0
 545               && S_ISDIR (st.st_mode)
 546               && !(last_st.st_dev == st.st_dev
 547                    && last_st.st_ino == st.st_ino
 548                    && st.st_ino != 0)
 549               && (d = opendir (plugin_dir)) != NULL)
 550             {
 551               struct dirent *ent;
 552
 553               last_st.st_dev = st.st_dev;
 554               last_st.st_ino = st.st_ino;
 555               while ((ent = readdir (d)) != NULL)
 556                 {
 557                   char *full_name;
 558
 559                   full_name = concat (plugin_dir, "/", ent->d_name, NULL);
 560                   if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
 561                     (void) try_load_plugin (full_name, NULL, abfd, true);
 562                   free (full_name);
 563                 }
 564               closedir (d);
 565             }
 566           free (plugin_dir);
 567         }
 568     }
 569
 570   has_plugin_list = plugin_list != NULL;
 571 }
 572
 573 static bool
 574 load_plugin (bfd *abfd)
 575 {
 576   struct plugin_list_entry *plugin_list_iter;
 577
 578   if (plugin_name)
 579     return try_load_plugin (plugin_name, plugin_list, abfd, false);
 580
 581   if (plugin_program_name == NULL)
 582     return false;
 583
 584   build_plugin_list (abfd);
 585
 586   for (plugin_list_iter = plugin_list;
 587        plugin_list_iter;
 588        plugin_list_iter = plugin_list_iter->next)
 589     if (try_load_plugin (NULL, plugin_list_iter, abfd, false))
 590       return true;
 591
 592   return false;
 593 }
 594
 595
 596 static bfd_cleanup
 597 bfd_plugin_object_p (bfd *abfd)
 598 {
 599   /* Since ld_plugin_object_p is called only for linker command-line input
 600      objects, pass true to ld_plugin_object_p so that the same input IR
 601      file won't be included twice if the LDPT_REGISTER_CLAIM_FILE_HOOK_V2
 602      isn't used.  */
 603   if (ld_plugin_object_p)
 604     return ld_plugin_object_p (abfd, true);
 605
 606   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 607     return NULL;
 608
 609   return abfd->plugin_format == bfd_plugin_yes ? _bfd_no_cleanup : NULL;
 610 }
 611
 612 /* Copy any private info we understand from the input bfd
 613    to the output bfd.  */
 614
 615 static bool
 616 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 617                                       bfd *obfd ATTRIBUTE_UNUSED)
 618 {
 619   BFD_ASSERT (0);
 620   return true;
 621 }
 622
 623 /* Copy any private info we understand from the input section
 624    to the output section.  */
 625
 626 static bool
 627 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 628                                           asection *isection ATTRIBUTE_UNUSED,
 629                                           bfd *obfd ATTRIBUTE_UNUSED,
 630                                           asection *osection ATTRIBUTE_UNUSED)
 631 {
 632   BFD_ASSERT (0);
 633   return true;
 634 }
 635
 636 /* Copy any private info we understand from the input symbol
 637    to the output symbol.  */
 638
 639 static bool
 640 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 641                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 642                                          bfd *obfd ATTRIBUTE_UNUSED,
 643                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 644 {
 645   BFD_ASSERT (0);
 646   return true;
 647 }
 648
 649 static bool
 650 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, void *ptr ATTRIBUTE_UNUSED)
 651 {
 652   BFD_ASSERT (0);
 653   return true;
 654 }
 655
 656 static char *
 657 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 658 {
 659   BFD_ASSERT (0);
 660   return NULL;
 661 }
 662
 663 static int
 664 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 665 {
 666   BFD_ASSERT (0);
 667   return 0;
 668 }
 669
 670 static int
 671 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 672 {
 673   BFD_ASSERT (0);
 674   return 0;
 675 }
 676
 677 static long
 678 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 679 {
 680   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 681   long nsyms = plugin_data->nsyms;
 682
 683   BFD_ASSERT (nsyms >= 0);
 684
 685   return ((nsyms + 1) * sizeof (asymbol *));
 686 }
 687
 688 static flagword
 689 convert_flags (const struct ld_plugin_symbol *sym)
 690 {
 691  switch (sym->def)
 692    {
 693    case LDPK_DEF:
 694    case LDPK_COMMON:
 695    case LDPK_UNDEF:
 696      return BSF_GLOBAL;
 697
 698    case LDPK_WEAKUNDEF:
 699    case LDPK_WEAKDEF:
 700      return BSF_GLOBAL | BSF_WEAK;
 701
 702    default:
 703      BFD_ASSERT (0);
 704      return 0;
 705    }
 706 }
 707
 708 static long
 709 bfd_plugin_canonicalize_symtab (bfd *abfd,
 710                                 asymbol **alocation)
 711 {
 712   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 713   long nsyms = plugin_data->nsyms;
 714   const struct ld_plugin_symbol *syms = plugin_data->syms;
 715   static asection fake_text_section
 716     = BFD_FAKE_SECTION (fake_text_section, NULL, "plug", 0,
 717                         SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 718   static asection fake_data_section
 719     = BFD_FAKE_SECTION (fake_data_section, NULL, "plug", 0,
 720                         SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS);
 721   static asection fake_bss_section
 722     = BFD_FAKE_SECTION (fake_bss_section, NULL, "plug", 0,
 723                         SEC_ALLOC);
 724   static asection fake_common_section
 725     = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
 726   int i;
 727
 728   for (i = 0; i < nsyms; i++)
 729     {
 730       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 731
 732       BFD_ASSERT (s);
 733       alocation[i] = s;
 734
 735       s->the_bfd = abfd;
 736       s->name = syms[i].name;
 737       s->value = 0;
 738       s->flags = convert_flags (&syms[i]);
 739       switch (syms[i].def)
 740         {
 741         case LDPK_COMMON:
 742           s->section = &fake_common_section;
 743           break;
 744         case LDPK_UNDEF:
 745         case LDPK_WEAKUNDEF:
 746           s->section = bfd_und_section_ptr;
 747           break;
 748         case LDPK_DEF:
 749         case LDPK_WEAKDEF:
 750           if (current_plugin->has_symbol_type)
 751             switch (syms[i].symbol_type)
 752               {
 753               default:
 754                 /* FIXME: Should we issue an error here ?  */
 755               case LDST_UNKNOWN:
 756                 /* What is the best fake section for LDST_UNKNOWN?  */
 757               case LDST_FUNCTION:
 758                 s->section = &fake_text_section;
 759                 break;
 760               case LDST_VARIABLE:
 761                 if (syms[i].section_kind == LDSSK_BSS)
 762                   s->section = &fake_bss_section;
 763                 else
 764                   s->section = &fake_data_section;
 765                 break;
 766               }
 767           else
 768             s->section = &fake_text_section;
 769           break;
 770         default:
 771           BFD_ASSERT (0);
 772         }
 773
 774       s->udata.p = (void *) &syms[i];
 775     }
 776
 777   return nsyms;
 778 }
 779
 780 static void
 781 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
 782                          void *afile ATTRIBUTE_UNUSED,
 783                          asymbol *symbol ATTRIBUTE_UNUSED,
 784                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
 785 {
 786   BFD_ASSERT (0);
 787 }
 788
 789 static void
 790 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 791                             asymbol *symbol,
 792                             symbol_info *ret)
 793 {
 794   bfd_symbol_info (symbol, ret);
 795 }
 796
 797 /* Make an empty symbol. */
 798
 799 static asymbol *
 800 bfd_plugin_make_empty_symbol (bfd *abfd)
 801 {
 802   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
 803   if (new_symbol == NULL)
 804     return new_symbol;
 805   new_symbol->the_bfd = abfd;
 806   return new_symbol;
 807 }
 808
 809 static int
 810 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
 811                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
 812 {
 813   BFD_ASSERT (0);
 814   return 0;
 815 }
 816
 817 const bfd_target plugin_vec =
 818 {
 819   "plugin",                     /* Name.  */
 820   bfd_target_unknown_flavour,
 821   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
 822   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
 823   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 824    HAS_LINENO | HAS_DEBUG |
 825    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
 826   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 827    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
 828   0,                            /* symbol_leading_char.  */
 829   '/',                          /* ar_pad_char.  */
 830   15,                           /* ar_max_namelen.  */
 831   255,                          /* match priority.  */
 832   TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols.  */
 833
 834   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 835   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 836   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
 837   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
 838   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
 839   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
 840
 841   {                             /* bfd_check_format.  */
 842     _bfd_dummy_target,
 843     bfd_plugin_object_p,
 844     bfd_generic_archive_p,
 845     _bfd_dummy_target
 846   },
 847   {                             /* bfd_set_format.  */
 848     _bfd_bool_bfd_false_error,
 849     _bfd_bool_bfd_false_error,
 850     _bfd_generic_mkarchive,
 851     _bfd_bool_bfd_false_error,
 852   },
 853   {                             /* bfd_write_contents.  */
 854     _bfd_bool_bfd_false_error,
 855     _bfd_bool_bfd_false_error,
 856     _bfd_write_archive_contents,
 857     _bfd_bool_bfd_false_error,
 858   },
 859
 860   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
 861   BFD_JUMP_TABLE_COPY (bfd_plugin),
 862   BFD_JUMP_TABLE_CORE (bfd_plugin),
 863 #ifdef USE_64_BIT_ARCHIVE
 864   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
 865 #else
 866   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
 867 #endif
 868   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
 869   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 870   BFD_JUMP_TABLE_WRITE (bfd_plugin),
 871   BFD_JUMP_TABLE_LINK (bfd_plugin),
 872   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 873
 874   NULL,
 875
 876   NULL                          /* backend_data.  */
 877 };
 878 #endif /* BFD_SUPPORTS_PLUGINS */