ld/plugin.c

   1 /* Plugin control for the GNU linker.
   2    Copyright (C) 2010-2018 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 (_("%F%P: %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 (_("%F%P: could not create dummy IR bfd: %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 (_("%F%P: %s: non-ELF symbol in ELF BFD!\n"), asym->name);
 428       switch (ldsym->visibility)
 429         {
 430         default:
 431           einfo (_("%F%P: 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 (_("%F%P: 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   if (bfd_link_relocatable (&link_info))
 629     return TRUE;
 630   if (blhe->non_ir_ref_dynamic
 631       || link_info.export_dynamic
 632       || bfd_link_dll (&link_info))
 633     {
 634       /* Check if symbol is hidden by version script.  */
 635       if (bfd_hide_sym_by_version (link_info.version_info,
 636                                    blhe->root.string))
 637         return FALSE;
 638       /* Only ELF symbols really have visibility.  */
 639       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
 640         {
 641           struct elf_link_hash_entry *el = (struct elf_link_hash_entry *)blhe;
 642           int vis = ELF_ST_VISIBILITY (el->other);
 643           return vis == STV_DEFAULT || vis == STV_PROTECTED;
 644         }
 645       /* On non-ELF targets, we can safely make inferences by considering
 646          what visibility the plugin would have liked to apply when it first
 647          sent us the symbol.  During ELF symbol processing, visibility only
 648          ever becomes more restrictive, not less, when symbols are merged,
 649          so this is a conservative estimate; it may give false positives,
 650          declaring something visible from outside when it in fact would
 651          not have been, but this will only lead to missed optimisation
 652          opportunities during LTRANS at worst; it will not give false
 653          negatives, which can lead to the disastrous conclusion that the
 654          related symbol is IRONLY.  (See GCC PR46319 for an example.)  */
 655       return (lsym->visibility == LDPV_DEFAULT
 656               || lsym->visibility == LDPV_PROTECTED);
 657     }
 658
 659   return FALSE;
 660 }
 661
 662 /* Get the symbol resolution info for a plugin-claimed input file.  */
 663 static enum ld_plugin_status
 664 get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms,
 665              int def_ironly_exp)
 666 {
 667   const plugin_input_file_t *input = handle;
 668   const bfd *abfd = (const bfd *) input->abfd;
 669   int n;
 670
 671   ASSERT (called_plugin);
 672   for (n = 0; n < nsyms; n++)
 673     {
 674       struct bfd_link_hash_entry *blhe;
 675       asection *owner_sec;
 676       int res;
 677
 678       if (syms[n].def != LDPK_UNDEF)
 679         blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name,
 680                                      FALSE, FALSE, TRUE);
 681       else
 682         blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info,
 683                                              syms[n].name, FALSE, FALSE, TRUE);
 684       if (!blhe)
 685         {
 686           /* The plugin is called to claim symbols in an archive element
 687              from plugin_object_p.  But those symbols aren't needed to
 688              create output.  They are defined and referenced only within
 689              IR.  */
 690           switch (syms[n].def)
 691             {
 692             default:
 693               abort ();
 694             case LDPK_UNDEF:
 695             case LDPK_WEAKUNDEF:
 696               res = LDPR_UNDEF;
 697               break;
 698             case LDPK_DEF:
 699             case LDPK_WEAKDEF:
 700             case LDPK_COMMON:
 701               res = LDPR_PREVAILING_DEF_IRONLY;
 702               break;
 703             }
 704           goto report_symbol;
 705         }
 706
 707       /* Determine resolution from blhe type and symbol's original type.  */
 708       if (blhe->type == bfd_link_hash_undefined
 709           || blhe->type == bfd_link_hash_undefweak)
 710         {
 711           res = LDPR_UNDEF;
 712           goto report_symbol;
 713         }
 714       if (blhe->type != bfd_link_hash_defined
 715           && blhe->type != bfd_link_hash_defweak
 716           && blhe->type != bfd_link_hash_common)
 717         {
 718           /* We should not have a new, indirect or warning symbol here.  */
 719           einfo (_("%F%P: %s: plugin symbol table corrupt (sym type %d)\n"),
 720                  called_plugin->name, blhe->type);
 721         }
 722
 723       /* Find out which section owns the symbol.  Since it's not undef,
 724          it must have an owner; if it's not a common symbol, both defs
 725          and weakdefs keep it in the same place. */
 726       owner_sec = (blhe->type == bfd_link_hash_common
 727                    ? blhe->u.c.p->section
 728                    : blhe->u.def.section);
 729
 730
 731       /* If it was originally undefined or common, then it has been
 732          resolved; determine how.  */
 733       if (syms[n].def == LDPK_UNDEF
 734           || syms[n].def == LDPK_WEAKUNDEF
 735           || syms[n].def == LDPK_COMMON)
 736         {
 737           if (owner_sec->owner == link_info.output_bfd)
 738             res = LDPR_RESOLVED_EXEC;
 739           else if (owner_sec->owner == abfd)
 740             res = LDPR_PREVAILING_DEF_IRONLY;
 741           else if (is_ir_dummy_bfd (owner_sec->owner))
 742             res = LDPR_RESOLVED_IR;
 743           else if (owner_sec->owner != NULL
 744                    && (owner_sec->owner->flags & DYNAMIC) != 0)
 745             res = LDPR_RESOLVED_DYN;
 746           else
 747             res = LDPR_RESOLVED_EXEC;
 748         }
 749
 750       /* Was originally def, or weakdef.  Does it prevail?  If the
 751          owner is the original dummy bfd that supplied it, then this
 752          is the definition that has prevailed.  */
 753       else if (owner_sec->owner == link_info.output_bfd)
 754         res = LDPR_PREEMPTED_REG;
 755       else if (owner_sec->owner == abfd)
 756         res = LDPR_PREVAILING_DEF_IRONLY;
 757
 758       /* Was originally def, weakdef, or common, but has been pre-empted.  */
 759       else if (is_ir_dummy_bfd (owner_sec->owner))
 760         res = LDPR_PREEMPTED_IR;
 761       else
 762         res = LDPR_PREEMPTED_REG;
 763
 764       if (res == LDPR_PREVAILING_DEF_IRONLY)
 765         {
 766           /* We need to know if the sym is referenced from non-IR files.  Or
 767              even potentially-referenced, perhaps in a future final link if
 768              this is a partial one, perhaps dynamically at load-time if the
 769              symbol is externally visible.  */
 770           if (blhe->non_ir_ref_regular)
 771             res = LDPR_PREVAILING_DEF;
 772           else if (is_visible_from_outside (&syms[n], blhe))
 773             res = def_ironly_exp;
 774         }
 775
 776     report_symbol:
 777       syms[n].resolution = res;
 778       if (report_plugin_symbols)
 779         einfo (_("%P: %pB: symbol `%s' "
 780                  "definition: %d, visibility: %d, resolution: %d\n"),
 781                abfd, syms[n].name,
 782                syms[n].def, syms[n].visibility, res);
 783     }
 784   return LDPS_OK;
 785 }
 786
 787 static enum ld_plugin_status
 788 get_symbols_v1 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 789 {
 790   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF);
 791 }
 792
 793 static enum ld_plugin_status
 794 get_symbols_v2 (const void *handle, int nsyms, struct ld_plugin_symbol *syms)
 795 {
 796   return get_symbols (handle, nsyms, syms, LDPR_PREVAILING_DEF_IRONLY_EXP);
 797 }
 798
 799 /* Add a new (real) input file generated by a plugin.  */
 800 static enum ld_plugin_status
 801 add_input_file (const char *pathname)
 802 {
 803   lang_input_statement_type *is;
 804
 805   ASSERT (called_plugin);
 806   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_file_enum,
 807                             NULL);
 808   if (!is)
 809     return LDPS_ERR;
 810   is->flags.lto_output = 1;
 811   return LDPS_OK;
 812 }
 813
 814 /* Add a new (real) library required by a plugin.  */
 815 static enum ld_plugin_status
 816 add_input_library (const char *pathname)
 817 {
 818   lang_input_statement_type *is;
 819
 820   ASSERT (called_plugin);
 821   is = lang_add_input_file (xstrdup (pathname), lang_input_file_is_l_enum,
 822                             NULL);
 823   if (!is)
 824     return LDPS_ERR;
 825   is->flags.lto_output = 1;
 826   return LDPS_OK;
 827 }
 828
 829 /* Set the extra library path to be used by libraries added via
 830    add_input_library.  */
 831 static enum ld_plugin_status
 832 set_extra_library_path (const char *path)
 833 {
 834   ASSERT (called_plugin);
 835   ldfile_add_library_path (xstrdup (path), FALSE);
 836   return LDPS_OK;
 837 }
 838
 839 /* Issue a diagnostic message from a plugin.  */
 840 static enum ld_plugin_status
 841 message (int level, const char *format, ...)
 842 {
 843   va_list args;
 844   va_start (args, format);
 845
 846   switch (level)
 847     {
 848     case LDPL_INFO:
 849       vfinfo (stdout, format, args, FALSE);
 850       putchar ('\n');
 851       break;
 852     case LDPL_WARNING:
 853       {
 854         char *newfmt = concat (_("%P: warning: "), format, "\n",
 855                                (const char *) NULL);
 856         vfinfo (stdout, newfmt, args, TRUE);
 857         free (newfmt);
 858       }
 859       break;
 860     case LDPL_FATAL:
 861     case LDPL_ERROR:
 862     default:
 863       {
 864         char *newfmt = concat (level == LDPL_FATAL ? "%F" : "%X",
 865                                _("%P: error: "), format, "\n",
 866                                (const char *) NULL);
 867         fflush (stdout);
 868         vfinfo (stderr, newfmt, args, TRUE);
 869         fflush (stderr);
 870         free (newfmt);
 871       }
 872       break;
 873     }
 874
 875   va_end (args);
 876   return LDPS_OK;
 877 }
 878
 879 /* Helper to size leading part of tv array and set it up. */
 880 static void
 881 set_tv_header (struct ld_plugin_tv *tv)
 882 {
 883   size_t i;
 884
 885   /* Version info.  */
 886   static const unsigned int major = (unsigned)(BFD_VERSION / 100000000UL);
 887   static const unsigned int minor = (unsigned)(BFD_VERSION / 1000000UL) % 100;
 888
 889   for (i = 0; i < tv_header_size; i++)
 890     {
 891       tv[i].tv_tag = tv_header_tags[i];
 892 #define TVU(x) tv[i].tv_u.tv_ ## x
 893       switch (tv[i].tv_tag)
 894         {
 895         case LDPT_MESSAGE:
 896           TVU(message) = message;
 897           break;
 898         case LDPT_API_VERSION:
 899           TVU(val) = LD_PLUGIN_API_VERSION;
 900           break;
 901         case LDPT_GNU_LD_VERSION:
 902           TVU(val) = major * 100 + minor;
 903           break;
 904         case LDPT_LINKER_OUTPUT:
 905           TVU(val) = (bfd_link_relocatable (&link_info) ? LDPO_REL
 906                       : bfd_link_pde (&link_info) ? LDPO_EXEC
 907                       : bfd_link_pie (&link_info) ? LDPO_PIE
 908                       : LDPO_DYN);
 909           break;
 910         case LDPT_OUTPUT_NAME:
 911           TVU(string) = output_filename;
 912           break;
 913         case LDPT_REGISTER_CLAIM_FILE_HOOK:
 914           TVU(register_claim_file) = register_claim_file;
 915           break;
 916         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 917           TVU(register_all_symbols_read) = register_all_symbols_read;
 918           break;
 919         case LDPT_REGISTER_CLEANUP_HOOK:
 920           TVU(register_cleanup) = register_cleanup;
 921           break;
 922         case LDPT_ADD_SYMBOLS:
 923           TVU(add_symbols) = add_symbols;
 924           break;
 925         case LDPT_GET_INPUT_FILE:
 926           TVU(get_input_file) = get_input_file;
 927           break;
 928         case LDPT_GET_VIEW:
 929           TVU(get_view) = get_view;
 930           break;
 931         case LDPT_RELEASE_INPUT_FILE:
 932           TVU(release_input_file) = release_input_file;
 933           break;
 934         case LDPT_GET_SYMBOLS:
 935           TVU(get_symbols) = get_symbols_v1;
 936           break;
 937         case LDPT_GET_SYMBOLS_V2:
 938           TVU(get_symbols) = get_symbols_v2;
 939           break;
 940         case LDPT_ADD_INPUT_FILE:
 941           TVU(add_input_file) = add_input_file;
 942           break;
 943         case LDPT_ADD_INPUT_LIBRARY:
 944           TVU(add_input_library) = add_input_library;
 945           break;
 946         case LDPT_SET_EXTRA_LIBRARY_PATH:
 947           TVU(set_extra_library_path) = set_extra_library_path;
 948           break;
 949         default:
 950           /* Added a new entry to the array without adding
 951              a new case to set up its value is a bug.  */
 952           FAIL ();
 953         }
 954 #undef TVU
 955     }
 956 }
 957
 958 /* Append the per-plugin args list and trailing LDPT_NULL to tv.  */
 959 static void
 960 set_tv_plugin_args (plugin_t *plugin, struct ld_plugin_tv *tv)
 961 {
 962   plugin_arg_t *arg = plugin->args;
 963   while (arg)
 964     {
 965       tv->tv_tag = LDPT_OPTION;
 966       tv->tv_u.tv_string = arg->arg;
 967       arg = arg->next;
 968       tv++;
 969     }
 970   tv->tv_tag = LDPT_NULL;
 971   tv->tv_u.tv_val = 0;
 972 }
 973
 974 /* Load up and initialise all plugins after argument parsing.  */
 975 void
 976 plugin_load_plugins (void)
 977 {
 978   struct ld_plugin_tv *my_tv;
 979   unsigned int max_args = 0;
 980   plugin_t *curplug = plugins_list;
 981
 982   /* If there are no plugins, we need do nothing this run.  */
 983   if (!curplug)
 984     return;
 985
 986   /* First pass over plugins to find max # args needed so that we
 987      can size and allocate the tv array.  */
 988   while (curplug)
 989     {
 990       if (curplug->n_args > max_args)
 991         max_args = curplug->n_args;
 992       curplug = curplug->next;
 993     }
 994
 995   /* Allocate tv array and initialise constant part.  */
 996   my_tv = xmalloc ((max_args + 1 + tv_header_size) * sizeof *my_tv);
 997   set_tv_header (my_tv);
 998
 999   /* Pass over plugins again, activating them.  */
1000   curplug = plugins_list;
1001   while (curplug)
1002     {
1003       enum ld_plugin_status rv;
1004       ld_plugin_onload onloadfn;
1005
1006       onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "onload");
1007       if (!onloadfn)
1008         onloadfn = (ld_plugin_onload) dlsym (curplug->dlhandle, "_onload");
1009       if (!onloadfn)
1010         einfo (_("%F%P: %s: error loading plugin: %s\n"),
1011                curplug->name, dlerror ());
1012       set_tv_plugin_args (curplug, &my_tv[tv_header_size]);
1013       called_plugin = curplug;
1014       rv = (*onloadfn) (my_tv);
1015       called_plugin = NULL;
1016       if (rv != LDPS_OK)
1017         einfo (_("%F%P: %s: plugin error: %d\n"), curplug->name, rv);
1018       curplug = curplug->next;
1019     }
1020
1021   /* Since plugin(s) inited ok, assume they're going to want symbol
1022      resolutions, which needs us to track which symbols are referenced
1023      by non-IR files using the linker's notice callback.  */
1024   orig_notice_all = link_info.notice_all;
1025   orig_callbacks = link_info.callbacks;
1026   plugin_callbacks = *orig_callbacks;
1027   plugin_callbacks.notice = &plugin_notice;
1028   link_info.notice_all = TRUE;
1029   link_info.lto_plugin_active = TRUE;
1030   link_info.callbacks = &plugin_callbacks;
1031
1032   register_ld_plugin_object_p (plugin_object_p);
1033
1034 #if HAVE_MMAP && HAVE_GETPAGESIZE
1035   plugin_pagesize = getpagesize ();
1036 #endif
1037 }
1038
1039 /* Call 'claim file' hook for all plugins.  */
1040 static int
1041 plugin_call_claim_file (const struct ld_plugin_input_file *file, int *claimed)
1042 {
1043   plugin_t *curplug = plugins_list;
1044   *claimed = FALSE;
1045   while (curplug && !*claimed)
1046     {
1047       if (curplug->claim_file_handler)
1048         {
1049           enum ld_plugin_status rv;
1050
1051           called_plugin = curplug;
1052           rv = (*curplug->claim_file_handler) (file, claimed);
1053           called_plugin = NULL;
1054           if (rv != LDPS_OK)
1055             set_plugin_error (curplug->name);
1056         }
1057       curplug = curplug->next;
1058     }
1059   return plugin_error_p () ? -1 : 0;
1060 }
1061
1062 /* Duplicates a character string with memory attached to ABFD.  */
1063
1064 static char *
1065 plugin_strdup (bfd *abfd, const char *str)
1066 {
1067   size_t strlength;
1068   char *copy;
1069   strlength = strlen (str) + 1;
1070   copy = bfd_alloc (abfd, strlength);
1071   if (copy == NULL)
1072     einfo (_("%F%P: plugin_strdup failed to allocate memory: %s\n"),
1073            bfd_get_error ());
1074   memcpy (copy, str, strlength);
1075   return copy;
1076 }
1077
1078 static const bfd_target *
1079 plugin_object_p (bfd *ibfd)
1080 {
1081   int claimed;
1082   plugin_input_file_t *input;
1083   struct ld_plugin_input_file file;
1084   bfd *abfd;
1085
1086   /* Don't try the dummy object file.  */
1087   if ((ibfd->flags & BFD_PLUGIN) != 0)
1088     return NULL;
1089
1090   if (ibfd->plugin_format != bfd_plugin_unknown)
1091     {
1092       if (ibfd->plugin_format == bfd_plugin_yes)
1093         return ibfd->plugin_dummy_bfd->xvec;
1094       else
1095         return NULL;
1096     }
1097
1098   /* We create a dummy BFD, initially empty, to house whatever symbols
1099      the plugin may want to add.  */
1100   abfd = plugin_get_ir_dummy_bfd (ibfd->filename, ibfd);
1101
1102   input = bfd_alloc (abfd, sizeof (*input));
1103   if (input == NULL)
1104     einfo (_("%F%P: plugin failed to allocate memory for input: %s\n"),
1105            bfd_get_error ());
1106
1107   if (!bfd_plugin_open_input (ibfd, &file))
1108     return NULL;
1109
1110   if (file.name == ibfd->filename)
1111     {
1112       /* We must copy filename attached to ibfd if it is not an archive
1113          member since it may be freed by bfd_close below.  */
1114       file.name = plugin_strdup (abfd, file.name);
1115     }
1116
1117   file.handle = input;
1118   input->abfd = abfd;
1119   input->view_buffer.addr = NULL;
1120   input->view_buffer.filesize = 0;
1121   input->view_buffer.offset = 0;
1122   input->fd = file.fd;
1123   input->use_mmap = FALSE;
1124   input->offset = file.offset;
1125   input->filesize = file.filesize;
1126   input->name = plugin_strdup (abfd, ibfd->filename);
1127
1128   claimed = 0;
1129
1130   if (plugin_call_claim_file (&file, &claimed))
1131     einfo (_("%F%P: %s: plugin reported error claiming file\n"),
1132            plugin_error_plugin ());
1133
1134   if (input->fd != -1 && !bfd_plugin_target_p (ibfd->xvec))
1135     {
1136       /* FIXME: fd belongs to us, not the plugin.  GCC plugin, which
1137          doesn't need fd after plugin_call_claim_file, doesn't use
1138          BFD plugin target vector.  Since GCC plugin doesn't call
1139          release_input_file, we close it here.  LLVM plugin, which
1140          needs fd after plugin_call_claim_file and calls
1141          release_input_file after it is done, uses BFD plugin target
1142          vector.  This scheme doesn't work when a plugin needs fd and
1143          doesn't use BFD plugin target vector neither.  */
1144       close (input->fd);
1145       input->fd = -1;
1146     }
1147
1148   if (claimed)
1149     {
1150       ibfd->plugin_format = bfd_plugin_yes;
1151       ibfd->plugin_dummy_bfd = abfd;
1152       bfd_make_readable (abfd);
1153       return abfd->xvec;
1154     }
1155   else
1156     {
1157 #if HAVE_MMAP
1158       if (input->use_mmap)
1159         {
1160           /* If plugin didn't claim the file, unmap the buffer.  */
1161           char *addr = input->view_buffer.addr;
1162           off_t size = input->view_buffer.filesize;
1163 # if HAVE_GETPAGESIZE
1164           off_t bias = input->view_buffer.offset % plugin_pagesize;
1165           size += bias;
1166           addr -= bias;
1167 # endif
1168           munmap (addr, size);
1169         }
1170 #endif
1171
1172       /* If plugin didn't claim the file, we don't need the dummy bfd.
1173          Can't avoid speculatively creating it, alas.  */
1174       ibfd->plugin_format = bfd_plugin_no;
1175       bfd_close_all_done (abfd);
1176       return NULL;
1177     }
1178 }
1179
1180 void
1181 plugin_maybe_claim (lang_input_statement_type *entry)
1182 {
1183   ASSERT (entry->header.type == lang_input_statement_enum);
1184   if (plugin_object_p (entry->the_bfd))
1185     {
1186       bfd *abfd = entry->the_bfd->plugin_dummy_bfd;
1187
1188       /* Discard the real file's BFD and substitute the dummy one.  */
1189
1190       /* We can't call bfd_close on archives.  BFD archive handling
1191          caches elements, and add_archive_element keeps pointers to
1192          the_bfd and the_bfd->filename in a lang_input_statement_type
1193          linker script statement.  */
1194       if (entry->the_bfd->my_archive == NULL)
1195         bfd_close (entry->the_bfd);
1196       entry->the_bfd = abfd;
1197       entry->flags.claimed = 1;
1198     }
1199 }
1200
1201 /* Call 'all symbols read' hook for all plugins.  */
1202 int
1203 plugin_call_all_symbols_read (void)
1204 {
1205   plugin_t *curplug = plugins_list;
1206
1207   /* Disable any further file-claiming.  */
1208   no_more_claiming = TRUE;
1209
1210   while (curplug)
1211     {
1212       if (curplug->all_symbols_read_handler)
1213         {
1214           enum ld_plugin_status rv;
1215           called_plugin = curplug;
1216           rv = (*curplug->all_symbols_read_handler) ();
1217           called_plugin = NULL;
1218           if (rv != LDPS_OK)
1219             set_plugin_error (curplug->name);
1220         }
1221       curplug = curplug->next;
1222     }
1223   return plugin_error_p () ? -1 : 0;
1224 }
1225
1226 /* Call 'cleanup' hook for all plugins at exit.  */
1227 void
1228 plugin_call_cleanup (void)
1229 {
1230   plugin_t *curplug = plugins_list;
1231   while (curplug)
1232     {
1233       if (curplug->cleanup_handler && !curplug->cleanup_done)
1234         {
1235           enum ld_plugin_status rv;
1236           curplug->cleanup_done = TRUE;
1237           called_plugin = curplug;
1238           rv = (*curplug->cleanup_handler) ();
1239           called_plugin = NULL;
1240           if (rv != LDPS_OK)
1241             info_msg (_("%P: %s: error in plugin cleanup: %d (ignored)\n"),
1242                       curplug->name, rv);
1243           dlclose (curplug->dlhandle);
1244         }
1245       curplug = curplug->next;
1246     }
1247 }
1248
1249 /* To determine which symbols should be resolved LDPR_PREVAILING_DEF
1250    and which LDPR_PREVAILING_DEF_IRONLY, we notice all the symbols as
1251    the linker adds them to the linker hash table.  Mark those
1252    referenced from a non-IR file with non_ir_ref_regular or
1253    non_ir_ref_dynamic as appropriate.  We have to notice_all symbols,
1254    because we won't necessarily know until later which ones will be
1255    contributed by IR files.  */
1256 static bfd_boolean
1257 plugin_notice (struct bfd_link_info *info,
1258                struct bfd_link_hash_entry *h,
1259                struct bfd_link_hash_entry *inh,
1260                bfd *abfd,
1261                asection *section,
1262                bfd_vma value,
1263                flagword flags)
1264 {
1265   struct bfd_link_hash_entry *orig_h = h;
1266
1267   if (h != NULL)
1268     {
1269       bfd *sym_bfd;
1270       bfd_boolean ref = FALSE;
1271
1272       if (h->type == bfd_link_hash_warning)
1273         h = h->u.i.link;
1274
1275       /* Nothing to do here if this def/ref is from an IR dummy BFD.  */
1276       if (is_ir_dummy_bfd (abfd))
1277         ;
1278
1279       /* Making an indirect symbol counts as a reference unless this
1280          is a brand new symbol.  */
1281       else if (bfd_is_ind_section (section)
1282                || (flags & BSF_INDIRECT) != 0)
1283         {
1284           /* ??? Some of this is questionable.  See comments in
1285              _bfd_generic_link_add_one_symbol for case IND.  */
1286           if (h->type != bfd_link_hash_new
1287               || inh->type == bfd_link_hash_new)
1288             {
1289               if ((abfd->flags & DYNAMIC) == 0)
1290                 inh->non_ir_ref_regular = TRUE;
1291               else
1292                 inh->non_ir_ref_dynamic = TRUE;
1293             }
1294
1295           if (h->type != bfd_link_hash_new)
1296             ref = TRUE;
1297         }
1298
1299       /* Nothing to do here for warning symbols.  */
1300       else if ((flags & BSF_WARNING) != 0)
1301         ;
1302
1303       /* Nothing to do here for constructor symbols.  */
1304       else if ((flags & BSF_CONSTRUCTOR) != 0)
1305         ;
1306
1307       /* If this is a ref, set non_ir_ref.  */
1308       else if (bfd_is_und_section (section))
1309         {
1310           /* Replace the undefined dummy bfd with the real one.  */
1311            if ((h->type == bfd_link_hash_undefined
1312                 || h->type == bfd_link_hash_undefweak)
1313                && (h->u.undef.abfd == NULL
1314                    || (h->u.undef.abfd->flags & BFD_PLUGIN) != 0))
1315              h->u.undef.abfd = abfd;
1316           ref = TRUE;
1317         }
1318
1319       /* Otherwise, it must be a new def.  */
1320       else
1321         {
1322           /* Ensure any symbol defined in an IR dummy BFD takes on a
1323              new value from a real BFD.  Weak symbols are not normally
1324              overridden by a new weak definition, and strong symbols
1325              will normally cause multiple definition errors.  Avoid
1326              this by making the symbol appear to be undefined.  */
1327           if (((h->type == bfd_link_hash_defweak
1328                 || h->type == bfd_link_hash_defined)
1329                && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner))
1330               || (h->type == bfd_link_hash_common
1331                   && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)))
1332             {
1333               h->type = bfd_link_hash_undefweak;
1334               h->u.undef.abfd = sym_bfd;
1335             }
1336
1337           /* A common symbol should be merged with other commons or
1338              defs with the same name.  In particular, a common ought
1339              to be overridden by a def in a -flto object.  In that
1340              sense a common is also a ref.  */
1341           if (bfd_is_com_section (section))
1342             ref = TRUE;
1343         }
1344
1345       if (ref)
1346         {
1347           if ((abfd->flags & DYNAMIC) == 0)
1348             h->non_ir_ref_regular = TRUE;
1349           else
1350             h->non_ir_ref_dynamic = TRUE;
1351         }
1352     }
1353
1354   /* Continue with cref/nocrossref/trace-sym processing.  */
1355   if (orig_h == NULL
1356       || orig_notice_all
1357       || (info->notice_hash != NULL
1358           && bfd_hash_lookup (info->notice_hash, orig_h->root.string,
1359                               FALSE, FALSE) != NULL))
1360     return (*orig_callbacks->notice) (info, orig_h, inh,
1361                                       abfd, section, value, flags);
1362   return TRUE;
1363 }