bfd/plugin.c

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