ld/plugin.c

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