bfd/plugin.c

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