ld/plugin.c

   1 /* Plugin control for the GNU linker.
   2    Copyright 2010 Free Software Foundation, Inc.
   3
   4    This file is part of the GNU Binutils.
   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 "libiberty.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "bfdver.h"
  26 #include "ld.h"
  27 #include "ldmain.h"
  28 #include "ldmisc.h"
  29 #include "ldexp.h"
  30 #include "ldlang.h"
  31 #include "ldfile.h"
  32 #include "plugin.h"
  33 #include "plugin-api.h"
  34 #include "elf-bfd.h"
  35 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
  36 #include <Windows.h>
  37 #endif
  38
  39 /* The suffix to append to the name of the real (claimed) object file
  40    when generating a dummy BFD to hold the IR symbols sent from the
  41    plugin.  */
  42 #define IRONLY_SUFFIX           ".ironly\004"
  43
  44 /* This is sizeof an array of chars, not sizeof a const char *.  We
  45    also have to avoid inadvertently counting the trailing NUL.  */
  46 #define IRONLY_SUFFIX_LEN       (sizeof (IRONLY_SUFFIX) - 1)
  47
  48 /* Stores a single argument passed to a plugin.  */
  49 typedef struct plugin_arg
  50 {
  51   struct plugin_arg *next;
  52   const char *arg;
  53 } plugin_arg_t;
  54
  55 /* Holds all details of a single plugin.  */
  56 typedef struct plugin
  57 {
  58   /* Next on the list of plugins, or NULL at end of chain.  */
  59   struct plugin *next;
  60   /* The argument string given to --plugin.  */
  61   const char *name;
  62   /* The shared library handle returned by dlopen.  */
  63   void *dlhandle;
  64   /* The list of argument string given to --plugin-opt.  */
  65   plugin_arg_t *args;
  66   /* Number of args in the list, for convenience.  */
  67   size_t n_args;
  68   /* The plugin's event handlers.  */
  69   ld_plugin_claim_file_handler claim_file_handler;
  70   ld_plugin_all_symbols_read_handler all_symbols_read_handler;
  71   ld_plugin_cleanup_handler cleanup_handler;
  72   /* TRUE if the cleanup handlers have been called.  */
  73   bfd_boolean cleanup_done;
  74 } plugin_t;
  75
  76 /* The master list of all plugins.  */
  77 static plugin_t *plugins_list = NULL;
  78
  79 /* We keep a tail pointer for easy linking on the end.  */
  80 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
  81
  82 /* The last plugin added to the list, for receiving args.  */
  83 static plugin_t *last_plugin = NULL;
  84
  85 /* The tail of the arg chain of the last plugin added to the list.  */
  86 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
  87
  88 /* The plugin which is currently having a callback executed.  */
  89 static plugin_t *called_plugin = NULL;
  90
  91 /* Last plugin to cause an error, if any.  */
  92 static const char *error_plugin = NULL;
  93
  94 /* A hash table that records symbols referenced by non-IR files.  Used
  95    at get_symbols time to determine whether any prevailing defs from
  96    IR files are referenced only from other IR files, so tthat we can
  97    we can distinguish the LDPR_PREVAILING_DEF and LDPR_PREVAILING_DEF_IRONLY
  98    cases when establishing symbol resolutions.  */
  99 static struct bfd_hash_table *non_ironly_hash = NULL;
 100
 101 /* Set at all symbols read time, to avoid recursively offering the plugin
 102    its own newly-added input files and libs to claim.  */
 103 static bfd_boolean no_more_claiming = FALSE;
 104
 105 /* If the --allow-multiple-definition command-line option is active, we
 106    have to disable it so that BFD always calls our hook, and simulate the
 107    effect (when not resolving IR vs. real symbols) ourselves by ensuring
 108    TRUE is returned from the hook.  */
 109 static bfd_boolean plugin_cached_allow_multiple_defs = FALSE;
 110
 111 /* List of tags to set in the constant leading part of the tv array. */
 112 static const enum ld_plugin_tag tv_header_tags[] =
 113 {
 114   LDPT_MESSAGE,
 115   LDPT_API_VERSION,
 116   LDPT_GNU_LD_VERSION,
 117   LDPT_LINKER_OUTPUT,
 118   LDPT_OUTPUT_NAME,
 119   LDPT_REGISTER_CLAIM_FILE_HOOK,
 120   LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
 121   LDPT_REGISTER_CLEANUP_HOOK,
 122   LDPT_ADD_SYMBOLS,
 123   LDPT_GET_INPUT_FILE,
 124   LDPT_RELEASE_INPUT_FILE,
 125   LDPT_GET_SYMBOLS,
 126   LDPT_ADD_INPUT_FILE,
 127   LDPT_ADD_INPUT_LIBRARY,
 128   LDPT_SET_EXTRA_LIBRARY_PATH
 129 };
 130
 131 /* How many entries in the constant leading part of the tv array.  */
 132 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
 133
 134 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
 135
 136 #define RTLD_NOW 0      /* Dummy value.  */
 137
 138 static void *
 139 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
 140 {
 141   return LoadLibrary (file);
 142 }
 143
 144 static void *
 145 dlsym (void *handle, const char *name)
 146 {
 147   return GetProcAddress (handle, name);
 148 }
 149
 150 static int
 151 dlclose (void *handle)
 152 {
 153   FreeLibrary (handle);
 154   return 0;
 155 }
 156
 157 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
 158
 159 /* Helper function for exiting with error status.  */
 160 static int
 161 set_plugin_error (const char *plugin)
 162 {
 163   error_plugin = plugin;
 164   return -1;
 165 }
 166
 167 /* Test if an error occurred.  */
 168 static bfd_boolean
 169 plugin_error_p (void)
 170 {
 171   return error_plugin != NULL;
 172 }
 173
 174 /* Return name of plugin which caused an error if any.  */
 175 const char *plugin_error_plugin (void)
 176 {
 177   return error_plugin ? error_plugin : _("<no plugin>");
 178 }
 179
 180 /* Handle -plugin arg: find and load plugin, or return error.  */
 181 int plugin_opt_plugin (const char *plugin)
 182 {
 183   plugin_t *newplug;
 184
 185   newplug = xmalloc (sizeof *newplug);
 186   memset (newplug, 0, sizeof *newplug);
 187   newplug->name = plugin;
 188   newplug->dlhandle = dlopen (plugin, RTLD_NOW);
 189   if (!newplug->dlhandle)
 190     return set_plugin_error (plugin);
 191
 192   /* Chain on end, so when we run list it is in command-line order.  */
 193   *plugins_tail_chain_ptr = newplug;
 194   plugins_tail_chain_ptr = &newplug->next;
 195
 196   /* Record it as current plugin for receiving args.  */
 197   last_plugin = newplug;
 198   last_plugin_args_tail_chain_ptr = &newplug->args;
 199   return 0;
 200 }
 201
 202 /* Accumulate option arguments for last-loaded plugin, or return
 203    error if none.  */
 204 int plugin_opt_plugin_arg (const char *arg)
 205 {
 206   plugin_arg_t *newarg;
 207
 208   if (!last_plugin)
 209     return set_plugin_error (_("<no plugin>"));
 210
 211   newarg = xmalloc (sizeof *newarg);
 212   newarg->arg = arg;
 213   newarg->next = NULL;
 214
 215   /* Chain on end to preserve command-line order.  */
 216   *last_plugin_args_tail_chain_ptr = newarg;
 217   last_plugin_args_tail_chain_ptr = &newarg->next;
 218   last_plugin->n_args++;
 219   return 0;
 220 }
 221
 222 /* Create a dummy BFD.  */
 223 bfd *
 224 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
 225 {
 226   asection *sec;
 227   bfd *abfd;
 228
 229   bfd_use_reserved_id = 1;
 230   abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *)NULL),
 231                      srctemplate);
 232   bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
 233   bfd_make_writable (abfd);
 234   /* Create a minimal set of sections to own the symbols.  */
 235   sec = bfd_make_section_old_way (abfd, ".text");
 236   bfd_set_section_flags (abfd, sec,
 237                          (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 238                           | SEC_ALLOC | SEC_LOAD | SEC_KEEP));
 239   sec->output_section = sec;
 240   sec->output_offset = 0;
 241   return abfd;
 242 }
 243
 244 /* Check if the BFD is an IR dummy.  */
 245 bfd_boolean
 246 is_ir_dummy_bfd (const bfd *abfd)
 247 {
 248   size_t namlen = strlen (abfd->filename);
 249   if (namlen < IRONLY_SUFFIX_LEN)
 250     return FALSE;
 251   return !strcmp (abfd->filename + namlen - IRONLY_SUFFIX_LEN, IRONLY_SUFFIX);
 252 }
 253
 254 /* Helpers to convert between BFD and GOLD symbol formats.  */
 255 static enum ld_plugin_status
 256 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
 257                                 const struct ld_plugin_symbol *ldsym)
 258 {
 259   flagword flags = BSF_NO_FLAGS;
 260   struct bfd_section *section;
 261
 262   asym->the_bfd = abfd;
 263   asym->name = ldsym->version
 264                 ? concat (ldsym->name, "@", ldsym->version, NULL)
 265                 : ldsym->name;
 266   asym->value = 0;
 267   switch (ldsym->def)
 268     {
 269     case LDPK_WEAKDEF:
 270       flags = BSF_WEAK;
 271       /* FALLTHRU */
 272     case LDPK_DEF:
 273       flags |= BSF_GLOBAL;
 274       section = bfd_get_section_by_name (abfd, ".text");
 275       break;
 276
 277     case LDPK_WEAKUNDEF:
 278       flags = BSF_WEAK;
 279       /* FALLTHRU */
 280     case LDPK_UNDEF:
 281       section = bfd_und_section_ptr;
 282       break;
 283
 284     case LDPK_COMMON:
 285       flags = BSF_GLOBAL;
 286       section = bfd_com_section_ptr;
 287       asym->value = ldsym->size;
 288       break;
 289
 290     default:
 291       return LDPS_ERR;
 292     }
 293   asym->flags = flags;
 294   asym->section = section;
 295
 296   /* Visibility only applies on ELF targets.  */
 297   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 298     {
 299       elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
 300       if (!elfsym)
 301         einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!"), asym->name);
 302       elfsym->internal_elf_sym.st_other &= ~3;
 303       elfsym->internal_elf_sym.st_other |= ldsym->visibility;
 304     }
 305
 306   return LDPS_OK;
 307 }
 308
 309 /* Register a claim-file handler.  */
 310 static enum ld_plugin_status
 311 register_claim_file (ld_plugin_claim_file_handler handler)
 312 {
 313   ASSERT (called_plugin);
 314   called_plugin->claim_file_handler = handler;
 315   return LDPS_OK;
 316 }
 317
 318 /* Register an all-symbols-read handler.  */
 319 static enum ld_plugin_status
 320 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
 321 {
 322   ASSERT (called_plugin);
 323   called_plugin->all_symbols_read_handler = handler;
 324   return LDPS_OK;
 325 }
 326
 327 /* Register a cleanup handler.  */
 328 static enum ld_plugin_status
 329 register_cleanup (ld_plugin_cleanup_handler handler)
 330 {
 331   ASSERT (called_plugin);
 332   called_plugin->cleanup_handler = handler;
 333   return LDPS_OK;
 334 }
 335
 336 /* Add symbols from a plugin-claimed input file.  */
 337 static enum ld_plugin_status
 338 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
 339 {
 340   asymbol **symptrs;
 341   bfd *abfd = handle;
 342   int n;
 343   ASSERT (called_plugin);
 344   symptrs = xmalloc (nsyms * sizeof *symptrs);
 345   for (n = 0; n < nsyms; n++)
 346     {
 347       enum ld_plugin_status rv;
 348       asymbol *bfdsym = bfd_make_empty_symbol (abfd);
 349       symptrs[n] = bfdsym;
 350       rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
 351       if (rv != LDPS_OK)
 352         return rv;
 353     }
 354   bfd_set_symtab (abfd, symptrs, nsyms);
 355   return LDPS_OK;
 356 }
 357
 358 /* Get the input file information with an open (possibly re-opened)
 359    file descriptor.  */
 360 static enum ld_plugin_status
 361 get_input_file (const void *handle, struct ld_plugin_input_file *file)
 362 {
 363   ASSERT (called_plugin);
 364   handle = handle;
 365   file = file;
 366   return LDPS_ERR;
 367 }
 368
 369 /* Release the input file.  */
 370 static enum ld_plugin_status
 371 release_input_file (const void *handle)
 372 {
 373   ASSERT (called_plugin);
 374   handle = handle;
 375   return LDPS_ERR;
 376 }
 377
 378 /* Get the symbol resolution info for a plugin-claimed input file.  */
 379 static enum ld_plugin_status
 380 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 381 {
 382   const bfd *abfd = handle;
 383   int n;
 384   ASSERT (called_plugin);
 385   for (n = 0; n < nsyms; n++)
 386     {
 387       struct bfd_link_hash_entry *blhe;
 388       bfd_boolean ironly;
 389
 390       blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
 391                                 FALSE, FALSE, TRUE);
 392       if (!blhe)
 393         {
 394           syms[n].resolution = LDPR_UNKNOWN;
 395           continue;
 396         }
 397
 398       /* Determine resolution from blhe type and symbol's original type.  */
 399       if (blhe->type == bfd_link_hash_undefined
 400                 || blhe->type == bfd_link_hash_undefweak)
 401         {
 402           syms[n].resolution = LDPR_UNDEF;
 403           continue;
 404         }
 405       if (blhe->type != bfd_link_hash_defined
 406                 && blhe->type != bfd_link_hash_defweak
 407                 && blhe->type != bfd_link_hash_common)
 408         {
 409           /* We should not have a new, indirect or warning symbol here.  */
 410           einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)",
 411                 called_plugin->name, blhe->type);
 412         }
 413
 414       /* We need to know if the sym is referenced from non-IR files.  */
 415       ironly = !bfd_hash_lookup (non_ironly_hash, syms[n].name, FALSE, FALSE);
 416
 417       /* If it was originally undefined or common, then it has been
 418          resolved; determine how.  */
 419       if (syms[n].def == LDPK_UNDEF || syms[n].def == LDPK_WEAKUNDEF
 420           || syms[n].def == LDPK_COMMON)
 421         {
 422           asection *owner_sec = (blhe->type == bfd_link_hash_common)
 423                                 ? blhe->u.c.p->section
 424                                 : blhe->u.def.section;
 425           if (owner_sec->owner == link_info.output_bfd)
 426             syms[n].resolution = LDPR_RESOLVED_EXEC;
 427           else if (owner_sec->owner == abfd)
 428             syms[n].resolution = (ironly)
 429                                 ? LDPR_PREVAILING_DEF_IRONLY
 430                                 : LDPR_PREVAILING_DEF;
 431           else if (is_ir_dummy_bfd (owner_sec->owner))
 432             syms[n].resolution = LDPR_RESOLVED_IR;
 433           else if (owner_sec->owner->flags & DYNAMIC)
 434             syms[n].resolution =  LDPR_RESOLVED_DYN;
 435           else
 436             syms[n].resolution = LDPR_RESOLVED_EXEC;
 437           continue;
 438         }
 439
 440       /* Was originally def, or weakdef.  Does it prevail?  If the
 441          owner is the original dummy bfd that supplied it, then this
 442          is the definition that has prevailed.  */
 443       if (blhe->u.def.section->owner == link_info.output_bfd)
 444         syms[n].resolution = LDPR_PREEMPTED_REG;
 445       else if (blhe->u.def.section->owner == abfd)
 446         {
 447           syms[n].resolution = (ironly)
 448                                 ? LDPR_PREVAILING_DEF_IRONLY
 449                                 : LDPR_PREVAILING_DEF;
 450           continue;
 451         }
 452
 453       /* Was originally def, weakdef, or common, but has been pre-empted.  */
 454       syms[n].resolution = is_ir_dummy_bfd (blhe->u.def.section->owner)
 455                                 ? LDPR_PREEMPTED_IR
 456                                 : LDPR_PREEMPTED_REG;
 457     }
 458   return LDPS_OK;
 459 }
 460
 461 /* Add a new (real) input file generated by a plugin.  */
 462 static enum ld_plugin_status
 463 add_input_file (const char *pathname)
 464 {
 465   ASSERT (called_plugin);
 466   if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
 467         NULL))
 468     return LDPS_ERR;
 469   return LDPS_OK;
 470 }
 471
 472 /* Add a new (real) library required by a plugin.  */
 473 static enum ld_plugin_status
 474 add_input_library (const char *pathname)
 475 {
 476   ASSERT (called_plugin);
 477   if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
 478         NULL))
 479     return LDPS_ERR;
 480   return LDPS_OK;
 481 }
 482
 483 /* Set the extra library path to be used by libraries added via
 484    add_input_library.  */
 485 static enum ld_plugin_status
 486 set_extra_library_path (const char *path)
 487 {
 488   ASSERT (called_plugin);
 489   ldfile_add_library_path (xstrdup (path), FALSE);
 490   return LDPS_OK;
 491 }
 492
 493 /* Issue a diagnostic message from a plugin.  */
 494 static enum ld_plugin_status
 495 message (int level, const char *format, ...)
 496 {
 497   va_list args;
 498   va_start (args, format);
 499
 500   switch (level)
 501     {
 502     case LDPL_INFO:
 503       vfinfo (stdout, format, args, FALSE);
 504       break;
 505     case LDPL_WARNING:
 506       vfinfo (stdout, format, args, TRUE);
 507       break;
 508     case LDPL_FATAL:
 509     case LDPL_ERROR:
 510     default:
 511       {
 512         char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%F" : "%X",
 513                                 format, NULL));
 514         vfinfo (stderr, newfmt, args, TRUE);
 515       }
 516       break;
 517     }
 518
 519   va_end (args);
 520   return LDPS_OK;
 521 }
 522
 523 /* Helper to size leading part of tv array and set it up. */
 524 static size_t
 525 set_tv_header (struct ld_plugin_tv *tv)
 526 {
 527   size_t i;
 528
 529   /* Version info.  */
 530   static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
 531   static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
 532
 533   if (!tv)
 534     return tv_header_size;
 535
 536   for (i = 0; i < tv_header_size; i++)
 537     {
 538       tv[i].tv_tag = tv_header_tags[i];
 539 #define TVU(x) tv[i].tv_u.tv_ ## x
 540       switch (tv[i].tv_tag)
 541         {
 542           case LDPT_MESSAGE:
 543             TVU(message) = message;
 544             break;
 545           case LDPT_API_VERSION:
 546             TVU(val) = LD_PLUGIN_API_VERSION;
 547             break;
 548           case LDPT_GNU_LD_VERSION:
 549             TVU(val) = major * 100 + minor;
 550             break;
 551           case LDPT_LINKER_OUTPUT:
 552             TVU(val) = link_info.relocatable ? LDPO_REL
 553                         : (link_info.shared ? LDPO_DYN : LDPO_EXEC);
 554             break;
 555           case LDPT_OUTPUT_NAME:
 556             TVU(string) = output_filename;
 557             break;
 558           case LDPT_REGISTER_CLAIM_FILE_HOOK:
 559             TVU(register_claim_file) = register_claim_file;
 560             break;
 561           case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 562             TVU(register_all_symbols_read) = register_all_symbols_read;
 563             break;
 564           case LDPT_REGISTER_CLEANUP_HOOK:
 565             TVU(register_cleanup) = register_cleanup;
 566             break;
 567           case LDPT_ADD_SYMBOLS:
 568             TVU(add_symbols) = add_symbols;
 569             break;
 570           case LDPT_GET_INPUT_FILE:
 571             TVU(get_input_file) = get_input_file;
 572             break;
 573           case LDPT_RELEASE_INPUT_FILE:
 574             TVU(release_input_file) = release_input_file;
 575             break;
 576           case LDPT_GET_SYMBOLS:
 577             TVU(get_symbols) = get_symbols;
 578             break;
 579           case LDPT_ADD_INPUT_FILE:
 580             TVU(add_input_file) = add_input_file;
 581             break;
 582           case LDPT_ADD_INPUT_LIBRARY:
 583             TVU(add_input_library) = add_input_library;
 584             break;
 585           case LDPT_SET_EXTRA_LIBRARY_PATH:
 586             TVU(set_extra_library_path) = set_extra_library_path;
 587             break;
 588           default:
 589             /* Added a new entry to the array without adding
 590                a new case to set up its value is a bug.  */
 591             FAIL ();
 592         }
 593 #undef TVU
 594     }
 595   return tv_header_size;
 596 }
 597
 598 /* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
 599 static void
 600 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
 601 {
 602   plugin_arg_t *arg = plugin->args;
 603   while (arg)
 604     {
 605       tv->tv_tag = LDPT_OPTION;
 606       tv->tv_u.tv_string = arg->arg;
 607       arg = arg->next;
 608       tv++;
 609     }
 610   tv->tv_tag = LDPT_NULL;
 611   tv->tv_u.tv_val = 0;
 612 }
 613
 614 /* Load up and initialise all plugins after argument parsing.  */
 615 int plugin_load_plugins (void)
 616 {
 617   struct ld_plugin_tv *my_tv;
 618   unsigned int max_args = 0;
 619   plugin_t *curplug = plugins_list;
 620
 621   /* If there are no plugins, we need do nothing this run.  */
 622   if (!curplug)
 623     return 0;
 624
 625   /* First pass over plugins to find max # args needed so that we
 626      can size and allocate the tv array.  */
 627   while (curplug)
 628     {
 629       if (curplug->n_args > max_args)
 630         max_args = curplug->n_args;
 631       curplug = curplug->next;
 632     }
 633
 634   /* Allocate tv array and initialise constant part.  */
 635   my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
 636   set_tv_header (my_tv);
 637
 638   /* Pass over plugins again, activating them.  */
 639   curplug = plugins_list;
 640   while (curplug)
 641     {
 642       enum ld_plugin_status rv;
 643       ld_plugin_onload onloadfn = dlsym (curplug->dlhandle, "onload");
 644       if (!onloadfn)
 645         onloadfn = dlsym (curplug->dlhandle, "_onload");
 646       if (!onloadfn)
 647         return set_plugin_error (curplug->name);
 648       set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
 649       called_plugin = curplug;
 650       rv = (*onloadfn) (my_tv);
 651       called_plugin = NULL;
 652       if (rv != LDPS_OK)
 653         return set_plugin_error (curplug->name);
 654       curplug = curplug->next;
 655     }
 656
 657   /* Since plugin(s) inited ok, assume they're going to want symbol
 658      resolutions, which needs us to track which symbols are referenced
 659      by non-IR files using the linker's notice callback.  */
 660   link_info.notice_all = TRUE;
 661
 662   return 0;
 663 }
 664
 665 /* Call 'claim file' hook for all plugins.  */
 666 int
 667 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
 668 {
 669   plugin_t *curplug = plugins_list;
 670   *claimed = FALSE;
 671   if (no_more_claiming)
 672     return 0;
 673   while (curplug && !*claimed)
 674     {
 675       if (curplug->claim_file_handler)
 676         {
 677           enum ld_plugin_status rv;
 678           called_plugin = curplug;
 679           rv = (*curplug->claim_file_handler) (file, claimed);
 680           called_plugin = NULL;
 681           if (rv != LDPS_OK)
 682             set_plugin_error (curplug->name);
 683         }
 684       curplug = curplug->next;
 685     }
 686   return plugin_error_p () ? -1 : 0;
 687 }
 688
 689 /* Call 'all symbols read' hook for all plugins.  */
 690 int
 691 plugin_call_all_symbols_read (void)
 692 {
 693   plugin_t *curplug = plugins_list;
 694
 695   /* Disable any further file-claiming.  */
 696   no_more_claiming = TRUE;
 697
 698   /* If --allow-multiple-definition is in effect, we need to disable it,
 699      as the plugin infrastructure relies on the multiple_definition
 700      callback to swap out the dummy IR-only BFDs for new real ones
 701      when it starts opening the files added during this callback.  */
 702   plugin_cached_allow_multiple_defs = link_info.allow_multiple_definition;
 703   link_info.allow_multiple_definition = FALSE;
 704
 705   while (curplug)
 706     {
 707       if (curplug->all_symbols_read_handler)
 708         {
 709           enum ld_plugin_status rv;
 710           called_plugin = curplug;
 711           rv = (*curplug->all_symbols_read_handler) ();
 712           called_plugin = NULL;
 713           if (rv != LDPS_OK)
 714             set_plugin_error (curplug->name);
 715         }
 716       curplug = curplug->next;
 717     }
 718   return plugin_error_p () ? -1 : 0;
 719 }
 720
 721 /* Call 'cleanup' hook for all plugins.  */
 722 int
 723 plugin_call_cleanup (void)
 724 {
 725   plugin_t *curplug = plugins_list;
 726   while (curplug)
 727     {
 728       if (curplug->cleanup_handler && !curplug->cleanup_done)
 729         {
 730           enum ld_plugin_status rv;
 731           curplug->cleanup_done = TRUE;
 732           called_plugin = curplug;
 733           rv = (*curplug->cleanup_handler) ();
 734           called_plugin = NULL;
 735           if (rv != LDPS_OK)
 736             set_plugin_error (curplug->name);
 737           dlclose (curplug->dlhandle);
 738         }
 739       curplug = curplug->next;
 740     }
 741   return plugin_error_p () ? -1 : 0;
 742 }
 743
 744 /* Lazily init the non_ironly hash table.  */
 745 static void
 746 init_non_ironly_hash (void)
 747 {
 748   if (non_ironly_hash == NULL)
 749     {
 750       non_ironly_hash =
 751           (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
 752       if (!bfd_hash_table_init_n (non_ironly_hash,
 753                                   bfd_hash_newfunc,
 754                                   sizeof (struct bfd_hash_entry),
 755                                   61))
 756         einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 757     }
 758 }
 759
 760 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
 761    and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
 762    the linker adds them to the linker hash table.  If we see a symbol
 763    being referenced from a non-IR file, we add it to the non_ironly hash
 764    table.  If we can't find it there at get_symbols time, we know that
 765    it was referenced only by IR files.  We have to notice_all symbols,
 766    because we won't necessarily know until later which ones will be
 767    contributed by IR files.  */
 768 bfd_boolean
 769 plugin_notice (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 770                 const char *name, bfd *abfd,
 771                 asection *section, bfd_vma value ATTRIBUTE_UNUSED)
 772 {
 773   bfd_boolean is_ref = bfd_is_und_section (section);
 774   bfd_boolean is_dummy = is_ir_dummy_bfd (abfd);
 775   init_non_ironly_hash ();
 776   /* We only care about refs, not defs, indicated by section pointing
 777      to the undefined section (according to the bfd linker notice callback
 778      interface definition).  */
 779   if (is_ref && !is_dummy)
 780     {
 781       /* This is a ref from a non-IR file, so note the ref'd symbol
 782          in the non-IR-only hash.  */
 783       if (!bfd_hash_lookup (non_ironly_hash, name, TRUE, TRUE))
 784         einfo (_("%P%X: %s: hash table failure adding symbol %s"),
 785                 abfd->filename, name);
 786     }
 787   else if (!is_ref && is_dummy)
 788     {
 789       /* No further processing since this is a def from an IR dummy BFD.  */
 790       return FALSE;
 791     }
 792
 793   /* Continue with cref/nocrossref/trace-sym processing.  */
 794   return TRUE;
 795 }
 796
 797 /* When we add new object files to the link at all symbols read time,
 798    these contain the real code and symbols generated from the IR files,
 799    and so duplicate all the definitions already supplied by the dummy
 800    IR-only BFDs that we created at claim files time.  We use the linker's
 801    multiple-definitions callback hook to fix up the clash, discarding
 802    the symbol from the IR-only BFD in favour of the symbol from the
 803    real BFD.  We return true if this was not-really-a-clash because
 804    we've fixed it up, or anyway if --allow-multiple-definition was in
 805    effect (before we disabled it to ensure we got called back).  */
 806 bfd_boolean
 807 plugin_multiple_definition (struct bfd_link_info *info, const char *name,
 808                 bfd *obfd, asection *osec ATTRIBUTE_UNUSED,
 809                 bfd_vma oval ATTRIBUTE_UNUSED,
 810                 bfd *nbfd, asection *nsec, bfd_vma nval)
 811 {
 812   if (is_ir_dummy_bfd (obfd))
 813     {
 814       struct bfd_link_hash_entry *blhe = bfd_link_hash_lookup (info->hash,
 815                                         name, FALSE, FALSE, FALSE);
 816       if (!blhe)
 817         einfo (_("%P%X: %s: can't find IR symbol '%s'"), nbfd->filename,
 818                 name);
 819       else if (blhe->type != bfd_link_hash_defined)
 820         einfo (_("%P%x: %s: bad IR symbol type %d"), name, blhe->type);
 821       /* Replace it with new details.  */
 822       blhe->u.def.section = nsec;
 823       blhe->u.def.value = nval;
 824       return TRUE;
 825     }
 826   return plugin_cached_allow_multiple_defs;
 827 }