ld/plugin.c

   1 /* Plugin control for the GNU linker.
   2    Copyright (C) 2010-2014 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 /* Report plugin symbols.  */
  40 bfd_boolean report_plugin_symbols;
  41
  42 /* The suffix to append to the name of the real (claimed) object file
  43    when generating a dummy BFD to hold the IR symbols sent from the
  44    plugin.  For cosmetic use only; appears in maps, crefs etc.  */
  45 #define IRONLY_SUFFIX " (symbol from plugin)"
  46
  47 /* Stores a single argument passed to a plugin.  */
  48 typedef struct plugin_arg
  49 {
  50   struct plugin_arg *next;
  51   const char *arg;
  52 } plugin_arg_t;
  53
  54 /* Holds all details of a single plugin.  */
  55 typedef struct plugin
  56 {
  57   /* Next on the list of plugins, or NULL at end of chain.  */
  58   struct plugin *next;
  59   /* The argument string given to --plugin.  */
  60   const char *name;
  61   /* The shared library handle returned by dlopen.  */
  62   void *dlhandle;
  63   /* The list of argument string given to --plugin-opt.  */
  64   plugin_arg_t *args;
  65   /* Number of args in the list, for convenience.  */
  66   size_t n_args;
  67   /* The plugin's event handlers.  */
  68   ld_plugin_claim_file_handler claim_file_handler;
  69   ld_plugin_all_symbols_read_handler all_symbols_read_handler;
  70   ld_plugin_cleanup_handler cleanup_handler;
  71   /* TRUE if the cleanup handlers have been called.  */
  72   bfd_boolean cleanup_done;
  73 } plugin_t;
  74
  75 /* The master list of all plugins.  */
  76 static plugin_t *plugins_list = NULL;
  77
  78 /* We keep a tail pointer for easy linking on the end.  */
  79 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
  80
  81 /* The last plugin added to the list, for receiving args.  */
  82 static plugin_t *last_plugin = NULL;
  83
  84 /* The tail of the arg chain of the last plugin added to the list.  */
  85 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
  86
  87 /* The plugin which is currently having a callback executed.  */
  88 static plugin_t *called_plugin = NULL;
  89
  90 /* Last plugin to cause an error, if any.  */
  91 static const char *error_plugin = NULL;
  92
  93 /* State of linker "notice" interface before we poked at it.  */
  94 static bfd_boolean orig_notice_all;
  95
  96 /* Original linker callbacks, and the plugin version.  */
  97 static const struct bfd_link_callbacks *orig_callbacks;
  98 static struct bfd_link_callbacks plugin_callbacks;
  99
 100 /* Set at all symbols read time, to avoid recursively offering the plugin
 101    its own newly-added input files and libs to claim.  */
 102 bfd_boolean no_more_claiming = FALSE;
 103
 104 /* List of tags to set in the constant leading part of the tv array. */
 105 static const enum ld_plugin_tag tv_header_tags[] =
 106 {
 107   LDPT_MESSAGE,
 108   LDPT_API_VERSION,
 109   LDPT_GNU_LD_VERSION,
 110   LDPT_LINKER_OUTPUT,
 111   LDPT_OUTPUT_NAME,
 112   LDPT_REGISTER_CLAIM_FILE_HOOK,
 113   LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
 114   LDPT_REGISTER_CLEANUP_HOOK,
 115   LDPT_ADD_SYMBOLS,
 116   LDPT_GET_INPUT_FILE,
 117   LDPT_RELEASE_INPUT_FILE,
 118   LDPT_GET_SYMBOLS,
 119   LDPT_GET_SYMBOLS_V2,
 120   LDPT_ADD_INPUT_FILE,
 121   LDPT_ADD_INPUT_LIBRARY,
 122   LDPT_SET_EXTRA_LIBRARY_PATH
 123 };
 124
 125 /* How many entries in the constant leading part of the tv array.  */
 126 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
 127
 128 /* Forward references.  */
 129 static bfd_boolean plugin_notice (struct bfd_link_info *,
 130                                   struct bfd_link_hash_entry *,
 131                                   struct bfd_link_hash_entry *,
 132                                   bfd *, asection *, bfd_vma, flagword);
 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 #ifndef HAVE_DLFCN_H
 160 static const char *
 161 dlerror (void)
 162 {
 163   return "";
 164 }
 165 #endif
 166
 167 /* Helper function for exiting with error status.  */
 168 static int
 169 set_plugin_error (const char *plugin)
 170 {
 171   error_plugin = plugin;
 172   return -1;
 173 }
 174
 175 /* Test if an error occurred.  */
 176 static bfd_boolean
 177 plugin_error_p (void)
 178 {
 179   return error_plugin != NULL;
 180 }
 181
 182 /* Return name of plugin which caused an error if any.  */
 183 const char *
 184 plugin_error_plugin (void)
 185 {
 186   return error_plugin ? error_plugin : _("<no plugin>");
 187 }
 188
 189 /* Handle -plugin arg: find and load plugin, or return error.  */
 190 void
 191 plugin_opt_plugin (const char *plugin)
 192 {
 193   plugin_t *newplug;
 194
 195   newplug = xmalloc (sizeof *newplug);
 196   memset (newplug, 0, sizeof *newplug);
 197   newplug->name = plugin;
 198   newplug->dlhandle = dlopen (plugin, RTLD_NOW);
 199   if (!newplug->dlhandle)
 200     einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin, dlerror ());
 201
 202   /* Chain on end, so when we run list it is in command-line order.  */
 203   *plugins_tail_chain_ptr = newplug;
 204   plugins_tail_chain_ptr = &newplug->next;
 205
 206   /* Record it as current plugin for receiving args.  */
 207   last_plugin = newplug;
 208   last_plugin_args_tail_chain_ptr = &newplug->args;
 209 }
 210
 211 /* Accumulate option arguments for last-loaded plugin, or return
 212    error if none.  */
 213 int
 214 plugin_opt_plugin_arg (const char *arg)
 215 {
 216   plugin_arg_t *newarg;
 217
 218   if (!last_plugin)
 219     return set_plugin_error (_("<no plugin>"));
 220
 221   /* Ignore -pass-through= from GCC driver.  */
 222   if (*arg == '-')
 223     {
 224       const char *p = arg + 1;
 225
 226       if (*p == '-')
 227         ++p;
 228       if (strncmp (p, "pass-through=", 13) == 0)
 229         return 0;
 230     }
 231
 232   newarg = xmalloc (sizeof *newarg);
 233   newarg->arg = arg;
 234   newarg->next = NULL;
 235
 236   /* Chain on end to preserve command-line order.  */
 237   *last_plugin_args_tail_chain_ptr = newarg;
 238   last_plugin_args_tail_chain_ptr = &newarg->next;
 239   last_plugin->n_args++;
 240   return 0;
 241 }
 242
 243 /* Create a dummy BFD.  */
 244 bfd *
 245 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
 246 {
 247   bfd *abfd;
 248
 249   bfd_use_reserved_id = 1;
 250   abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
 251                      srctemplate);
 252   if (abfd != NULL)
 253     {
 254       abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
 255       bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
 256       bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
 257       if (bfd_make_writable (abfd)
 258           && bfd_copy_private_bfd_data (srctemplate, abfd))
 259         {
 260           flagword flags;
 261
 262           /* Create section to own the symbols.  */
 263           flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 264                    | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
 265           if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
 266             return abfd;
 267         }
 268     }
 269   einfo (_("could not create dummy IR bfd: %F%E\n"));
 270   return NULL;
 271 }
 272
 273 /* Check if the BFD passed in is an IR dummy object file.  */
 274 static inline bfd_boolean
 275 is_ir_dummy_bfd (const bfd *abfd)
 276 {
 277   /* ABFD can sometimes legitimately be NULL, e.g. when called from one
 278      of the linker callbacks for a symbol in the *ABS* or *UND* sections.  */
 279   return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0;
 280 }
 281
 282 /* Helpers to convert between BFD and GOLD symbol formats.  */
 283 static enum ld_plugin_status
 284 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
 285                             const struct ld_plugin_symbol *ldsym)
 286 {
 287   flagword flags = BSF_NO_FLAGS;
 288   struct bfd_section *section;
 289
 290   asym->the_bfd = abfd;
 291   asym->name = (ldsym->version
 292                 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
 293                 : ldsym->name);
 294   asym->value = 0;
 295   switch (ldsym->def)
 296     {
 297     case LDPK_WEAKDEF:
 298       flags = BSF_WEAK;
 299       /* FALLTHRU */
 300     case LDPK_DEF:
 301       flags |= BSF_GLOBAL;
 302       if (ldsym->comdat_key)
 303         {
 304           char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
 305                                (const char *) NULL);
 306           section = bfd_get_section_by_name (abfd, name);
 307           if (section != NULL)
 308             free (name);
 309           else
 310             {
 311               flagword sflags;
 312
 313               sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 314                         | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
 315                         | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
 316               section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
 317               if (section == NULL)
 318                 return LDPS_ERR;
 319             }
 320         }
 321       else
 322         section = bfd_get_section_by_name (abfd, ".text");
 323       break;
 324
 325     case LDPK_WEAKUNDEF:
 326       flags = BSF_WEAK;
 327       /* FALLTHRU */
 328     case LDPK_UNDEF:
 329       section = bfd_und_section_ptr;
 330       break;
 331
 332     case LDPK_COMMON:
 333       flags = BSF_GLOBAL;
 334       section = bfd_com_section_ptr;
 335       asym->value = ldsym->size;
 336       /* For ELF targets, set alignment of common symbol to 1.  */
 337       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 338         {
 339           ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
 340           ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
 341         }
 342       break;
 343
 344     default:
 345       return LDPS_ERR;
 346     }
 347   asym->flags = flags;
 348   asym->section = section;
 349
 350   /* Visibility only applies on ELF targets.  */
 351   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 352     {
 353       elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
 354       unsigned char visibility;
 355
 356       if (!elfsym)
 357         einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
 358       switch (ldsym->visibility)
 359         {
 360         default:
 361           einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
 362                  ldsym->visibility);
 363         case LDPV_DEFAULT:
 364           visibility = STV_DEFAULT;
 365           break;
 366         case LDPV_PROTECTED:
 367           visibility = STV_PROTECTED;
 368           break;
 369         case LDPV_INTERNAL:
 370           visibility = STV_INTERNAL;
 371           break;
 372         case LDPV_HIDDEN:
 373           visibility = STV_HIDDEN;
 374           break;
 375         }
 376       elfsym->internal_elf_sym.st_other
 377         = (visibility | (elfsym->internal_elf_sym.st_other
 378                          & ~ELF_ST_VISIBILITY (-1)));
 379     }
 380
 381   return LDPS_OK;
 382 }
 383
 384 /* Register a claim-file handler.  */
 385 static enum ld_plugin_status
 386 register_claim_file (ld_plugin_claim_file_handler handler)
 387 {
 388   ASSERT (called_plugin);
 389   called_plugin->claim_file_handler = handler;
 390   return LDPS_OK;
 391 }
 392
 393 /* Register an all-symbols-read handler.  */
 394 static enum ld_plugin_status
 395 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
 396 {
 397   ASSERT (called_plugin);
 398   called_plugin->all_symbols_read_handler = handler;
 399   return LDPS_OK;
 400 }
 401
 402 /* Register a cleanup handler.  */
 403 static enum ld_plugin_status
 404 register_cleanup (ld_plugin_cleanup_handler handler)
 405 {
 406   ASSERT (called_plugin);
 407   called_plugin->cleanup_handler = handler;
 408   return LDPS_OK;
 409 }
 410
 411 /* Add symbols from a plugin-claimed input file.  */
 412 static enum ld_plugin_status
 413 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
 414 {
 415   asymbol **symptrs;
 416   bfd *abfd = handle;
 417   int n;
 418
 419   ASSERT (called_plugin);
 420   symptrs = xmalloc (nsyms * sizeof *symptrs);
 421   for (n = 0; n < nsyms; n++)
 422     {
 423       enum ld_plugin_status rv;
 424       asymbol *bfdsym;
 425
 426       bfdsym = bfd_make_empty_symbol (abfd);
 427       symptrs[n] = bfdsym;
 428       rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
 429       if (rv != LDPS_OK)
 430         return rv;
 431     }
 432   bfd_set_symtab (abfd, symptrs, nsyms);
 433   return LDPS_OK;
 434 }
 435
 436 /* Get the input file information with an open (possibly re-opened)
 437    file descriptor.  */
 438 static enum ld_plugin_status
 439 get_input_file (const void *handle ATTRIBUTE_UNUSED,
 440                 struct ld_plugin_input_file *file ATTRIBUTE_UNUSED)
 441 {
 442   ASSERT (called_plugin);
 443   return LDPS_ERR;
 444 }
 445
 446 /* Release the input file.  */
 447 static enum ld_plugin_status
 448 release_input_file (const void *handle ATTRIBUTE_UNUSED)
 449 {
 450   ASSERT (called_plugin);
 451   return LDPS_ERR;
 452 }
 453
 454 /* Return TRUE if a defined symbol might be reachable from outside the
 455    universe of claimed objects.  */
 456 static inline bfd_boolean
 457 is_visible_from_outside (struct ld_plugin_symbol *lsym,
 458                          struct bfd_link_hash_entry *blhe)
 459 {
 460   struct bfd_sym_chain *sym;
 461
 462   if (link_info.relocatable)
 463     return TRUE;
 464   if (link_info.export_dynamic || !link_info.executable)
 465     {
 466       /* Check if symbol is hidden by version script.  */
 467       if (bfd_hide_sym_by_version (link_info.version_info,
 468                                    blhe->root.string))
 469         return FALSE;
 470       /* Only ELF symbols really have visibility.  */
 471       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 472         {
 473           struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
 474           int vis = ELF_ST_VISIBILITY (el->other);
 475           return vis == STV_DEFAULT || vis == STV_PROTECTED;
 476         }
 477       /* On non-ELF targets, we can safely make inferences by considering
 478          what visibility the plugin would have liked to apply when it first
 479          sent us the symbol.  During ELF symbol processing, visibility only
 480          ever becomes more restrictive, not less, when symbols are merged,
 481          so this is a conservative estimate; it may give false positives,
 482          declaring something visible from outside when it in fact would
 483          not have been, but this will only lead to missed optimisation
 484          opportunities during LTRANS at worst; it will not give false
 485          negatives, which can lead to the disastrous conclusion that the
 486          related symbol is IRONLY.  (See GCC PR46319 for an example.)  */
 487       return (lsym->visibility == LDPV_DEFAULT
 488               || lsym->visibility == LDPV_PROTECTED);
 489     }
 490
 491   for (sym = &entry_symbol; sym != NULL; sym = sym->next)
 492     if (sym->name
 493         && strcmp (sym->name, blhe->root.string) == 0)
 494       return TRUE;
 495
 496   return FALSE;
 497 }
 498
 499 /* Get the symbol resolution info for a plugin-claimed input file.  */
 500 static enum ld_plugin_status
 501 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
 502              int def_ironly_exp)
 503 {
 504   const bfd *abfd = handle;
 505   int n;
 506
 507   ASSERT (called_plugin);
 508   for (n = 0; n < nsyms; n++)
 509     {
 510       struct bfd_link_hash_entry *blhe;
 511       asection *owner_sec;
 512       int res;
 513
 514       if (syms[n].def != LDPK_UNDEF)
 515         blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
 516                                      FALSE, FALSE, TRUE);
 517       else
 518         blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
 519                                              syms[n].name, FALSE, FALSE, TRUE);
 520       if (!blhe)
 521         {
 522           res = LDPR_UNKNOWN;
 523           goto report_symbol;
 524         }
 525
 526       /* Determine resolution from blhe type and symbol's original type.  */
 527       if (blhe->type == bfd_link_hash_undefined
 528           || blhe->type == bfd_link_hash_undefweak)
 529         {
 530           res = LDPR_UNDEF;
 531           goto report_symbol;
 532         }
 533       if (blhe->type != bfd_link_hash_defined
 534           && blhe->type != bfd_link_hash_defweak
 535           && blhe->type != bfd_link_hash_common)
 536         {
 537           /* We should not have a new, indirect or warning symbol here.  */
 538           einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
 539                  called_plugin->name, blhe->type);
 540         }
 541
 542       /* Find out which section owns the symbol.  Since it's not undef,
 543          it must have an owner; if it's not a common symbol, both defs
 544          and weakdefs keep it in the same place. */
 545       owner_sec = (blhe->type == bfd_link_hash_common
 546                    ? blhe->u.c.p->section
 547                    : blhe->u.def.section);
 548
 549
 550       /* If it was originally undefined or common, then it has been
 551          resolved; determine how.  */
 552       if (syms[n].def == LDPK_UNDEF
 553           || syms[n].def == LDPK_WEAKUNDEF
 554           || syms[n].def == LDPK_COMMON)
 555         {
 556           if (owner_sec->owner == link_info.output_bfd)
 557             res = LDPR_RESOLVED_EXEC;
 558           else if (owner_sec->owner == abfd)
 559             res = LDPR_PREVAILING_DEF_IRONLY;
 560           else if (is_ir_dummy_bfd (owner_sec->owner))
 561             res = LDPR_RESOLVED_IR;
 562           else if (owner_sec->owner != NULL
 563                    && (owner_sec->owner->flags & DYNAMIC) != 0)
 564             res = LDPR_RESOLVED_DYN;
 565           else
 566             res = LDPR_RESOLVED_EXEC;
 567         }
 568
 569       /* Was originally def, or weakdef.  Does it prevail?  If the
 570          owner is the original dummy bfd that supplied it, then this
 571          is the definition that has prevailed.  */
 572       else if (owner_sec->owner == link_info.output_bfd)
 573         res = LDPR_PREEMPTED_REG;
 574       else if (owner_sec->owner == abfd)
 575         res = LDPR_PREVAILING_DEF_IRONLY;
 576
 577       /* Was originally def, weakdef, or common, but has been pre-empted.  */
 578       else if (is_ir_dummy_bfd (owner_sec->owner))
 579         res = LDPR_PREEMPTED_IR;
 580       else
 581         res = LDPR_PREEMPTED_REG;
 582
 583       if (res == LDPR_PREVAILING_DEF_IRONLY)
 584         {
 585           /* We need to know if the sym is referenced from non-IR files.  Or
 586              even potentially-referenced, perhaps in a future final link if
 587              this is a partial one, perhaps dynamically at load-time if the
 588              symbol is externally visible.  */
 589           if (blhe->non_ir_ref)
 590             res = LDPR_PREVAILING_DEF;
 591           else if (is_visible_from_outside (&syms[n], blhe))
 592             res = def_ironly_exp;
 593         }
 594
 595     report_symbol:
 596       syms[n].resolution = res;
 597       if (report_plugin_symbols)
 598         einfo (_("%P: %B: symbol `%s' "
 599                  "definition: %d, visibility: %d, resolution: %d\n"),
 600                abfd, syms[n].name,
 601                syms[n].def, syms[n].visibility, res);
 602     }
 603   return LDPS_OK;
 604 }
 605
 606 static enum ld_plugin_status
 607 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 608 {
 609   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
 610 }
 611
 612 static enum ld_plugin_status
 613 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 614 {
 615   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
 616 }
 617
 618 /* Add a new (real) input file generated by a plugin.  */
 619 static enum ld_plugin_status
 620 add_input_file (const char *pathname)
 621 {
 622   ASSERT (called_plugin);
 623   if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
 624                             NULL))
 625     return LDPS_ERR;
 626   return LDPS_OK;
 627 }
 628
 629 /* Add a new (real) library required by a plugin.  */
 630 static enum ld_plugin_status
 631 add_input_library (const char *pathname)
 632 {
 633   ASSERT (called_plugin);
 634   if (!lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
 635                             NULL))
 636     return LDPS_ERR;
 637   return LDPS_OK;
 638 }
 639
 640 /* Set the extra library path to be used by libraries added via
 641    add_input_library.  */
 642 static enum ld_plugin_status
 643 set_extra_library_path (const char *path)
 644 {
 645   ASSERT (called_plugin);
 646   ldfile_add_library_path (xstrdup (path), FALSE);
 647   return LDPS_OK;
 648 }
 649
 650 /* Issue a diagnostic message from a plugin.  */
 651 static enum ld_plugin_status
 652 message (int level, const char *format, ...)
 653 {
 654   va_list args;
 655   va_start (args, format);
 656
 657   switch (level)
 658     {
 659     case LDPL_INFO:
 660       vfinfo (stdout, format, args, FALSE);
 661       putchar ('\n');
 662       break;
 663     case LDPL_WARNING:
 664       vfinfo (stdout, format, args, TRUE);
 665       putchar ('\n');
 666       break;
 667     case LDPL_FATAL:
 668     case LDPL_ERROR:
 669     default:
 670       {
 671         char *newfmt = ACONCAT ((level == LDPL_FATAL ? "%P%F: " : "%P%X: ",
 672                                  format, "\n", (const char *) NULL));
 673         fflush (stdout);
 674         vfinfo (stderr, newfmt, args, TRUE);
 675         fflush (stderr);
 676       }
 677       break;
 678     }
 679
 680   va_end (args);
 681   return LDPS_OK;
 682 }
 683
 684 /* Helper to size leading part of tv array and set it up. */
 685 static void
 686 set_tv_header (struct ld_plugin_tv *tv)
 687 {
 688   size_t i;
 689
 690   /* Version info.  */
 691   static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
 692   static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
 693
 694   for (i = 0; i < tv_header_size; i++)
 695     {
 696       tv[i].tv_tag = tv_header_tags[i];
 697 #define TVU(x) tv[i].tv_u.tv_ ## x
 698       switch (tv[i].tv_tag)
 699         {
 700         case LDPT_MESSAGE:
 701           TVU(message) = message;
 702           break;
 703         case LDPT_API_VERSION:
 704           TVU(val) = LD_PLUGIN_API_VERSION;
 705           break;
 706         case LDPT_GNU_LD_VERSION:
 707           TVU(val) = major * 100 + minor;
 708           break;
 709         case LDPT_LINKER_OUTPUT:
 710           TVU(val) = (link_info.relocatable
 711                       ? LDPO_REL
 712                       : (link_info.executable
 713                          ? (link_info.pie ? LDPO_PIE : LDPO_EXEC)
 714                          : LDPO_DYN));
 715           break;
 716         case LDPT_OUTPUT_NAME:
 717           TVU(string) = output_filename;
 718           break;
 719         case LDPT_REGISTER_CLAIM_FILE_HOOK:
 720           TVU(register_claim_file) = register_claim_file;
 721           break;
 722         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 723           TVU(register_all_symbols_read) = register_all_symbols_read;
 724           break;
 725         case LDPT_REGISTER_CLEANUP_HOOK:
 726           TVU(register_cleanup) = register_cleanup;
 727           break;
 728         case LDPT_ADD_SYMBOLS:
 729           TVU(add_symbols) = add_symbols;
 730           break;
 731         case LDPT_GET_INPUT_FILE:
 732           TVU(get_input_file) = get_input_file;
 733           break;
 734         case LDPT_RELEASE_INPUT_FILE:
 735           TVU(release_input_file) = release_input_file;
 736           break;
 737         case LDPT_GET_SYMBOLS:
 738           TVU(get_symbols) = get_symbols_v1;
 739           break;
 740         case LDPT_GET_SYMBOLS_V2:
 741           TVU(get_symbols) = get_symbols_v2;
 742           break;
 743         case LDPT_ADD_INPUT_FILE:
 744           TVU(add_input_file) = add_input_file;
 745           break;
 746         case LDPT_ADD_INPUT_LIBRARY:
 747           TVU(add_input_library) = add_input_library;
 748           break;
 749         case LDPT_SET_EXTRA_LIBRARY_PATH:
 750           TVU(set_extra_library_path) = set_extra_library_path;
 751           break;
 752         default:
 753           /* Added a new entry to the array without adding
 754              a new case to set up its value is a bug.  */
 755           FAIL ();
 756         }
 757 #undef TVU
 758     }
 759 }
 760
 761 /* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
 762 static void
 763 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
 764 {
 765   plugin_arg_t *arg = plugin->args;
 766   while (arg)
 767     {
 768       tv->tv_tag = LDPT_OPTION;
 769       tv->tv_u.tv_string = arg->arg;
 770       arg = arg->next;
 771       tv++;
 772     }
 773   tv->tv_tag = LDPT_NULL;
 774   tv->tv_u.tv_val = 0;
 775 }
 776
 777 /* Return true if any plugins are active this run.  Only valid
 778    after options have been processed.  */
 779 bfd_boolean
 780 plugin_active_plugins_p (void)
 781 {
 782   return plugins_list != NULL;
 783 }
 784
 785 /* Load up and initialise all plugins after argument parsing.  */
 786 void
 787 plugin_load_plugins (void)
 788 {
 789   struct ld_plugin_tv *my_tv;
 790   unsigned int max_args = 0;
 791   plugin_t *curplug = plugins_list;
 792
 793   /* If there are no plugins, we need do nothing this run.  */
 794   if (!curplug)
 795     return;
 796
 797   /* First pass over plugins to find max # args needed so that we
 798      can size and allocate the tv array.  */
 799   while (curplug)
 800     {
 801       if (curplug->n_args > max_args)
 802         max_args = curplug->n_args;
 803       curplug = curplug->next;
 804     }
 805
 806   /* Allocate tv array and initialise constant part.  */
 807   my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
 808   set_tv_header (my_tv);
 809
 810   /* Pass over plugins again, activating them.  */
 811   curplug = plugins_list;
 812   while (curplug)
 813     {
 814       enum ld_plugin_status rv;
 815       ld_plugin_onload onloadfn;
 816
 817       onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
 818       if (!onloadfn)
 819         onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
 820       if (!onloadfn)
 821         einfo (_("%P%F: %s: error loading plugin: %s\n"),
 822                curplug->name, dlerror ());
 823       set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
 824       called_plugin = curplug;
 825       rv = (*onloadfn) (my_tv);
 826       called_plugin = NULL;
 827       if (rv != LDPS_OK)
 828         einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
 829       curplug = curplug->next;
 830     }
 831
 832   /* Since plugin(s) inited ok, assume they're going to want symbol
 833      resolutions, which needs us to track which symbols are referenced
 834      by non-IR files using the linker's notice callback.  */
 835   orig_notice_all = link_info.notice_all;
 836   orig_callbacks = link_info.callbacks;
 837   plugin_callbacks = *orig_callbacks;
 838   plugin_callbacks.notice = &plugin_notice;
 839   link_info.notice_all = TRUE;
 840   link_info.lto_plugin_active = TRUE;
 841   link_info.callbacks = &plugin_callbacks;
 842 }
 843
 844 /* Call 'claim file' hook for all plugins.  */
 845 static int
 846 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
 847 {
 848   plugin_t *curplug = plugins_list;
 849   *claimed = FALSE;
 850   if (no_more_claiming)
 851     return 0;
 852   while (curplug && !*claimed)
 853     {
 854       if (curplug->claim_file_handler)
 855         {
 856           enum ld_plugin_status rv;
 857           called_plugin = curplug;
 858           rv = (*curplug->claim_file_handler) (file, claimed);
 859           called_plugin = NULL;
 860           if (rv != LDPS_OK)
 861             set_plugin_error (curplug->name);
 862         }
 863       curplug = curplug->next;
 864     }
 865   return plugin_error_p () ? -1 : 0;
 866 }
 867
 868 void
 869 plugin_maybe_claim (struct ld_plugin_input_file *file,
 870                     lang_input_statement_type *entry)
 871 {
 872   int claimed = 0;
 873
 874   /* We create a dummy BFD, initially empty, to house whatever symbols
 875      the plugin may want to add.  */
 876   file->handle = plugin_get_ir_dummy_bfd (entry->the_bfd->filename,
 877                                           entry->the_bfd);
 878   if (plugin_call_claim_file (file, &claimed))
 879     einfo (_("%P%F: %s: plugin reported error claiming file\n"),
 880            plugin_error_plugin ());
 881   /* fd belongs to us, not the plugin; but we don't need it.  */
 882   close (file->fd);
 883   if (claimed)
 884     {
 885       /* Discard the real file's BFD and substitute the dummy one.  */
 886
 887       /* BFD archive handling caches elements so we can't call
 888          bfd_close for archives.  */
 889       if (entry->the_bfd->my_archive == NULL)
 890         bfd_close (entry->the_bfd);
 891       entry->the_bfd = file->handle;
 892       entry->flags.claimed = TRUE;
 893       bfd_make_readable (entry->the_bfd);
 894     }
 895   else
 896     {
 897       /* If plugin didn't claim the file, we don't need the dummy bfd.
 898          Can't avoid speculatively creating it, alas.  */
 899       bfd_close_all_done (file->handle);
 900       entry->flags.claimed = FALSE;
 901     }
 902 }
 903
 904 /* Call 'all symbols read' hook for all plugins.  */
 905 int
 906 plugin_call_all_symbols_read (void)
 907 {
 908   plugin_t *curplug = plugins_list;
 909
 910   /* Disable any further file-claiming.  */
 911   no_more_claiming = TRUE;
 912
 913   while (curplug)
 914     {
 915       if (curplug->all_symbols_read_handler)
 916         {
 917           enum ld_plugin_status rv;
 918           called_plugin = curplug;
 919           rv = (*curplug->all_symbols_read_handler) ();
 920           called_plugin = NULL;
 921           if (rv != LDPS_OK)
 922             set_plugin_error (curplug->name);
 923         }
 924       curplug = curplug->next;
 925     }
 926   return plugin_error_p () ? -1 : 0;
 927 }
 928
 929 /* Call 'cleanup' hook for all plugins at exit.  */
 930 void
 931 plugin_call_cleanup (void)
 932 {
 933   plugin_t *curplug = plugins_list;
 934   while (curplug)
 935     {
 936       if (curplug->cleanup_handler && !curplug->cleanup_done)
 937         {
 938           enum ld_plugin_status rv;
 939           curplug->cleanup_done = TRUE;
 940           called_plugin = curplug;
 941           rv = (*curplug->cleanup_handler) ();
 942           called_plugin = NULL;
 943           if (rv != LDPS_OK)
 944             info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
 945                       curplug->name, rv);
 946           dlclose (curplug->dlhandle);
 947         }
 948       curplug = curplug->next;
 949     }
 950 }
 951
 952 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
 953    and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
 954    the linker adds them to the linker hash table.  Mark those
 955    referenced from a non-IR file with non_ir_ref.  We have to
 956    notice_all symbols, because we won't necessarily know until later
 957    which ones will be contributed by IR files.  */
 958 static bfd_boolean
 959 plugin_notice (struct bfd_link_info *info,
 960                struct bfd_link_hash_entry *h,
 961                struct bfd_link_hash_entry *inh,
 962                bfd *abfd,
 963                asection *section,
 964                bfd_vma value,
 965                flagword flags)
 966 {
 967   struct bfd_link_hash_entry *orig_h = h;
 968
 969   if (h != NULL)
 970     {
 971       bfd *sym_bfd;
 972
 973       if (h->type == bfd_link_hash_warning)
 974         h = h->u.i.link;
 975
 976       /* Nothing to do here if this def/ref is from an IR dummy BFD.  */
 977       if (is_ir_dummy_bfd (abfd))
 978         ;
 979
 980       /* Making an indirect symbol counts as a reference unless this
 981          is a brand new symbol.  */
 982       else if (bfd_is_ind_section (section)
 983                || (flags & BSF_INDIRECT) != 0)
 984         {
 985           /* ??? Some of this is questionable.  See comments in
 986              _bfd_generic_link_add_one_symbol for case IND.  */
 987           if (h->type != bfd_link_hash_new)
 988             {
 989               h->non_ir_ref = TRUE;
 990               inh->non_ir_ref = TRUE;
 991             }
 992           else if (inh->type == bfd_link_hash_new)
 993             inh->non_ir_ref = TRUE;
 994         }
 995
 996       /* Nothing to do here for warning symbols.  */
 997       else if ((flags & BSF_WARNING) != 0)
 998         ;
 999
1000       /* Nothing to do here for constructor symbols.  */
1001       else if ((flags & BSF_CONSTRUCTOR) != 0)
1002         ;
1003
1004       /* If this is a ref, set non_ir_ref.  */
1005       else if (bfd_is_und_section (section))
1006         {
1007           /* Replace the undefined dummy bfd with the real one.  */
1008           if ((h->type == bfd_link_hash_undefined
1009                || h->type == bfd_link_hash_undefweak)
1010               && (h->u.undef.abfd == NULL
1011                   || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1012             h->u.undef.abfd = abfd;
1013           h->non_ir_ref = TRUE;
1014         }
1015
1016       /* Otherwise, it must be a new def.  Ensure any symbol defined
1017          in an IR dummy BFD takes on a new value from a real BFD.
1018          Weak symbols are not normally overridden by a new weak
1019          definition, and strong symbols will normally cause multiple
1020          definition errors.  Avoid this by making the symbol appear
1021          to be undefined.  */
1022       else if (((h->type == bfd_link_hash_defweak
1023                  || h->type == bfd_link_hash_defined)
1024                 && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1025                || (h->type == bfd_link_hash_common
1026                    && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1027         {
1028           h->type = bfd_link_hash_undefweak;
1029           h->u.undef.abfd = sym_bfd;
1030         }
1031     }
1032
1033   /* Continue with cref/nocrossref/trace-sym processing.  */
1034   if (orig_h == NULL
1035       || orig_notice_all
1036       || (info->notice_hash != NULL
1037           && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1038                               FALSE, FALSE) != NULL))
1039     return (*orig_callbacks->notice) (info, orig_h, inh,
1040                                       abfd, section, value, flags);
1041   return TRUE;
1042 }