bfd/plugin.c

   1 /* Plugin support for BFD.
   2    Copyright (C) 2009-2020 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_bfd_free_cached_info               _bfd_generic_bfd_free_cached_info
  73 #define bfd_plugin_new_section_hook                   _bfd_generic_new_section_hook
  74 #define bfd_plugin_get_section_contents               _bfd_generic_get_section_contents
  75 #define bfd_plugin_get_section_contents_in_window     _bfd_generic_get_section_contents_in_window
  76 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  77 #define bfd_plugin_bfd_merge_private_bfd_data         _bfd_generic_bfd_merge_private_bfd_data
  78 #define bfd_plugin_bfd_copy_private_header_data       _bfd_generic_bfd_copy_private_header_data
  79 #define bfd_plugin_bfd_set_private_flags              _bfd_generic_bfd_set_private_flags
  80 #define bfd_plugin_core_file_matches_executable_p     generic_core_file_matches_executable_p
  81 #define bfd_plugin_bfd_is_local_label_name            _bfd_nosymbols_bfd_is_local_label_name
  82 #define bfd_plugin_bfd_is_target_special_symbol       _bfd_bool_bfd_asymbol_false
  83 #define bfd_plugin_get_lineno                         _bfd_nosymbols_get_lineno
  84 #define bfd_plugin_find_nearest_line                  _bfd_nosymbols_find_nearest_line
  85 #define bfd_plugin_find_line                          _bfd_nosymbols_find_line
  86 #define bfd_plugin_find_inliner_info                  _bfd_nosymbols_find_inliner_info
  87 #define bfd_plugin_get_symbol_version_string          _bfd_nosymbols_get_symbol_version_string
  88 #define bfd_plugin_bfd_make_debug_symbol              _bfd_nosymbols_bfd_make_debug_symbol
  89 #define bfd_plugin_read_minisymbols                   _bfd_generic_read_minisymbols
  90 #define bfd_plugin_minisymbol_to_symbol               _bfd_generic_minisymbol_to_symbol
  91 #define bfd_plugin_set_arch_mach                      bfd_default_set_arch_mach
  92 #define bfd_plugin_set_section_contents               _bfd_generic_set_section_contents
  93 #define bfd_plugin_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
  94 #define bfd_plugin_bfd_relax_section                  bfd_generic_relax_section
  95 #define bfd_plugin_bfd_link_hash_table_create         _bfd_generic_link_hash_table_create
  96 #define bfd_plugin_bfd_link_add_symbols               _bfd_generic_link_add_symbols
  97 #define bfd_plugin_bfd_link_just_syms                 _bfd_generic_link_just_syms
  98 #define bfd_plugin_bfd_final_link                     _bfd_generic_final_link
  99 #define bfd_plugin_bfd_link_split_section             _bfd_generic_link_split_section
 100 #define bfd_plugin_bfd_gc_sections                    bfd_generic_gc_sections
 101 #define bfd_plugin_bfd_lookup_section_flags           bfd_generic_lookup_section_flags
 102 #define bfd_plugin_bfd_merge_sections                 bfd_generic_merge_sections
 103 #define bfd_plugin_bfd_is_group_section               bfd_generic_is_group_section
 104 #define bfd_plugin_bfd_group_name                     bfd_generic_group_name
 105 #define bfd_plugin_bfd_discard_group                  bfd_generic_discard_group
 106 #define bfd_plugin_section_already_linked             _bfd_generic_section_already_linked
 107 #define bfd_plugin_bfd_define_common_symbol           bfd_generic_define_common_symbol
 108 #define bfd_plugin_bfd_link_hide_symbol               _bfd_generic_link_hide_symbol
 109 #define bfd_plugin_bfd_define_start_stop              bfd_generic_define_start_stop
 110 #define bfd_plugin_bfd_copy_link_hash_symbol_type     _bfd_generic_copy_link_hash_symbol_type
 111 #define bfd_plugin_bfd_link_check_relocs              _bfd_generic_link_check_relocs
 112
 113 static enum ld_plugin_status
 114 message (int level ATTRIBUTE_UNUSED,
 115          const char * format, ...)
 116 {
 117   va_list args;
 118   va_start (args, format);
 119   printf ("bfd plugin: ");
 120   vprintf (format, args);
 121   putchar ('\n');
 122   va_end (args);
 123   return LDPS_OK;
 124 }
 125
 126 struct plugin_list_entry
 127 {
 128   /* These must be initialized for each IR object with LTO wrapper.  */
 129   void *handle;
 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   char *resolution_file;
 134   char *resolution_option;
 135   bfd *real_bfd;
 136   long real_nsyms;
 137   asymbol **real_syms;
 138   int lto_nsyms;
 139   const struct ld_plugin_symbol *lto_syms;
 140
 141   struct plugin_list_entry *next;
 142
 143   /* These can be reused for all IR objects.  */
 144   const char *plugin_name;
 145   char *gcc;
 146   char *lto_wrapper;
 147   char *gcc_env;
 148   bfd_boolean initialized;
 149 };
 150
 151 /* Use GCC LTO wrapper to covert LTO IR object to the real object.  */
 152
 153 static bfd_boolean
 154 get_lto_wrapper (struct plugin_list_entry *plugin)
 155 {
 156   struct stat st;
 157   const char *real_name;
 158   const char *base_name;
 159   size_t length;
 160   const char *target_start = NULL;
 161   const char *target_end = NULL;
 162   size_t target_length = 0;
 163   char *gcc_name;
 164   char *wrapper_name;
 165   char *p;
 166   char dir_seperator = '\0';
 167   char *resolution_file;
 168
 169   if (plugin->initialized)
 170     {
 171       if (plugin->lto_wrapper)
 172         {
 173           resolution_file = make_temp_file (".res");
 174           if (resolution_file)
 175             {
 176               plugin->resolution_file = resolution_file;
 177               plugin->resolution_option = concat ("-fresolution=",
 178                                                   resolution_file, NULL);
 179               return TRUE;
 180             }
 181           else
 182             {
 183               /* Something is wrong.  Give up.  */
 184               free (plugin->gcc);
 185               free (plugin->lto_wrapper);
 186               free (plugin->gcc_env);
 187               plugin->gcc = NULL;
 188               plugin->gcc_env = NULL;
 189               plugin->lto_wrapper = NULL;
 190             }
 191         }
 192
 193       return FALSE;
 194     }
 195
 196   plugin->initialized = TRUE;
 197
 198   /* Check for PREFIX/libexec/gcc/TARGET/VERSION/liblto_plugin.so.  */
 199   real_name = lrealpath (plugin->plugin_name);
 200   base_name = lbasename (real_name);
 201
 202   /* The directory length in plugin pathname.  */
 203   length = base_name - real_name;
 204
 205   /* Skip if there is no PREFIX.  */
 206   if (!length)
 207     return FALSE;
 208
 209   p = (char *) real_name + length - 1;
 210   if (IS_DIR_SEPARATOR (*p))
 211     {
 212       int level = 0;
 213       for (; p != real_name; p--)
 214         if (IS_DIR_SEPARATOR (*p))
 215           {
 216             level++;
 217             if (level == 2)
 218               target_end = p;
 219             else if (level == 3)
 220               {
 221                 target_start = p + 1;
 222                 target_length = target_end - target_start;
 223               }
 224             else if (level == 5)
 225               {
 226                 dir_seperator = *p;
 227                 break;
 228               }
 229           }
 230     }
 231
 232   /* Skip if there is no TARGET nor PREFIX.  */
 233   if (!target_length || !dir_seperator)
 234     return FALSE;
 235
 236 #ifdef HAVE_EXECUTABLE_SUFFIX
 237 # define GCC_EXECUTABLE         "gcc" EXECUTABLE_SUFFIX
 238 # define LTO_WRAPPER_EXECUTABLE "lto-wrapper" EXECUTABLE_SUFFIX
 239 #else
 240 # define GCC_EXECUTABLE         "gcc"
 241 # define LTO_WRAPPER_EXECUTABLE "lto-wrapper"
 242 #endif
 243   gcc_name = bfd_malloc (length + target_length
 244                          + sizeof (GCC_EXECUTABLE));
 245   if (gcc_name == NULL)
 246     return FALSE;
 247   memcpy (gcc_name, real_name, length);
 248
 249   /* Get PREFIX/bin/.  */
 250   p += gcc_name - real_name;
 251   memcpy (p + 1, "bin", 3);
 252   p[4] = dir_seperator;
 253
 254   /* Try PREFIX/bin/TARGET-gcc first.  */
 255   memcpy (p + 5, target_start, target_length);
 256   p[5 + target_length] = '-';
 257   memcpy (p + 5 + target_length + 1, GCC_EXECUTABLE,
 258           sizeof (GCC_EXECUTABLE));
 259   if (stat (gcc_name, &st) != 0 || !S_ISREG (st.st_mode))
 260     {
 261       /* Then try PREFIX/bin/gcc.  */
 262       memcpy (p + 5, GCC_EXECUTABLE, sizeof (GCC_EXECUTABLE));
 263       if (stat (gcc_name, &st) != 0 || !S_ISREG (st.st_mode))
 264         {
 265           free (gcc_name);
 266           return FALSE;
 267         }
 268     }
 269
 270   /* lto-wrapper should be in the same directory with LTO plugin.  */
 271   wrapper_name = bfd_malloc (length + sizeof (LTO_WRAPPER_EXECUTABLE));
 272   if (wrapper_name == NULL)
 273     {
 274       free (gcc_name);
 275       return FALSE;
 276     }
 277   memcpy (wrapper_name, real_name, length);
 278   memcpy (wrapper_name + length, LTO_WRAPPER_EXECUTABLE,
 279           sizeof (LTO_WRAPPER_EXECUTABLE));
 280   if (stat (wrapper_name, &st) == 0 && S_ISREG (st.st_mode))
 281     {
 282       resolution_file = make_temp_file (".res");
 283       if (resolution_file)
 284         {
 285           plugin->gcc = gcc_name;
 286           plugin->lto_wrapper = wrapper_name;
 287           plugin->gcc_env = concat ("COLLECT_GCC=", gcc_name, NULL);
 288           plugin->resolution_file = resolution_file;
 289           plugin->resolution_option = concat ("-fresolution=",
 290                                               resolution_file, NULL);
 291           return TRUE;
 292         }
 293     }
 294
 295   free (gcc_name);
 296   free (wrapper_name);
 297   return FALSE;
 298 }
 299
 300 /* Set environment variables for GCC LTO wrapper to covert LTO IR
 301    object to the real object.  */
 302
 303 static int
 304 setup_lto_wrapper_env (struct plugin_list_entry *plugin)
 305 {
 306   return (putenv (plugin->gcc_env)
 307           || putenv ("COLLECT_GCC_OPTIONS="));
 308 }
 309
 310 static struct plugin_list_entry *plugin_list = NULL;
 311 static struct plugin_list_entry *current_plugin = NULL;
 312
 313 /* Register a claim-file handler. */
 314
 315 static enum ld_plugin_status
 316 register_claim_file (ld_plugin_claim_file_handler handler)
 317 {
 318   current_plugin->claim_file = handler;
 319   return LDPS_OK;
 320 }
 321
 322 /* Register an all-symbols-read handler.  */
 323
 324 static enum ld_plugin_status
 325 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
 326 {
 327   current_plugin->all_symbols_read = handler;
 328   return LDPS_OK;
 329 }
 330
 331 /* Register a cleanup handler.  */
 332
 333 static enum ld_plugin_status
 334 register_cleanup (ld_plugin_all_symbols_read_handler handler)
 335 {
 336   current_plugin->cleanup_handler = handler;
 337   return LDPS_OK;
 338 }
 339
 340 /* Get the symbol resolution info for a plugin-claimed input file.  */
 341
 342 static enum ld_plugin_status
 343 get_symbols (const void *handle ATTRIBUTE_UNUSED, int nsyms,
 344              struct ld_plugin_symbol *syms)
 345 {
 346   if (syms)
 347     {
 348       int n;
 349       for (n = 0; n < nsyms; n++)
 350         {
 351           switch (syms[n].def)
 352             {
 353             default:
 354               BFD_ASSERT (0);
 355               break;
 356             case LDPK_UNDEF:
 357             case LDPK_WEAKUNDEF:
 358               syms[n].resolution = LDPR_UNDEF;
 359               break;
 360             case LDPK_DEF:
 361             case LDPK_WEAKDEF:
 362             case LDPK_COMMON:
 363               /* Tell plugin that LTO symbol has references from regular
 364                  object code. */
 365               syms[n].resolution  = LDPR_PREVAILING_DEF;
 366               break;
 367             }
 368       }
 369     }
 370
 371   return LDPS_OK;
 372 }
 373
 374 /* Add a new (real) input file generated by a plugin.  */
 375
 376 static enum ld_plugin_status
 377 add_input_file (const char *pathname)
 378 {
 379   /* Get symbols from the real LTO object.  */
 380   char **matching;
 381   long real_symsize;
 382   long real_nsyms;
 383   asymbol **real_syms;
 384   int lto_nsyms;
 385   bfd_boolean lto_symbol_found = FALSE;
 386   const struct ld_plugin_symbol *lto_syms;
 387   bfd *rbfd;
 388   int i, j;
 389
 390   rbfd = bfd_openr (pathname, NULL);
 391   if (!bfd_check_format_matches (rbfd, bfd_object, &matching))
 392     BFD_ASSERT (0);
 393
 394   real_symsize = bfd_get_symtab_upper_bound (rbfd);
 395   if (real_symsize < 0)
 396     BFD_ASSERT (0);
 397
 398   real_syms = (asymbol **) bfd_malloc (real_symsize);
 399   if (real_syms)
 400     {
 401       real_nsyms = bfd_canonicalize_symtab (rbfd, real_syms);
 402       if (real_nsyms < 0)
 403         BFD_ASSERT (0);
 404
 405       /* NB: LTO plugin may generate more than one real object from one
 406          LTO IR object.  We use the one which contains LTO symbols.  */
 407       lto_syms = current_plugin->lto_syms;
 408       lto_nsyms = current_plugin->lto_nsyms;
 409       for (i = 0; i < lto_nsyms; i++)
 410         for (j = 0; j < real_nsyms; j++)
 411           if (real_syms[j]->name
 412               && strcmp (lto_syms[i].name, real_syms[j]->name) == 0)
 413             {
 414               lto_symbol_found = TRUE;
 415               break;
 416             }
 417     }
 418
 419   if (lto_symbol_found)
 420     {
 421       current_plugin->real_nsyms = real_nsyms;
 422       current_plugin->real_syms = real_syms;
 423       /* NB: We can't close RBFD which own the real symbol info.  */
 424       current_plugin->real_bfd = rbfd;
 425     }
 426   else
 427     {
 428       bfd_close (rbfd);
 429       free (real_syms);
 430     }
 431
 432   return LDPS_OK;
 433 }
 434
 435 static enum ld_plugin_status
 436 add_symbols (void * handle,
 437              int nsyms,
 438              const struct ld_plugin_symbol * syms)
 439 {
 440   bfd *abfd = handle;
 441   struct plugin_data_struct *plugin_data =
 442     bfd_alloc (abfd, sizeof (plugin_data_struct));
 443
 444   if (plugin_data)
 445     {
 446       struct ld_plugin_symbol *sym_info;
 447       char *strtab;
 448       size_t sym_info_size, name_length;
 449       int i;
 450
 451       abfd->tdata.plugin_data = plugin_data;
 452
 453       /* NB: LTO symbols are owned by LTO plugin.  Create a copy so
 454          that we can use it in bfd_plugin_canonicalize_symtab.  */
 455       sym_info_size = nsyms * sizeof (*syms);
 456
 457       /* Allocate a string table  */
 458       for (i = 0; i < nsyms; i++)
 459         sym_info_size += strlen (syms[i].name) + 1;
 460
 461       sym_info = bfd_alloc (abfd, sym_info_size);
 462       if (sym_info)
 463         {
 464           /* Copy symbol table.  */
 465           memcpy (sym_info, syms, nsyms * sizeof (*syms));
 466
 467           /* Copy symbol names in symbol table.  */
 468           strtab = (char *) (sym_info + nsyms);
 469           for (i = 0; i < nsyms; i++)
 470             {
 471               name_length = strlen (syms[i].name);
 472               memcpy (strtab, syms[i].name, name_length + 1);
 473               sym_info[i].name = strtab;
 474               strtab += name_length + 1;
 475             }
 476
 477           plugin_data->nsyms = nsyms;
 478           plugin_data->syms = sym_info;
 479
 480           current_plugin->lto_nsyms = nsyms;
 481           current_plugin->lto_syms = sym_info;
 482         }
 483     }
 484
 485   if (nsyms != 0)
 486     abfd->flags |= HAS_SYMS;
 487
 488   return LDPS_OK;
 489 }
 490
 491 static const char *plugin_program_name;
 492
 493 void
 494 bfd_plugin_set_program_name (const char *program_name)
 495 {
 496   plugin_program_name = program_name;
 497 }
 498
 499 int
 500 bfd_plugin_open_input (bfd *ibfd, struct ld_plugin_input_file *file)
 501 {
 502   bfd *iobfd;
 503
 504   iobfd = ibfd;
 505   while (iobfd->my_archive
 506          && !bfd_is_thin_archive (iobfd->my_archive))
 507     iobfd = iobfd->my_archive;
 508   file->name = iobfd->filename;
 509
 510   if (!iobfd->iostream && !bfd_open_file (iobfd))
 511     return 0;
 512
 513   /* The plugin API expects that the file descriptor won't be closed
 514      and reused as done by the bfd file cache.  So open it again.
 515      dup isn't good enough.  plugin IO uses lseek/read while BFD uses
 516      fseek/fread.  It isn't wise to mix the unistd and stdio calls on
 517      the same underlying file descriptor.  */
 518   file->fd = open (file->name, O_RDONLY | O_BINARY);
 519   if (file->fd < 0)
 520     return 0;
 521
 522   if (iobfd == ibfd)
 523     {
 524       struct stat stat_buf;
 525
 526       if (fstat (file->fd, &stat_buf))
 527         {
 528           close(file->fd);
 529           return 0;
 530         }
 531
 532       file->offset = 0;
 533       file->filesize = stat_buf.st_size;
 534     }
 535   else
 536     {
 537       file->offset = ibfd->origin;
 538       file->filesize = arelt_size (ibfd);
 539     }
 540   return 1;
 541 }
 542
 543 static int
 544 try_claim (bfd *abfd)
 545 {
 546   int claimed = 0;
 547   struct ld_plugin_input_file file;
 548
 549   file.handle = abfd;
 550   if (!bfd_plugin_open_input (abfd, &file))
 551     return 0;
 552   if (current_plugin->claim_file)
 553     {
 554       current_plugin->claim_file (&file, &claimed);
 555       if (claimed)
 556         {
 557           if (current_plugin->all_symbols_read)
 558             {
 559               struct plugin_data_struct *plugin_data
 560                 = abfd->tdata.plugin_data;
 561               if (plugin_data)
 562                 {
 563                   /* Get real symbols from LTO wrapper.  */
 564                   current_plugin->all_symbols_read ();
 565
 566                   /* Copy real symbols to plugin_data.  */
 567                   plugin_data->real_bfd = current_plugin->real_bfd;
 568                   plugin_data->real_nsyms = current_plugin->real_nsyms;
 569                   plugin_data->real_syms = current_plugin->real_syms;
 570
 571                   /* Clean up LTO plugin.  */
 572                   if (current_plugin->cleanup_handler)
 573                     current_plugin->cleanup_handler ();
 574                 }
 575             }
 576         }
 577
 578       if (current_plugin->lto_wrapper)
 579         {
 580           /* Clean up for LTO wrapper.  */
 581           unlink (current_plugin->resolution_file);
 582           free (current_plugin->resolution_option);
 583         }
 584     }
 585   close (file.fd);
 586   return claimed;
 587 }
 588
 589 static int
 590 try_load_plugin (const char *pname, bfd *abfd, int *has_plugin_p)
 591 {
 592   void *plugin_handle = NULL;
 593   struct ld_plugin_tv tv[12];
 594   int i;
 595   ld_plugin_onload onload;
 596   enum ld_plugin_status status;
 597   struct plugin_list_entry *plugin_list_iter;
 598
 599   *has_plugin_p = 0;
 600
 601   /* NB: Each object is inddependent.  Reuse the previous plugin from
 602      the last LTO wrapper run will lead to wrong LTO data.  */
 603   if (current_plugin
 604       && current_plugin->handle
 605       && current_plugin->lto_wrapper
 606       && strcmp (current_plugin->plugin_name, pname) == 0)
 607     {
 608       dlclose (current_plugin->handle);
 609       memset (current_plugin, 0,
 610               offsetof (struct plugin_list_entry, next));
 611     }
 612
 613   plugin_handle = dlopen (pname, RTLD_NOW);
 614   if (!plugin_handle)
 615     {
 616       _bfd_error_handler ("%s\n", dlerror ());
 617       return 0;
 618     }
 619
 620   for (plugin_list_iter = plugin_list;
 621        plugin_list_iter;
 622        plugin_list_iter = plugin_list_iter->next)
 623     {
 624       if (plugin_handle == plugin_list_iter->handle)
 625         {
 626           dlclose (plugin_handle);
 627           if (!plugin_list_iter->claim_file)
 628             return 0;
 629
 630           register_claim_file (plugin_list_iter->claim_file);
 631           current_plugin = plugin_list_iter;
 632           goto have_claim_file;
 633         }
 634       else if (plugin_list_iter->lto_wrapper
 635                && strcmp (plugin_list_iter->plugin_name, pname) == 0)
 636         goto have_lto_wrapper;
 637     }
 638
 639   plugin_list_iter = bfd_malloc (sizeof *plugin_list_iter);
 640   if (plugin_list_iter == NULL)
 641     return 0;
 642   memset (plugin_list_iter, 0, sizeof (*plugin_list_iter));
 643   plugin_list_iter->plugin_name = pname;
 644   plugin_list_iter->next = plugin_list;
 645   plugin_list = plugin_list_iter;
 646
 647 have_lto_wrapper:
 648   plugin_list_iter->handle = plugin_handle;
 649
 650   onload = dlsym (plugin_handle, "onload");
 651   if (!onload)
 652     return 0;
 653
 654   i = 0;
 655   tv[i].tv_tag = LDPT_MESSAGE;
 656   tv[i].tv_u.tv_message = message;
 657
 658   ++i;
 659   tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK;
 660   tv[i].tv_u.tv_register_claim_file = register_claim_file;
 661
 662   ++i;
 663   tv[i].tv_tag = LDPT_ADD_SYMBOLS;
 664   tv[i].tv_u.tv_add_symbols = add_symbols;
 665
 666   if (get_lto_wrapper (plugin_list_iter))
 667     {
 668       ++i;
 669       tv[i].tv_tag = LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK;
 670       tv[i].tv_u.tv_register_all_symbols_read = register_all_symbols_read;
 671
 672       ++i;
 673       tv[i].tv_tag = LDPT_REGISTER_CLEANUP_HOOK;
 674       tv[i].tv_u.tv_register_cleanup = register_cleanup;
 675
 676       ++i;
 677       tv[i].tv_tag = LDPT_GET_SYMBOLS;
 678       tv[i].tv_u.tv_get_symbols = get_symbols;
 679
 680       ++i;
 681       tv[i].tv_tag = LDPT_GET_SYMBOLS_V2;
 682       tv[i].tv_u.tv_get_symbols = get_symbols;
 683
 684       ++i;
 685       tv[i].tv_tag = LDPT_OPTION;
 686       tv[i].tv_u.tv_string = plugin_list_iter->lto_wrapper;
 687
 688       ++i;
 689       tv[i].tv_tag = LDPT_OPTION;
 690       tv[i].tv_u.tv_string = plugin_list_iter->resolution_option;
 691
 692       ++i;
 693       tv[i].tv_tag = LDPT_LINKER_OUTPUT;
 694       tv[i].tv_u.tv_val = LDPO_EXEC;
 695
 696       ++i;
 697       tv[i].tv_tag = LDPT_ADD_INPUT_FILE;
 698       tv[i].tv_u.tv_add_input_file = add_input_file;
 699     }
 700
 701   ++i;
 702   tv[i].tv_tag = LDPT_NULL;
 703   tv[i].tv_u.tv_val = 0;
 704
 705   current_plugin = plugin_list_iter;
 706
 707   /* LTO plugin will call handler hooks to set up plugin handlers.  */
 708   status = (*onload)(tv);
 709
 710   if (status != LDPS_OK)
 711     return 0;
 712
 713   if (current_plugin->lto_wrapper
 714       && setup_lto_wrapper_env (current_plugin))
 715     return 0;
 716
 717 have_claim_file:
 718   *has_plugin_p = 1;
 719
 720   abfd->plugin_format = bfd_plugin_no;
 721
 722   if (!current_plugin->claim_file)
 723     return 0;
 724
 725   if (!try_claim (abfd))
 726     return 0;
 727
 728   abfd->plugin_format = bfd_plugin_yes;
 729   return 1;
 730 }
 731
 732 /* There may be plugin libraries in lib/bfd-plugins.  */
 733
 734 static int has_plugin = -1;
 735
 736 static const bfd_target *(*ld_plugin_object_p) (bfd *);
 737
 738 static const char *plugin_name;
 739
 740 void
 741 bfd_plugin_set_plugin (const char *p)
 742 {
 743   plugin_name = p;
 744   has_plugin = p != NULL;
 745 }
 746
 747 /* Return TRUE if a plugin library is used.  */
 748
 749 bfd_boolean
 750 bfd_plugin_specified_p (void)
 751 {
 752   return has_plugin > 0;
 753 }
 754
 755 /* Return TRUE if ABFD can be claimed by linker LTO plugin.  */
 756
 757 bfd_boolean
 758 bfd_link_plugin_object_p (bfd *abfd)
 759 {
 760   if (ld_plugin_object_p)
 761     return ld_plugin_object_p (abfd) != NULL;
 762   return FALSE;
 763 }
 764
 765 extern const bfd_target plugin_vec;
 766
 767 /* Return TRUE if TARGET is a pointer to plugin_vec.  */
 768
 769 bfd_boolean
 770 bfd_plugin_target_p (const bfd_target *target)
 771 {
 772   return target == &plugin_vec;
 773 }
 774
 775 /* Register OBJECT_P to be used by bfd_plugin_object_p.  */
 776
 777 void
 778 register_ld_plugin_object_p (const bfd_target *(*object_p) (bfd *))
 779 {
 780   ld_plugin_object_p = object_p;
 781 }
 782
 783 static int
 784 load_plugin (bfd *abfd)
 785 {
 786   /* The intent was to search ${libdir}/bfd-plugins for plugins, but
 787      unfortunately the original implementation wasn't precisely that
 788      when configuring binutils using --libdir.  Search in the proper
 789      path first, then the old one for backwards compatibility.  */
 790   static const char *path[]
 791     = { LIBDIR "/bfd-plugins", BINDIR "/../lib/bfd-plugins" };
 792   struct stat last_st;
 793   int found = 0;
 794   unsigned int i;
 795
 796   if (!has_plugin)
 797     return found;
 798
 799   if (plugin_name)
 800     return try_load_plugin (plugin_name, abfd, &has_plugin);
 801
 802   if (plugin_program_name == NULL)
 803     return found;
 804
 805   /* Try not to search the same dir twice, by looking at st_dev and
 806      st_ino for the dir.  If we are on a file system that always sets
 807      st_ino to zero or the actual st_ino is zero we might waste some
 808      time, but that doesn't matter too much.  */
 809   last_st.st_dev = 0;
 810   last_st.st_ino = 0;
 811   for (i = 0; i < sizeof (path) / sizeof (path[0]); i++)
 812     {
 813       char *plugin_dir = make_relative_prefix (plugin_program_name,
 814                                                BINDIR,
 815                                                path[i]);
 816       if (plugin_dir)
 817         {
 818           struct stat st;
 819           DIR *d;
 820
 821           if (stat (plugin_dir, &st) == 0
 822               && S_ISDIR (st.st_mode)
 823               && !(last_st.st_dev == st.st_dev
 824                    && last_st.st_ino == st.st_ino
 825                    && st.st_ino != 0)
 826               && (d = opendir (plugin_dir)) != NULL)
 827             {
 828               struct dirent *ent;
 829
 830               last_st.st_dev = st.st_dev;
 831               last_st.st_ino = st.st_ino;
 832               while ((ent = readdir (d)) != NULL)
 833                 {
 834                   char *full_name;
 835
 836                   full_name = concat (plugin_dir, "/", ent->d_name, NULL);
 837                   if (stat (full_name, &st) == 0 && S_ISREG (st.st_mode))
 838                     {
 839                       int valid_plugin;
 840
 841                       found = try_load_plugin (full_name, abfd, &valid_plugin);
 842                       if (has_plugin <= 0)
 843                         has_plugin = valid_plugin;
 844                     }
 845                   free (full_name);
 846                   if (found)
 847                     break;
 848                 }
 849               closedir (d);
 850             }
 851           free (plugin_dir);
 852         }
 853       if (found)
 854         break;
 855     }
 856
 857   return found;
 858 }
 859
 860
 861 static const bfd_target *
 862 bfd_plugin_object_p (bfd *abfd)
 863 {
 864   if (ld_plugin_object_p)
 865     return ld_plugin_object_p (abfd);
 866
 867   if (abfd->plugin_format == bfd_plugin_unknown && !load_plugin (abfd))
 868     return NULL;
 869
 870   return abfd->plugin_format == bfd_plugin_yes ? abfd->xvec : NULL;
 871 }
 872
 873 /* Copy any private info we understand from the input bfd
 874    to the output bfd.  */
 875
 876 static bfd_boolean
 877 bfd_plugin_bfd_copy_private_bfd_data (bfd *ibfd ATTRIBUTE_UNUSED,
 878                                       bfd *obfd ATTRIBUTE_UNUSED)
 879 {
 880   BFD_ASSERT (0);
 881   return TRUE;
 882 }
 883
 884 /* Copy any private info we understand from the input section
 885    to the output section.  */
 886
 887 static bfd_boolean
 888 bfd_plugin_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
 889                                           asection *isection ATTRIBUTE_UNUSED,
 890                                           bfd *obfd ATTRIBUTE_UNUSED,
 891                                           asection *osection ATTRIBUTE_UNUSED)
 892 {
 893   BFD_ASSERT (0);
 894   return TRUE;
 895 }
 896
 897 /* Copy any private info we understand from the input symbol
 898    to the output symbol.  */
 899
 900 static bfd_boolean
 901 bfd_plugin_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
 902                                          asymbol *isymbol ATTRIBUTE_UNUSED,
 903                                          bfd *obfd ATTRIBUTE_UNUSED,
 904                                          asymbol *osymbol ATTRIBUTE_UNUSED)
 905 {
 906   BFD_ASSERT (0);
 907   return TRUE;
 908 }
 909
 910 static bfd_boolean
 911 bfd_plugin_bfd_print_private_bfd_data (bfd *abfd ATTRIBUTE_UNUSED, PTR ptr ATTRIBUTE_UNUSED)
 912 {
 913   BFD_ASSERT (0);
 914   return TRUE;
 915 }
 916
 917 static char *
 918 bfd_plugin_core_file_failing_command (bfd *abfd ATTRIBUTE_UNUSED)
 919 {
 920   BFD_ASSERT (0);
 921   return NULL;
 922 }
 923
 924 static int
 925 bfd_plugin_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
 926 {
 927   BFD_ASSERT (0);
 928   return 0;
 929 }
 930
 931 static int
 932 bfd_plugin_core_file_pid (bfd *abfd ATTRIBUTE_UNUSED)
 933 {
 934   BFD_ASSERT (0);
 935   return 0;
 936 }
 937
 938 static long
 939 bfd_plugin_get_symtab_upper_bound (bfd *abfd)
 940 {
 941   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 942   long nsyms = plugin_data->nsyms;
 943
 944   BFD_ASSERT (nsyms >= 0);
 945
 946   return ((nsyms + 1) * sizeof (asymbol *));
 947 }
 948
 949 static flagword
 950 convert_flags (const struct ld_plugin_symbol *sym)
 951 {
 952  switch (sym->def)
 953    {
 954    case LDPK_DEF:
 955    case LDPK_COMMON:
 956    case LDPK_UNDEF:
 957      return BSF_GLOBAL;
 958
 959    case LDPK_WEAKUNDEF:
 960    case LDPK_WEAKDEF:
 961      return BSF_GLOBAL | BSF_WEAK;
 962
 963    default:
 964      BFD_ASSERT (0);
 965      return 0;
 966    }
 967 }
 968
 969 static long
 970 bfd_plugin_canonicalize_symtab (bfd *abfd,
 971                                 asymbol **alocation)
 972 {
 973   struct plugin_data_struct *plugin_data = abfd->tdata.plugin_data;
 974   long nsyms = plugin_data->nsyms;
 975   const struct ld_plugin_symbol *syms = plugin_data->syms;
 976   static asection fake_section
 977     = BFD_FAKE_SECTION (fake_section, NULL, "plug", 0,
 978                         SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS);
 979   static asection fake_common_section
 980     = BFD_FAKE_SECTION (fake_common_section, NULL, "plug", 0, SEC_IS_COMMON);
 981   int i, j;
 982   long real_nsyms;
 983   asymbol **real_syms;
 984
 985   real_syms = plugin_data->real_syms;
 986   if (real_syms)
 987     real_nsyms = plugin_data->real_nsyms;
 988   else
 989     real_nsyms = 0;
 990
 991   for (i = 0; i < nsyms; i++)
 992     {
 993       asymbol *s = bfd_alloc (abfd, sizeof (asymbol));
 994
 995       BFD_ASSERT (s);
 996       alocation[i] = s;
 997
 998       s->the_bfd = abfd;
 999       s->name = syms[i].name;
1000       s->value = 0;
1001       s->flags = convert_flags (&syms[i]);
1002       switch (syms[i].def)
1003         {
1004         case LDPK_COMMON:
1005           s->section = &fake_common_section;
1006           break;
1007         case LDPK_UNDEF:
1008         case LDPK_WEAKUNDEF:
1009           s->section = bfd_und_section_ptr;
1010           break;
1011         case LDPK_DEF:
1012         case LDPK_WEAKDEF:
1013           s->section = &fake_section;
1014           if (real_nsyms)
1015             /* Use real LTO symbols if possible.  */
1016             for (j = 0; j < real_nsyms; j++)
1017               if (real_syms[j]->name
1018                   && strcmp (syms[i].name, real_syms[j]->name) == 0)
1019                 {
1020                   s->section = real_syms[j]->section;
1021                   break;
1022                 }
1023           break;
1024         default:
1025           BFD_ASSERT (0);
1026         }
1027
1028       s->udata.p = (void *) &syms[i];
1029     }
1030
1031   return nsyms;
1032 }
1033
1034 static void
1035 bfd_plugin_print_symbol (bfd *abfd ATTRIBUTE_UNUSED,
1036                          PTR afile ATTRIBUTE_UNUSED,
1037                          asymbol *symbol ATTRIBUTE_UNUSED,
1038                          bfd_print_symbol_type how ATTRIBUTE_UNUSED)
1039 {
1040   BFD_ASSERT (0);
1041 }
1042
1043 static void
1044 bfd_plugin_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1045                             asymbol *symbol,
1046                             symbol_info *ret)
1047 {
1048   bfd_symbol_info (symbol, ret);
1049 }
1050
1051 /* Make an empty symbol. */
1052
1053 static asymbol *
1054 bfd_plugin_make_empty_symbol (bfd *abfd)
1055 {
1056   asymbol *new_symbol = bfd_zalloc (abfd, sizeof (asymbol));
1057   if (new_symbol == NULL)
1058     return new_symbol;
1059   new_symbol->the_bfd = abfd;
1060   return new_symbol;
1061 }
1062
1063 static int
1064 bfd_plugin_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
1065                            struct bfd_link_info *info ATTRIBUTE_UNUSED)
1066 {
1067   BFD_ASSERT (0);
1068   return 0;
1069 }
1070
1071 static bfd_boolean
1072 bfd_plugin_close_and_cleanup (bfd *abfd)
1073 {
1074   struct plugin_data_struct *plugin_data;
1075
1076   if (abfd->format != bfd_archive
1077       && (plugin_data = abfd->tdata.plugin_data))
1078     {
1079       if (plugin_data->real_bfd)
1080         bfd_close (plugin_data->real_bfd);
1081
1082       if (plugin_data->real_syms)
1083         free (plugin_data->real_syms);
1084     }
1085
1086   return _bfd_generic_close_and_cleanup (abfd);
1087 }
1088
1089 const bfd_target plugin_vec =
1090 {
1091   "plugin",                     /* Name.  */
1092   bfd_target_unknown_flavour,
1093   BFD_ENDIAN_LITTLE,            /* Target byte order.  */
1094   BFD_ENDIAN_LITTLE,            /* Target headers byte order.  */
1095   (HAS_RELOC | EXEC_P |         /* Object flags.  */
1096    HAS_LINENO | HAS_DEBUG |
1097    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
1098   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
1099    | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* Section flags.  */
1100   0,                            /* symbol_leading_char.  */
1101   '/',                          /* ar_pad_char.  */
1102   15,                           /* ar_max_namelen.  */
1103   255,                          /* match priority.  */
1104
1105   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1106   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1107   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* data */
1108   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1109   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1110   bfd_getl16, bfd_getl_signed_16, bfd_putl16,   /* hdrs */
1111
1112   {                             /* bfd_check_format.  */
1113     _bfd_dummy_target,
1114     bfd_plugin_object_p,
1115     bfd_generic_archive_p,
1116     _bfd_dummy_target
1117   },
1118   {                             /* bfd_set_format.  */
1119     _bfd_bool_bfd_false_error,
1120     _bfd_bool_bfd_false_error,
1121     _bfd_generic_mkarchive,
1122     _bfd_bool_bfd_false_error,
1123   },
1124   {                             /* bfd_write_contents.  */
1125     _bfd_bool_bfd_false_error,
1126     _bfd_bool_bfd_false_error,
1127     _bfd_write_archive_contents,
1128     _bfd_bool_bfd_false_error,
1129   },
1130
1131   BFD_JUMP_TABLE_GENERIC (bfd_plugin),
1132   BFD_JUMP_TABLE_COPY (bfd_plugin),
1133   BFD_JUMP_TABLE_CORE (bfd_plugin),
1134 #ifdef USE_64_BIT_ARCHIVE
1135   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_64_bit),
1136 #else
1137   BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff),
1138 #endif
1139   BFD_JUMP_TABLE_SYMBOLS (bfd_plugin),
1140   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
1141   BFD_JUMP_TABLE_WRITE (bfd_plugin),
1142   BFD_JUMP_TABLE_LINK (bfd_plugin),
1143   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1144
1145   NULL,
1146
1147   NULL                          /* backend_data.  */
1148 };
1149 #endif /* BFD_SUPPORTS_PLUGIN */