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