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