ld/plugin.c

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