ld/plugin.c

   1 /* Plugin control for the GNU linker.
   2    Copyright (C) 2010-2016 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 "libbfd.h"
  25 #include "bfdlink.h"
  26 #include "bfdver.h"
  27 #include "ld.h"
  28 #include "ldmain.h"
  29 #include "ldmisc.h"
  30 #include "ldexp.h"
  31 #include "ldlang.h"
  32 #include "ldfile.h"
  33 #include "../bfd/plugin.h"
  34 #include "plugin.h"
  35 #include "plugin-api.h"
  36 #include "elf-bfd.h"
  37 #if HAVE_MMAP
  38 # include <sys/mman.h>
  39 # ifndef MAP_FAILED
  40 #  define MAP_FAILED ((void *) -1)
  41 # endif
  42 # ifndef PROT_READ
  43 #  define PROT_READ 0
  44 # endif
  45 # ifndef MAP_PRIVATE
  46 #  define MAP_PRIVATE 0
  47 # endif
  48 #endif
  49 #include <errno.h>
  50 #if !(defined(errno) || defined(_MSC_VER) && defined(_INC_ERRNO))
  51 extern int errno;
  52 #endif
  53 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
  54 #include <windows.h>
  55 #endif
  56
  57 /* Report plugin symbols.  */
  58 bfd_boolean report_plugin_symbols;
  59
  60 /* The suffix to append to the name of the real (claimed) object file
  61    when generating a dummy BFD to hold the IR symbols sent from the
  62    plugin.  For cosmetic use only; appears in maps, crefs etc.  */
  63 #define IRONLY_SUFFIX " (symbol from plugin)"
  64
  65 /* Stores a single argument passed to a plugin.  */
  66 typedef struct plugin_arg
  67 {
  68   struct plugin_arg *next;
  69   const char *arg;
  70 } plugin_arg_t;
  71
  72 /* Holds all details of a single plugin.  */
  73 typedef struct plugin
  74 {
  75   /* Next on the list of plugins, or NULL at end of chain.  */
  76   struct plugin *next;
  77   /* The argument string given to --plugin.  */
  78   const char *name;
  79   /* The shared library handle returned by dlopen.  */
  80   void *dlhandle;
  81   /* The list of argument string given to --plugin-opt.  */
  82   plugin_arg_t *args;
  83   /* Number of args in the list, for convenience.  */
  84   size_t n_args;
  85   /* The plugin's event handlers.  */
  86   ld_plugin_claim_file_handler claim_file_handler;
  87   ld_plugin_all_symbols_read_handler all_symbols_read_handler;
  88   ld_plugin_cleanup_handler cleanup_handler;
  89   /* TRUE if the cleanup handlers have been called.  */
  90   bfd_boolean cleanup_done;
  91 } plugin_t;
  92
  93 typedef struct view_buffer
  94 {
  95   char *addr;
  96   size_t filesize;
  97   off_t offset;
  98 } view_buffer_t;
  99
 100 /* The internal version of struct ld_plugin_input_file with a BFD
 101    pointer.  */
 102 typedef struct plugin_input_file
 103 {
 104   bfd *abfd;
 105   view_buffer_t view_buffer;
 106   char *name;
 107   int fd;
 108   bfd_boolean use_mmap;
 109   off_t offset;
 110   off_t filesize;
 111 } plugin_input_file_t;
 112
 113 /* The master list of all plugins.  */
 114 static plugin_t *plugins_list = NULL;
 115
 116 /* We keep a tail pointer for easy linking on the end.  */
 117 static plugin_t **plugins_tail_chain_ptr = &plugins_list;
 118
 119 /* The last plugin added to the list, for receiving args.  */
 120 static plugin_t *last_plugin = NULL;
 121
 122 /* The tail of the arg chain of the last plugin added to the list.  */
 123 static plugin_arg_t **last_plugin_args_tail_chain_ptr = NULL;
 124
 125 /* The plugin which is currently having a callback executed.  */
 126 static plugin_t *called_plugin = NULL;
 127
 128 /* Last plugin to cause an error, if any.  */
 129 static const char *error_plugin = NULL;
 130
 131 /* State of linker "notice" interface before we poked at it.  */
 132 static bfd_boolean orig_notice_all;
 133
 134 /* Original linker callbacks, and the plugin version.  */
 135 static const struct bfd_link_callbacks *orig_callbacks;
 136 static struct bfd_link_callbacks plugin_callbacks;
 137
 138 /* Set at all symbols read time, to avoid recursively offering the plugin
 139    its own newly-added input files and libs to claim.  */
 140 bfd_boolean no_more_claiming = FALSE;
 141
 142 #if HAVE_MMAP && HAVE_GETPAGESIZE
 143 /* Page size used by mmap.  */
 144 static off_t plugin_pagesize;
 145 #endif
 146
 147 /* List of tags to set in the constant leading part of the tv array. */
 148 static const enum ld_plugin_tag tv_header_tags[] =
 149 {
 150   LDPT_MESSAGE,
 151   LDPT_API_VERSION,
 152   LDPT_GNU_LD_VERSION,
 153   LDPT_LINKER_OUTPUT,
 154   LDPT_OUTPUT_NAME,
 155   LDPT_REGISTER_CLAIM_FILE_HOOK,
 156   LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK,
 157   LDPT_REGISTER_CLEANUP_HOOK,
 158   LDPT_ADD_SYMBOLS,
 159   LDPT_GET_INPUT_FILE,
 160   LDPT_GET_VIEW,
 161   LDPT_RELEASE_INPUT_FILE,
 162   LDPT_GET_SYMBOLS,
 163   LDPT_GET_SYMBOLS_V2,
 164   LDPT_ADD_INPUT_FILE,
 165   LDPT_ADD_INPUT_LIBRARY,
 166   LDPT_SET_EXTRA_LIBRARY_PATH
 167 };
 168
 169 /* How many entries in the constant leading part of the tv array.  */
 170 static const size_t tv_header_size = ARRAY_SIZE (tv_header_tags);
 171
 172 /* Forward references.  */
 173 static bfd_boolean plugin_notice (struct bfd_link_info *,
 174                                   struct bfd_link_hash_entry *,
 175                                   struct bfd_link_hash_entry *,
 176                                   bfd *, asection *, bfd_vma, flagword);
 177
 178 static const bfd_target * plugin_object_p (bfd *);
 179
 180 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)
 181
 182 #define RTLD_NOW 0      /* Dummy value.  */
 183
 184 static void *
 185 dlopen (const char *file, int mode ATTRIBUTE_UNUSED)
 186 {
 187   return LoadLibrary (file);
 188 }
 189
 190 static void *
 191 dlsym (void *handle, const char *name)
 192 {
 193   return GetProcAddress (handle, name);
 194 }
 195
 196 static int
 197 dlclose (void *handle)
 198 {
 199   FreeLibrary (handle);
 200   return 0;
 201 }
 202
 203 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H)  */
 204
 205 #ifndef HAVE_DLFCN_H
 206 static const char *
 207 dlerror (void)
 208 {
 209   return "";
 210 }
 211 #endif
 212
 213 /* Helper function for exiting with error status.  */
 214 static int
 215 set_plugin_error (const char *plugin)
 216 {
 217   error_plugin = plugin;
 218   return -1;
 219 }
 220
 221 /* Test if an error occurred.  */
 222 static bfd_boolean
 223 plugin_error_p (void)
 224 {
 225   return error_plugin != NULL;
 226 }
 227
 228 /* Return name of plugin which caused an error if any.  */
 229 const char *
 230 plugin_error_plugin (void)
 231 {
 232   return error_plugin ? error_plugin : _("<no plugin>");
 233 }
 234
 235 /* Handle -plugin arg: find and load plugin, or return error.  */
 236 void
 237 plugin_opt_plugin (const char *plugin)
 238 {
 239   plugin_t *newplug;
 240   plugin_t *curplug = plugins_list;
 241
 242   newplug = xmalloc (sizeof *newplug);
 243   memset (newplug, 0, sizeof *newplug);
 244   newplug->name = plugin;
 245   newplug->dlhandle = dlopen (plugin, RTLD_NOW);
 246   if (!newplug->dlhandle)
 247     einfo (_("%P%F: %s: error loading plugin: %s\n"), plugin, dlerror ());
 248
 249   /* Check if plugin has been loaded already.  */
 250   while (curplug)
 251     {
 252       if (newplug->dlhandle == curplug->dlhandle)
 253         {
 254           einfo (_("%P: %s: duplicated plugin\n"), plugin);
 255           free (newplug);
 256           return;
 257         }
 258       curplug = curplug->next;
 259     }
 260
 261   /* Chain on end, so when we run list it is in command-line order.  */
 262   *plugins_tail_chain_ptr = newplug;
 263   plugins_tail_chain_ptr = &newplug->next;
 264
 265   /* Record it as current plugin for receiving args.  */
 266   last_plugin = newplug;
 267   last_plugin_args_tail_chain_ptr = &newplug->args;
 268 }
 269
 270 /* Accumulate option arguments for last-loaded plugin, or return
 271    error if none.  */
 272 int
 273 plugin_opt_plugin_arg (const char *arg)
 274 {
 275   plugin_arg_t *newarg;
 276
 277   if (!last_plugin)
 278     return set_plugin_error (_("<no plugin>"));
 279
 280   /* Ignore -pass-through= from GCC driver.  */
 281   if (*arg == '-')
 282     {
 283       const char *p = arg + 1;
 284
 285       if (*p == '-')
 286         ++p;
 287       if (strncmp (p, "pass-through=", 13) == 0)
 288         return 0;
 289     }
 290
 291   newarg = xmalloc (sizeof *newarg);
 292   newarg->arg = arg;
 293   newarg->next = NULL;
 294
 295   /* Chain on end to preserve command-line order.  */
 296   *last_plugin_args_tail_chain_ptr = newarg;
 297   last_plugin_args_tail_chain_ptr = &newarg->next;
 298   last_plugin->n_args++;
 299   return 0;
 300 }
 301
 302 /* Generate a dummy BFD to represent an IR file, for any callers of
 303    plugin_call_claim_file to use as the handle in the ld_plugin_input_file
 304    struct that they build to pass in.  The BFD is initially writable, so
 305    that symbols can be added to it; it must be made readable after the
 306    add_symbols hook has been called so that it can be read when linking.  */
 307 static bfd *
 308 plugin_get_ir_dummy_bfd (const char *name, bfd *srctemplate)
 309 {
 310   bfd *abfd;
 311   bfd_boolean bfd_plugin_target;
 312
 313   bfd_use_reserved_id = 1;
 314   bfd_plugin_target = bfd_plugin_target_p (srctemplate->xvec);
 315   abfd = bfd_create (concat (name, IRONLY_SUFFIX, (const char *) NULL),
 316                      bfd_plugin_target ? link_info.output_bfd : srctemplate);
 317   if (abfd != NULL)
 318     {
 319       abfd->flags |= BFD_LINKER_CREATED | BFD_PLUGIN;
 320       if (!bfd_make_writable (abfd))
 321         goto report_error;
 322       if (!bfd_plugin_target)
 323         {
 324           bfd_set_arch_info (abfd, bfd_get_arch_info (srctemplate));
 325           bfd_set_gp_size (abfd, bfd_get_gp_size (srctemplate));
 326           if (!bfd_copy_private_bfd_data (srctemplate, abfd))
 327             goto report_error;
 328         }
 329         {
 330           flagword flags;
 331
 332           /* Create section to own the symbols.  */
 333           flags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 334                    | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE);
 335           if (bfd_make_section_anyway_with_flags (abfd, ".text", flags))
 336             return abfd;
 337         }
 338     }
 339 report_error:
 340   einfo (_("could not create dummy IR bfd: %F%E\n"));
 341   return NULL;
 342 }
 343
 344 /* Check if the BFD passed in is an IR dummy object file.  */
 345 static inline bfd_boolean
 346 is_ir_dummy_bfd (const bfd *abfd)
 347 {
 348   /* ABFD can sometimes legitimately be NULL, e.g. when called from one
 349      of the linker callbacks for a symbol in the *ABS* or *UND* sections.  */
 350   return abfd != NULL && (abfd->flags & BFD_PLUGIN) != 0;
 351 }
 352
 353 /* Helpers to convert between BFD and GOLD symbol formats.  */
 354 static enum ld_plugin_status
 355 asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym,
 356                             const struct ld_plugin_symbol *ldsym)
 357 {
 358   flagword flags = BSF_NO_FLAGS;
 359   struct bfd_section *section;
 360
 361   asym->the_bfd = abfd;
 362   asym->name = (ldsym->version
 363                 ? concat (ldsym->name, "@", ldsym->version, (const char *) NULL)
 364                 : ldsym->name);
 365   asym->value = 0;
 366   switch (ldsym->def)
 367     {
 368     case LDPK_WEAKDEF:
 369       flags = BSF_WEAK;
 370       /* FALLTHRU */
 371     case LDPK_DEF:
 372       flags |= BSF_GLOBAL;
 373       if (ldsym->comdat_key)
 374         {
 375           char *name = concat (".gnu.linkonce.t.", ldsym->comdat_key,
 376                                (const char *) NULL);
 377           section = bfd_get_section_by_name (abfd, name);
 378           if (section != NULL)
 379             free (name);
 380           else
 381             {
 382               flagword sflags;
 383
 384               sflags = (SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY
 385                         | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_EXCLUDE
 386                         | SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
 387               section = bfd_make_section_anyway_with_flags (abfd, name, sflags);
 388               if (section == NULL)
 389                 return LDPS_ERR;
 390             }
 391         }
 392       else
 393         section = bfd_get_section_by_name (abfd, ".text");
 394       break;
 395
 396     case LDPK_WEAKUNDEF:
 397       flags = BSF_WEAK;
 398       /* FALLTHRU */
 399     case LDPK_UNDEF:
 400       section = bfd_und_section_ptr;
 401       break;
 402
 403     case LDPK_COMMON:
 404       flags = BSF_GLOBAL;
 405       section = bfd_com_section_ptr;
 406       asym->value = ldsym->size;
 407       /* For ELF targets, set alignment of common symbol to 1.  */
 408       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 409         {
 410           ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON;
 411           ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1;
 412         }
 413       break;
 414
 415     default:
 416       return LDPS_ERR;
 417     }
 418   asym->flags = flags;
 419   asym->section = section;
 420
 421   /* Visibility only applies on ELF targets.  */
 422   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 423     {
 424       elf_symbol_type *elfsym = elf_symbol_from (abfd, asym);
 425       unsigned char visibility;
 426
 427       if (!elfsym)
 428         einfo (_("%P%F: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
 429       switch (ldsym->visibility)
 430         {
 431         default:
 432           einfo (_("%P%F: unknown ELF symbol visibility: %d!\n"),
 433                  ldsym->visibility);
 434         case LDPV_DEFAULT:
 435           visibility = STV_DEFAULT;
 436           break;
 437         case LDPV_PROTECTED:
 438           visibility = STV_PROTECTED;
 439           break;
 440         case LDPV_INTERNAL:
 441           visibility = STV_INTERNAL;
 442           break;
 443         case LDPV_HIDDEN:
 444           visibility = STV_HIDDEN;
 445           break;
 446         }
 447       elfsym->internal_elf_sym.st_other
 448         = (visibility | (elfsym->internal_elf_sym.st_other
 449                          & ~ELF_ST_VISIBILITY (-1)));
 450     }
 451
 452   return LDPS_OK;
 453 }
 454
 455 /* Register a claim-file handler.  */
 456 static enum ld_plugin_status
 457 register_claim_file (ld_plugin_claim_file_handler handler)
 458 {
 459   ASSERT (called_plugin);
 460   called_plugin->claim_file_handler = handler;
 461   return LDPS_OK;
 462 }
 463
 464 /* Register an all-symbols-read handler.  */
 465 static enum ld_plugin_status
 466 register_all_symbols_read (ld_plugin_all_symbols_read_handler handler)
 467 {
 468   ASSERT (called_plugin);
 469   called_plugin->all_symbols_read_handler = handler;
 470   return LDPS_OK;
 471 }
 472
 473 /* Register a cleanup handler.  */
 474 static enum ld_plugin_status
 475 register_cleanup (ld_plugin_cleanup_handler handler)
 476 {
 477   ASSERT (called_plugin);
 478   called_plugin->cleanup_handler = handler;
 479   return LDPS_OK;
 480 }
 481
 482 /* Add symbols from a plugin-claimed input file.  */
 483 static enum ld_plugin_status
 484 add_symbols (void *handle, int nsyms, const struct ld_plugin_symbol *syms)
 485 {
 486   asymbol **symptrs;
 487   plugin_input_file_t *input = handle;
 488   bfd *abfd = input->abfd;
 489   int n;
 490
 491   ASSERT (called_plugin);
 492   symptrs = xmalloc (nsyms * sizeof *symptrs);
 493   for (n = 0; n < nsyms; n++)
 494     {
 495       enum ld_plugin_status rv;
 496       asymbol *bfdsym;
 497
 498       bfdsym = bfd_make_empty_symbol (abfd);
 499       symptrs[n] = bfdsym;
 500       rv = asymbol_from_plugin_symbol (abfd, bfdsym, syms + n);
 501       if (rv != LDPS_OK)
 502         return rv;
 503     }
 504   bfd_set_symtab (abfd, symptrs, nsyms);
 505   return LDPS_OK;
 506 }
 507
 508 /* Get the input file information with an open (possibly re-opened)
 509    file descriptor.  */
 510 static enum ld_plugin_status
 511 get_input_file (const void *handle, struct ld_plugin_input_file *file)
 512 {
 513   const plugin_input_file_t *input = handle;
 514
 515   ASSERT (called_plugin);
 516
 517   file->name = input->name;
 518   file->offset = input->offset;
 519   file->filesize = input->filesize;
 520   file->handle = (void *) handle;
 521
 522   return LDPS_OK;
 523 }
 524
 525 /* Get view of the input file.  */
 526 static enum ld_plugin_status
 527 get_view (const void *handle, const void **viewp)
 528 {
 529   plugin_input_file_t *input = (plugin_input_file_t *) handle;
 530   char *buffer;
 531   size_t size = input->filesize;
 532   off_t offset = input->offset;
 533 #if HAVE_MMAP && HAVE_GETPAGESIZE
 534   off_t bias;
 535 #endif
 536
 537   ASSERT (called_plugin);
 538
 539   /* FIXME: einfo should support %lld.  */
 540   if ((off_t) size != input->filesize)
 541     einfo (_("%P%F: unsupported input file size: %s (%ld bytes)\n"),
 542            input->name, (long) input->filesize);
 543
 544   /* Check the cached view buffer.  */
 545   if (input->view_buffer.addr != NULL
 546       && input->view_buffer.filesize == size
 547       && input->view_buffer.offset == offset)
 548     {
 549       *viewp = input->view_buffer.addr;
 550       return LDPS_OK;
 551     }
 552
 553   input->view_buffer.filesize = size;
 554   input->view_buffer.offset = offset;
 555
 556 #if HAVE_MMAP
 557 # if HAVE_GETPAGESIZE
 558   bias = offset % plugin_pagesize;
 559   offset -= bias;
 560   size += bias;
 561 # endif
 562   buffer = mmap (NULL, size, PROT_READ, MAP_PRIVATE, input->fd, offset);
 563   if (buffer != MAP_FAILED)
 564     {
 565       input->use_mmap = TRUE;
 566 # if HAVE_GETPAGESIZE
 567       buffer += bias;
 568 # endif
 569     }
 570   else
 571 #endif
 572     {
 573       char *p;
 574
 575       input->use_mmap = FALSE;
 576
 577       if (lseek (input->fd, offset, SEEK_SET) < 0)
 578         return LDPS_ERR;
 579
 580       buffer = bfd_alloc (input->abfd, size);
 581       if (buffer == NULL)
 582         return LDPS_ERR;
 583
 584       p = buffer;
 585       do
 586         {
 587           ssize_t got = read (input->fd, p, size);
 588           if (got == 0)
 589             break;
 590           else if (got > 0)
 591             {
 592               p += got;
 593               size -= got;
 594             }
 595           else if (errno != EINTR)
 596             return LDPS_ERR;
 597         }
 598       while (size > 0);
 599     }
 600
 601   input->view_buffer.addr = buffer;
 602   *viewp = buffer;
 603
 604   return LDPS_OK;
 605 }
 606
 607 /* Release the input file.  */
 608 static enum ld_plugin_status
 609 release_input_file (const void *handle)
 610 {
 611   plugin_input_file_t *input = (plugin_input_file_t *) handle;
 612   ASSERT (called_plugin);
 613   if (input->fd != -1)
 614     {
 615       close (input->fd);
 616       input->fd = -1;
 617     }
 618   return LDPS_OK;
 619 }
 620
 621 /* Return TRUE if a defined symbol might be reachable from outside the
 622    universe of claimed objects.  */
 623 static inline bfd_boolean
 624 is_visible_from_outside (struct ld_plugin_symbol *lsym,
 625                          struct bfd_link_hash_entry *blhe)
 626 {
 627   struct bfd_sym_chain *sym;
 628
 629   if (bfd_link_relocatable (&link_info))
 630     return TRUE;
 631   if (link_info.export_dynamic || bfd_link_dll (&link_info))
 632     {
 633       /* Check if symbol is hidden by version script.  */
 634       if (bfd_hide_sym_by_version (link_info.version_info,
 635                                    blhe->root.string))
 636         return FALSE;
 637       /* Only ELF symbols really have visibility.  */
 638       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 639         {
 640           struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
 641           int vis = ELF_ST_VISIBILITY (el->other);
 642           return vis == STV_DEFAULT || vis == STV_PROTECTED;
 643         }
 644       /* On non-ELF targets, we can safely make inferences by considering
 645          what visibility the plugin would have liked to apply when it first
 646          sent us the symbol.  During ELF symbol processing, visibility only
 647          ever becomes more restrictive, not less, when symbols are merged,
 648          so this is a conservative estimate; it may give false positives,
 649          declaring something visible from outside when it in fact would
 650          not have been, but this will only lead to missed optimisation
 651          opportunities during LTRANS at worst; it will not give false
 652          negatives, which can lead to the disastrous conclusion that the
 653          related symbol is IRONLY.  (See GCC PR46319 for an example.)  */
 654       return (lsym->visibility == LDPV_DEFAULT
 655               || lsym->visibility == LDPV_PROTECTED);
 656     }
 657
 658   for (sym = &entry_symbol; sym != NULL; sym = sym->next)
 659     if (sym->name
 660         && strcmp (sym->name, blhe->root.string) == 0)
 661       return TRUE;
 662
 663   return FALSE;
 664 }
 665
 666 /* Get the symbol resolution info for a plugin-claimed input file.  */
 667 static enum ld_plugin_status
 668 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
 669              int def_ironly_exp)
 670 {
 671   const plugin_input_file_t *input = handle;
 672   const bfd *abfd = (const bfd *) input->abfd;
 673   int n;
 674
 675   ASSERT (called_plugin);
 676   for (n = 0; n < nsyms; n++)
 677     {
 678       struct bfd_link_hash_entry *blhe;
 679       asection *owner_sec;
 680       int res;
 681
 682       if (syms[n].def != LDPK_UNDEF)
 683         blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
 684                                      FALSE, FALSE, TRUE);
 685       else
 686         blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
 687                                              syms[n].name, FALSE, FALSE, TRUE);
 688       if (!blhe)
 689         {
 690           /* The plugin is called to claim symbols in an archive element
 691              from plugin_object_p.  But those symbols aren't needed to
 692              create output.  They are defined and referenced only within
 693              IR.  */
 694           switch (syms[n].def)
 695             {
 696             default:
 697               abort ();
 698             case LDPK_UNDEF:
 699             case LDPK_WEAKUNDEF:
 700               res = LDPR_UNDEF;
 701               break;
 702             case LDPK_DEF:
 703             case LDPK_WEAKDEF:
 704             case LDPK_COMMON:
 705               res = LDPR_PREVAILING_DEF_IRONLY;
 706               break;
 707             }
 708           goto report_symbol;
 709         }
 710
 711       /* Determine resolution from blhe type and symbol's original type.  */
 712       if (blhe->type == bfd_link_hash_undefined
 713           || blhe->type == bfd_link_hash_undefweak)
 714         {
 715           res = LDPR_UNDEF;
 716           goto report_symbol;
 717         }
 718       if (blhe->type != bfd_link_hash_defined
 719           && blhe->type != bfd_link_hash_defweak
 720           && blhe->type != bfd_link_hash_common)
 721         {
 722           /* We should not have a new, indirect or warning symbol here.  */
 723           einfo ("%P%F: %s: plugin symbol table corrupt (sym type %d)\n",
 724                  called_plugin->name, blhe->type);
 725         }
 726
 727       /* Find out which section owns the symbol.  Since it's not undef,
 728          it must have an owner; if it's not a common symbol, both defs
 729          and weakdefs keep it in the same place. */
 730       owner_sec = (blhe->type == bfd_link_hash_common
 731                    ? blhe->u.c.p->section
 732                    : blhe->u.def.section);
 733
 734
 735       /* If it was originally undefined or common, then it has been
 736          resolved; determine how.  */
 737       if (syms[n].def == LDPK_UNDEF
 738           || syms[n].def == LDPK_WEAKUNDEF
 739           || syms[n].def == LDPK_COMMON)
 740         {
 741           if (owner_sec->owner == link_info.output_bfd)
 742             res = LDPR_RESOLVED_EXEC;
 743           else if (owner_sec->owner == abfd)
 744             res = LDPR_PREVAILING_DEF_IRONLY;
 745           else if (is_ir_dummy_bfd (owner_sec->owner))
 746             res = LDPR_RESOLVED_IR;
 747           else if (owner_sec->owner != NULL
 748                    && (owner_sec->owner->flags & DYNAMIC) != 0)
 749             res = LDPR_RESOLVED_DYN;
 750           else
 751             res = LDPR_RESOLVED_EXEC;
 752         }
 753
 754       /* Was originally def, or weakdef.  Does it prevail?  If the
 755          owner is the original dummy bfd that supplied it, then this
 756          is the definition that has prevailed.  */
 757       else if (owner_sec->owner == link_info.output_bfd)
 758         res = LDPR_PREEMPTED_REG;
 759       else if (owner_sec->owner == abfd)
 760         res = LDPR_PREVAILING_DEF_IRONLY;
 761
 762       /* Was originally def, weakdef, or common, but has been pre-empted.  */
 763       else if (is_ir_dummy_bfd (owner_sec->owner))
 764         res = LDPR_PREEMPTED_IR;
 765       else
 766         res = LDPR_PREEMPTED_REG;
 767
 768       if (res == LDPR_PREVAILING_DEF_IRONLY)
 769         {
 770           /* We need to know if the sym is referenced from non-IR files.  Or
 771              even potentially-referenced, perhaps in a future final link if
 772              this is a partial one, perhaps dynamically at load-time if the
 773              symbol is externally visible.  */
 774           if (blhe->non_ir_ref)
 775             res = LDPR_PREVAILING_DEF;
 776           else if (is_visible_from_outside (&syms[n], blhe))
 777             res = def_ironly_exp;
 778         }
 779
 780     report_symbol:
 781       syms[n].resolution = res;
 782       if (report_plugin_symbols)
 783         einfo (_("%P: %B: symbol `%s' "
 784                  "definition: %d, visibility: %d, resolution: %d\n"),
 785                abfd, syms[n].name,
 786                syms[n].def, syms[n].visibility, res);
 787     }
 788   return LDPS_OK;
 789 }
 790
 791 static enum ld_plugin_status
 792 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 793 {
 794   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
 795 }
 796
 797 static enum ld_plugin_status
 798 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 799 {
 800   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
 801 }
 802
 803 /* Add a new (real) input file generated by a plugin.  */
 804 static enum ld_plugin_status
 805 add_input_file (const char *pathname)
 806 {
 807   lang_input_statement_type *is;
 808
 809   ASSERT (called_plugin);
 810   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
 811                             NULL);
 812   if (!is)
 813     return LDPS_ERR;
 814   is->flags.lto_output = 1;
 815   return LDPS_OK;
 816 }
 817
 818 /* Add a new (real) library required by a plugin.  */
 819 static enum ld_plugin_status
 820 add_input_library (const char *pathname)
 821 {
 822   lang_input_statement_type *is;
 823
 824   ASSERT (called_plugin);
 825   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
 826                             NULL);
 827   if (!is)
 828     return LDPS_ERR;
 829   is->flags.lto_output = 1;
 830   return LDPS_OK;
 831 }
 832
 833 /* Set the extra library path to be used by libraries added via
 834    add_input_library.  */
 835 static enum ld_plugin_status
 836 set_extra_library_path (const char *path)
 837 {
 838   ASSERT (called_plugin);
 839   ldfile_add_library_path (xstrdup (path), FALSE);
 840   return LDPS_OK;
 841 }
 842
 843 /* Issue a diagnostic message from a plugin.  */
 844 static enum ld_plugin_status
 845 message (int level, const char *format, ...)
 846 {
 847   va_list args;
 848   va_start (args, format);
 849
 850   switch (level)
 851     {
 852     case LDPL_INFO:
 853       vfinfo (stdout, format, args, FALSE);
 854       putchar ('\n');
 855       break;
 856     case LDPL_WARNING:
 857       {
 858         char *newfmt = concat ("%P: warning: ", format, "\n",
 859                                (const char *) NULL);
 860         vfinfo (stdout, newfmt, args, TRUE);
 861         free (newfmt);
 862       }
 863       break;
 864     case LDPL_FATAL:
 865     case LDPL_ERROR:
 866     default:
 867       {
 868         char *newfmt = concat (level == LDPL_FATAL ? "%P%F" : "%P%X",
 869                                ": error: ", format, "\n",
 870                                (const char *) NULL);
 871         fflush (stdout);
 872         vfinfo (stderr, newfmt, args, TRUE);
 873         fflush (stderr);
 874         free (newfmt);
 875       }
 876       break;
 877     }
 878
 879   va_end (args);
 880   return LDPS_OK;
 881 }
 882
 883 /* Helper to size leading part of tv array and set it up. */
 884 static void
 885 set_tv_header (struct ld_plugin_tv *tv)
 886 {
 887   size_t i;
 888
 889   /* Version info.  */
 890   static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
 891   static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
 892
 893   for (i = 0; i < tv_header_size; i++)
 894     {
 895       tv[i].tv_tag = tv_header_tags[i];
 896 #define TVU(x) tv[i].tv_u.tv_ ## x
 897       switch (tv[i].tv_tag)
 898         {
 899         case LDPT_MESSAGE:
 900           TVU(message) = message;
 901           break;
 902         case LDPT_API_VERSION:
 903           TVU(val) = LD_PLUGIN_API_VERSION;
 904           break;
 905         case LDPT_GNU_LD_VERSION:
 906           TVU(val) = major * 100 + minor;
 907           break;
 908         case LDPT_LINKER_OUTPUT:
 909           TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
 910                       : bfd_link_pde (&link_info) ? LDPO_EXEC
 911                       : bfd_link_pie (&link_info) ? LDPO_PIE
 912                       : LDPO_DYN);
 913           break;
 914         case LDPT_OUTPUT_NAME:
 915           TVU(string) = output_filename;
 916           break;
 917         case LDPT_REGISTER_CLAIM_FILE_HOOK:
 918           TVU(register_claim_file) = register_claim_file;
 919           break;
 920         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 921           TVU(register_all_symbols_read) = register_all_symbols_read;
 922           break;
 923         case LDPT_REGISTER_CLEANUP_HOOK:
 924           TVU(register_cleanup) = register_cleanup;
 925           break;
 926         case LDPT_ADD_SYMBOLS:
 927           TVU(add_symbols) = add_symbols;
 928           break;
 929         case LDPT_GET_INPUT_FILE:
 930           TVU(get_input_file) = get_input_file;
 931           break;
 932         case LDPT_GET_VIEW:
 933           TVU(get_view) = get_view;
 934           break;
 935         case LDPT_RELEASE_INPUT_FILE:
 936           TVU(release_input_file) = release_input_file;
 937           break;
 938         case LDPT_GET_SYMBOLS:
 939           TVU(get_symbols) = get_symbols_v1;
 940           break;
 941         case LDPT_GET_SYMBOLS_V2:
 942           TVU(get_symbols) = get_symbols_v2;
 943           break;
 944         case LDPT_ADD_INPUT_FILE:
 945           TVU(add_input_file) = add_input_file;
 946           break;
 947         case LDPT_ADD_INPUT_LIBRARY:
 948           TVU(add_input_library) = add_input_library;
 949           break;
 950         case LDPT_SET_EXTRA_LIBRARY_PATH:
 951           TVU(set_extra_library_path) = set_extra_library_path;
 952           break;
 953         default:
 954           /* Added a new entry to the array without adding
 955              a new case to set up its value is a bug.  */
 956           FAIL ();
 957         }
 958 #undef TVU
 959     }
 960 }
 961
 962 /* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
 963 static void
 964 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
 965 {
 966   plugin_arg_t *arg = plugin->args;
 967   while (arg)
 968     {
 969       tv->tv_tag = LDPT_OPTION;
 970       tv->tv_u.tv_string = arg->arg;
 971       arg = arg->next;
 972       tv++;
 973     }
 974   tv->tv_tag = LDPT_NULL;
 975   tv->tv_u.tv_val = 0;
 976 }
 977
 978 /* Load up and initialise all plugins after argument parsing.  */
 979 void
 980 plugin_load_plugins (void)
 981 {
 982   struct ld_plugin_tv *my_tv;
 983   unsigned int max_args = 0;
 984   plugin_t *curplug = plugins_list;
 985
 986   /* If there are no plugins, we need do nothing this run.  */
 987   if (!curplug)
 988     return;
 989
 990   /* First pass over plugins to find max # args needed so that we
 991      can size and allocate the tv array.  */
 992   while (curplug)
 993     {
 994       if (curplug->n_args > max_args)
 995         max_args = curplug->n_args;
 996       curplug = curplug->next;
 997     }
 998
 999   /* Allocate tv array and initialise constant part.  */
1000   my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
1001   set_tv_header (my_tv);
1002
1003   /* Pass over plugins again, activating them.  */
1004   curplug = plugins_list;
1005   while (curplug)
1006     {
1007       enum ld_plugin_status rv;
1008       ld_plugin_onload onloadfn;
1009
1010       onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
1011       if (!onloadfn)
1012         onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
1013       if (!onloadfn)
1014         einfo (_("%P%F: %s: error loading plugin: %s\n"),
1015                curplug->name, dlerror ());
1016       set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
1017       called_plugin = curplug;
1018       rv = (*onloadfn) (my_tv);
1019       called_plugin = NULL;
1020       if (rv != LDPS_OK)
1021         einfo (_("%P%F: %s: plugin error: %d\n"), curplug->name, rv);
1022       curplug = curplug->next;
1023     }
1024
1025   /* Since plugin(s) inited ok, assume they're going to want symbol
1026      resolutions, which needs us to track which symbols are referenced
1027      by non-IR files using the linker's notice callback.  */
1028   orig_notice_all = link_info.notice_all;
1029   orig_callbacks = link_info.callbacks;
1030   plugin_callbacks = *orig_callbacks;
1031   plugin_callbacks.notice = &plugin_notice;
1032   link_info.notice_all = TRUE;
1033   link_info.lto_plugin_active = TRUE;
1034   link_info.callbacks = &plugin_callbacks;
1035
1036   register_ld_plugin_object_p (plugin_object_p);
1037
1038 #if HAVE_MMAP && HAVE_GETPAGESIZE
1039   plugin_pagesize = getpagesize ();
1040 #endif
1041 }
1042
1043 /* Call 'claim file' hook for all plugins.  */
1044 static int
1045 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1046 {
1047   plugin_t *curplug = plugins_list;
1048   *claimed = FALSE;
1049   while (curplug && !*claimed)
1050     {
1051       if (curplug->claim_file_handler)
1052         {
1053           enum ld_plugin_status rv;
1054           called_plugin = curplug;
1055           rv = (*curplug->claim_file_handler) (file, claimed);
1056           called_plugin = NULL;
1057           if (rv != LDPS_OK)
1058             set_plugin_error (curplug->name);
1059         }
1060       curplug = curplug->next;
1061     }
1062   return plugin_error_p () ? -1 : 0;
1063 }
1064
1065 /* Duplicates a character string with memory attached to ABFD.  */
1066
1067 static char *
1068 plugin_strdup (bfd *abfd, const char *str)
1069 {
1070   size_t strlength;
1071   char *copy;
1072   strlength = strlen (str) + 1;
1073   copy = bfd_alloc (abfd, strlength);
1074   if (copy == NULL)
1075     einfo (_("%P%F: plugin_strdup failed to allocate memory: %s\n"),
1076            bfd_get_error ());
1077   memcpy (copy, str, strlength);
1078   return copy;
1079 }
1080
1081 static const bfd_target *
1082 plugin_object_p (bfd *ibfd)
1083 {
1084   int claimed;
1085   plugin_input_file_t *input;
1086   off_t offset, filesize;
1087   struct ld_plugin_input_file file;
1088   bfd *abfd;
1089   bfd_boolean inarchive;
1090   const char *name;
1091   int fd;
1092
1093   /* Don't try the dummy object file.  */
1094   if ((ibfd->flags & BFD_PLUGIN) != 0)
1095     return NULL;
1096
1097   if (ibfd->plugin_format != bfd_plugin_unknown)
1098     {
1099       if (ibfd->plugin_format == bfd_plugin_yes)
1100         return ibfd->plugin_dummy_bfd->xvec;
1101       else
1102         return NULL;
1103     }
1104
1105   inarchive = (ibfd->my_archive != NULL
1106                && !bfd_is_thin_archive (ibfd->my_archive));
1107   name = inarchive ? ibfd->my_archive->filename : ibfd->filename;
1108   fd = open (name, O_RDONLY | O_BINARY);
1109
1110   if (fd < 0)
1111     return NULL;
1112
1113   /* We create a dummy BFD, initially empty, to house whatever symbols
1114      the plugin may want to add.  */
1115   abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1116
1117   input = bfd_alloc (abfd, sizeof (*input));
1118   if (input == NULL)
1119     einfo (_("%P%F: plugin failed to allocate memory for input: %s\n"),
1120            bfd_get_error ());
1121
1122   if (inarchive)
1123     {
1124       /* Offset and filesize must refer to the individual archive
1125          member, not the whole file, and must exclude the header.
1126          Fortunately for us, that is how the data is stored in the
1127          origin field of the bfd and in the arelt_data.  */
1128       offset = ibfd->origin;
1129       filesize = arelt_size (ibfd);
1130     }
1131   else
1132     {
1133       offset = 0;
1134       filesize = lseek (fd, 0, SEEK_END);
1135
1136       /* We must copy filename attached to ibfd if it is not an archive
1137          member since it may be freed by bfd_close below.  */
1138       name = plugin_strdup (abfd, name);
1139     }
1140
1141   file.name = name;
1142   file.offset = offset;
1143   file.filesize = filesize;
1144   file.fd = fd;
1145   file.handle = input;
1146
1147   input->abfd = abfd;
1148   input->view_buffer.addr = NULL;
1149   input->view_buffer.filesize = 0;
1150   input->view_buffer.offset = 0;
1151   input->fd = fd;
1152   input->use_mmap = FALSE;
1153   input->offset = offset;
1154   input->filesize = filesize;
1155   input->name = plugin_strdup (abfd, ibfd->filename);
1156
1157   claimed = 0;
1158
1159   if (plugin_call_claim_file (&file, &claimed))
1160     einfo (_("%P%F: %s: plugin reported error claiming file\n"),
1161            plugin_error_plugin ());
1162
1163   if (input->fd != -1 && ! bfd_plugin_target_p (ibfd->xvec))
1164     {
1165       /* FIXME: fd belongs to us, not the plugin.  GCC plugin, which
1166          doesn't need fd after plugin_call_claim_file, doesn't use
1167          BFD plugin target vector.  Since GCC plugin doesn't call
1168          release_input_file, we close it here.  LLVM plugin, which
1169          needs fd after plugin_call_claim_file and calls
1170          release_input_file after it is done, uses BFD plugin target
1171          vector.  This scheme doesn't work when a plugin needs fd and
1172          doesn't use BFD plugin target vector neither.  */
1173       close (fd);
1174       input->fd = -1;
1175     }
1176
1177   if (claimed)
1178     {
1179       ibfd->plugin_format = bfd_plugin_yes;
1180       ibfd->plugin_dummy_bfd = abfd;
1181       bfd_make_readable (abfd);
1182       return abfd->xvec;
1183     }
1184   else
1185     {
1186 #if HAVE_MMAP
1187       if (input->use_mmap)
1188         {
1189           /* If plugin didn't claim the file, unmap the buffer.  */
1190           char *addr = input->view_buffer.addr;
1191           off_t size = input->view_buffer.filesize;
1192 # if HAVE_GETPAGESIZE
1193           off_t bias = input->view_buffer.offset % plugin_pagesize;
1194           size += bias;
1195           addr -= bias;
1196 # endif
1197           munmap (addr, size);
1198         }
1199 #endif
1200
1201       /* If plugin didn't claim the file, we don't need the dummy bfd.
1202          Can't avoid speculatively creating it, alas.  */
1203       ibfd->plugin_format = bfd_plugin_no;
1204       bfd_close_all_done (abfd);
1205       return NULL;
1206     }
1207 }
1208
1209 void
1210 plugin_maybe_claim (lang_input_statement_type *entry)
1211 {
1212   if (plugin_object_p (entry->the_bfd))
1213     {
1214       bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1215
1216       /* Discard the real file's BFD and substitute the dummy one.  */
1217
1218       /* We can't call bfd_close on archives.  BFD archive handling
1219          caches elements, and add_archive_element keeps pointers to
1220          the_bfd and the_bfd->filename in a lang_input_statement_type
1221          linker script statement.  */
1222       if (entry->the_bfd->my_archive == NULL)
1223         bfd_close (entry->the_bfd);
1224       entry->the_bfd = abfd;
1225       entry->flags.claimed = 1;
1226     }
1227 }
1228
1229 /* Call 'all symbols read' hook for all plugins.  */
1230 int
1231 plugin_call_all_symbols_read (void)
1232 {
1233   plugin_t *curplug = plugins_list;
1234
1235   /* Disable any further file-claiming.  */
1236   no_more_claiming = TRUE;
1237
1238   while (curplug)
1239     {
1240       if (curplug->all_symbols_read_handler)
1241         {
1242           enum ld_plugin_status rv;
1243           called_plugin = curplug;
1244           rv = (*curplug->all_symbols_read_handler) ();
1245           called_plugin = NULL;
1246           if (rv != LDPS_OK)
1247             set_plugin_error (curplug->name);
1248         }
1249       curplug = curplug->next;
1250     }
1251   return plugin_error_p () ? -1 : 0;
1252 }
1253
1254 /* Call 'cleanup' hook for all plugins at exit.  */
1255 void
1256 plugin_call_cleanup (void)
1257 {
1258   plugin_t *curplug = plugins_list;
1259   while (curplug)
1260     {
1261       if (curplug->cleanup_handler && !curplug->cleanup_done)
1262         {
1263           enum ld_plugin_status rv;
1264           curplug->cleanup_done = TRUE;
1265           called_plugin = curplug;
1266           rv = (*curplug->cleanup_handler) ();
1267           called_plugin = NULL;
1268           if (rv != LDPS_OK)
1269             info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1270                       curplug->name, rv);
1271           dlclose (curplug->dlhandle);
1272         }
1273       curplug = curplug->next;
1274     }
1275 }
1276
1277 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1278    and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1279    the linker adds them to the linker hash table.  Mark those
1280    referenced from a non-IR file with non_ir_ref.  We have to
1281    notice_all symbols, because we won't necessarily know until later
1282    which ones will be contributed by IR files.  */
1283 static bfd_boolean
1284 plugin_notice (struct bfd_link_info *info,
1285                struct bfd_link_hash_entry *h,
1286                struct bfd_link_hash_entry *inh,
1287                bfd *abfd,
1288                asection *section,
1289                bfd_vma value,
1290                flagword flags)
1291 {
1292   struct bfd_link_hash_entry *orig_h = h;
1293
1294   if (h != NULL)
1295     {
1296       bfd *sym_bfd;
1297
1298       if (h->type == bfd_link_hash_warning)
1299         h = h->u.i.link;
1300
1301       /* Nothing to do here if this def/ref is from an IR dummy BFD.  */
1302       if (is_ir_dummy_bfd (abfd))
1303         ;
1304
1305       /* Making an indirect symbol counts as a reference unless this
1306          is a brand new symbol.  */
1307       else if (bfd_is_ind_section (section)
1308                || (flags & BSF_INDIRECT) != 0)
1309         {
1310           /* ??? Some of this is questionable.  See comments in
1311              _bfd_generic_link_add_one_symbol for case IND.  */
1312           if (h->type != bfd_link_hash_new)
1313             {
1314               h->non_ir_ref = TRUE;
1315               inh->non_ir_ref = TRUE;
1316             }
1317           else if (inh->type == bfd_link_hash_new)
1318             inh->non_ir_ref = TRUE;
1319         }
1320
1321       /* Nothing to do here for warning symbols.  */
1322       else if ((flags & BSF_WARNING) != 0)
1323         ;
1324
1325       /* Nothing to do here for constructor symbols.  */
1326       else if ((flags & BSF_CONSTRUCTOR) != 0)
1327         ;
1328
1329       /* If this is a ref, set non_ir_ref.  */
1330       else if (bfd_is_und_section (section))
1331         {
1332           /* Replace the undefined dummy bfd with the real one.  */
1333           if ((h->type == bfd_link_hash_undefined
1334                || h->type == bfd_link_hash_undefweak)
1335               && (h->u.undef.abfd == NULL
1336                   || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1337             h->u.undef.abfd = abfd;
1338           h->non_ir_ref = TRUE;
1339         }
1340
1341       /* Otherwise, it must be a new def.  */
1342       else
1343         {
1344           /* A common symbol should be merged with other commons or
1345              defs with the same name.  In particular, a common ought
1346              to be overridden by a def in a -flto object.  In that
1347              sense a common is also a ref.  */
1348           if (bfd_is_com_section (section))
1349             h->non_ir_ref = TRUE;
1350
1351           /* Ensure any symbol defined in an IR dummy BFD takes on a
1352              new value from a real BFD.  Weak symbols are not normally
1353              overridden by a new weak definition, and strong symbols
1354              will normally cause multiple definition errors.  Avoid
1355              this by making the symbol appear to be undefined.  */
1356           if (((h->type == bfd_link_hash_defweak
1357                 || h->type == bfd_link_hash_defined)
1358                && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1359               || (h->type == bfd_link_hash_common
1360                   && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1361             {
1362               h->type = bfd_link_hash_undefweak;
1363               h->u.undef.abfd = sym_bfd;
1364             }
1365         }
1366     }
1367
1368   /* Continue with cref/nocrossref/trace-sym processing.  */
1369   if (orig_h == NULL
1370       || orig_notice_all
1371       || (info->notice_hash != NULL
1372           && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1373                               FALSE, FALSE) != NULL))
1374     return (*orig_callbacks->notice) (info, orig_h, inh,
1375                                       abfd, section, value, flags);
1376   return TRUE;
1377 }