/* Main program of GNU linker.

   Copyright (C) 1991-2018 Free Software Foundation, Inc.

   Written by Steve Chamberlain steve@cygnus.com

   This file is part of the GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"

#include "safe-ctype.h"

#include "libiberty.h"

#include "progress.h"

#include "bfdlink.h"

#include "filenames.h"

#include "ld.h"

#include "ldmain.h"

#include "ldmisc.h"

#include "ldwrite.h"

#include "ldexp.h"

#include "ldlang.h"

#include <ldgram.h>

#include "ldlex.h"

#include "ldfile.h"

#include "ldemul.h"

#include "ldctor.h"

#ifdef ENABLE_PLUGINS

#include "plugin.h"

#include "plugin-api.h"

#endif /* ENABLE_PLUGINS */

/* Somewhere above, sys/stat.h got included.  */

#if !defined(S_ISDIR) && defined(S_IFDIR)

#define	S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)

#endif

#include <string.h>

#ifndef TARGET_SYSTEM_ROOT

#define TARGET_SYSTEM_ROOT ""

#endif

/* EXPORTS */

FILE *saved_script_handle = NULL;

FILE *previous_script_handle = NULL;

bfd_boolean force_make_executable = FALSE;

char *default_target;

const char *output_filename = "a.out";

/* Name this program was invoked by.  */

char *program_name;

/* The prefix for system library directories.  */

const char *ld_sysroot;

/* The canonical representation of ld_sysroot.  */

char *ld_canon_sysroot;

int ld_canon_sysroot_len;

/* Set by -G argument, for targets like MIPS ELF.  */

int g_switch_value = 8;

/* Nonzero means print names of input files as processed.  */

bfd_boolean trace_files;

/* Nonzero means report actions taken by the linker, and describe the linker script in use.  */

bfd_boolean verbose;

/* Nonzero means version number was printed, so exit successfully

   instead of complaining if no input files are given.  */

bfd_boolean version_printed;

/* TRUE if we should demangle symbol names.  */

bfd_boolean demangling;

args_type command_line;

ld_config_type config;

sort_type sort_section;

static const char *get_sysroot

  (int, char **);

static char *get_emulation

  (int, char **);

static bfd_boolean add_archive_element

  (struct bfd_link_info *, bfd *, const char *, bfd **);

static void multiple_definition

  (struct bfd_link_info *, struct bfd_link_hash_entry *,

   bfd *, asection *, bfd_vma);

static void multiple_common

  (struct bfd_link_info *, struct bfd_link_hash_entry *,

   bfd *, enum bfd_link_hash_type, bfd_vma);

static void add_to_set

  (struct bfd_link_info *, struct bfd_link_hash_entry *,

   bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);

static void constructor_callback

  (struct bfd_link_info *, bfd_boolean, const char *, bfd *,

   asection *, bfd_vma);

static void warning_callback

  (struct bfd_link_info *, const char *, const char *, bfd *,

   asection *, bfd_vma);

static void warning_find_reloc

  (bfd *, asection *, void *);

static void undefined_symbol

  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,

   bfd_boolean);

static void reloc_overflow

  (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,

   const char *, bfd_vma, bfd *, asection *, bfd_vma);

static void reloc_dangerous

  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);

static void unattached_reloc

  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);

static bfd_boolean notice

  (struct bfd_link_info *, struct bfd_link_hash_entry *,

   struct bfd_link_hash_entry *, bfd *, asection *, bfd_vma, flagword);

static struct bfd_link_callbacks link_callbacks =

{

  add_archive_element,

  multiple_definition,

  multiple_common,

  add_to_set,

  constructor_callback,

  warning_callback,

  undefined_symbol,

  reloc_overflow,

  reloc_dangerous,

  unattached_reloc,

  notice,

  einfo,

  info_msg,

  minfo,

  ldlang_override_segment_assignment

};

static bfd_assert_handler_type default_bfd_assert_handler;

static bfd_error_handler_type default_bfd_error_handler;

struct bfd_link_info link_info;

static void

ld_cleanup (void)

{

  bfd_cache_close_all ();

#ifdef ENABLE_PLUGINS

  plugin_call_cleanup ();

#endif

  if (output_filename && delete_output_file_on_failure)

    unlink_if_ordinary (output_filename);

}

/* Hook to notice BFD assertions.  */

static void

ld_bfd_assert_handler (const char *fmt, const char *bfdver,

		       const char *file, int line)

{

  config.make_executable = FALSE;

  (*default_bfd_assert_handler) (fmt, bfdver, file, line);

}

/* Hook the bfd error/warning handler for --fatal-warnings.  */

static void

ld_bfd_error_handler (const char *fmt, va_list ap)

{

  if (config.fatal_warnings)

    config.make_executable = FALSE;

  (*default_bfd_error_handler) (fmt, ap);

}

int

main (int argc, char **argv)

{

  char *emulation;

  long start_time = get_run_time ();

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)

  setlocale (LC_MESSAGES, "");

#endif

#if defined (HAVE_SETLOCALE)

  setlocale (LC_CTYPE, "");

#endif

  bindtextdomain (PACKAGE, LOCALEDIR);

  textdomain (PACKAGE);

  program_name = argv[0];

  xmalloc_set_program_name (program_name);

  START_PROGRESS (program_name, 0);

  expandargv (&argc, &argv);

  bfd_init ();

  bfd_set_error_program_name (program_name);

  /* We want to notice and fail on those nasty BFD assertions which are

     likely to signal incorrect output being generated but otherwise may

     leave no trace.  */

  default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);

  /* Also hook the bfd error/warning handler for --fatal-warnings.  */

  default_bfd_error_handler = bfd_set_error_handler (ld_bfd_error_handler);

  xatexit (ld_cleanup);

  /* Set up the sysroot directory.  */

  ld_sysroot = get_sysroot (argc, argv);

  if (*ld_sysroot)

    ld_canon_sysroot = lrealpath (ld_sysroot);

  if (ld_canon_sysroot)

    ld_canon_sysroot_len = strlen (ld_canon_sysroot);

  else

    ld_canon_sysroot_len = -1;

  /* Set the default BFD target based on the configured target.  Doing

     this permits the linker to be configured for a particular target,

     and linked against a shared BFD library which was configured for

     a different target.  The macro TARGET is defined by Makefile.  */

  if (!bfd_set_default_target (TARGET))

    {

      einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);

      xexit (1);

    }

#if YYDEBUG

  {

    extern int yydebug;

    yydebug = 1;

  }

#endif

  config.build_constructors = TRUE;

  config.rpath_separator = ':';

  config.split_by_reloc = (unsigned) -1;

  config.split_by_file = (bfd_size_type) -1;

  config.make_executable = TRUE;

  config.magic_demand_paged = TRUE;

  config.text_read_only = TRUE;

  link_info.disable_target_specific_optimizations = -1;

  command_line.warn_mismatch = TRUE;

  command_line.warn_search_mismatch = TRUE;

  command_line.check_section_addresses = -1;

  /* We initialize DEMANGLING based on the environment variable

     COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the

     output of the linker, unless COLLECT_NO_DEMANGLE is set in the

     environment.  Acting the same way here lets us provide the same

     interface by default.  */

  demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;

  link_info.allow_undefined_version = TRUE;

  link_info.keep_memory = TRUE;

  link_info.combreloc = TRUE;

  link_info.strip_discarded = TRUE;

  link_info.emit_hash = DEFAULT_EMIT_SYSV_HASH;

  link_info.emit_gnu_hash = DEFAULT_EMIT_GNU_HASH;

  link_info.callbacks = &link_callbacks;

  link_info.input_bfds_tail = &link_info.input_bfds;

  /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init

     and _fini symbols.  We are compatible.  */

  link_info.init_function = "_init";

  link_info.fini_function = "_fini";

  link_info.relax_pass = 1;

  link_info.extern_protected_data = -1;

  link_info.dynamic_undefined_weak = -1;

  link_info.pei386_auto_import = -1;

  link_info.spare_dynamic_tags = 5;

  link_info.path_separator = ':';

#ifdef DEFAULT_FLAG_COMPRESS_DEBUG

  link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;

#endif

#ifdef DEFAULT_NEW_DTAGS

  link_info.new_dtags = DEFAULT_NEW_DTAGS;

#endif

  ldfile_add_arch ("");

  emulation = get_emulation (argc, argv);

  ldemul_choose_mode (emulation);

  default_target = ldemul_choose_target (argc, argv);

  config.maxpagesize = bfd_emul_get_maxpagesize (default_target);

  config.commonpagesize = bfd_emul_get_commonpagesize (default_target);

  lang_init ();

  ldexp_init ();

  ldemul_before_parse ();

  lang_has_input_file = FALSE;

  parse_args (argc, argv);

  if (config.hash_table_size != 0)

    bfd_hash_set_default_size (config.hash_table_size);

#ifdef ENABLE_PLUGINS

  /* Now all the plugin arguments have been gathered, we can load them.  */

  plugin_load_plugins ();

#endif /* ENABLE_PLUGINS */

  ldemul_set_symbols ();

  /* If we have not already opened and parsed a linker script,

     try the default script from command line first.  */

  if (saved_script_handle == NULL

      && command_line.default_script != NULL)

    {

      ldfile_open_command_file (command_line.default_script);

      parser_input = input_script;

      yyparse ();

    }

  /* If we have not already opened and parsed a linker script

     read the emulation's appropriate default script.  */

  if (saved_script_handle == NULL)

    {

      int isfile;

      char *s = ldemul_get_script (&isfile);

      if (isfile)

	ldfile_open_default_command_file (s);

      else

	{

	  lex_string = s;

	  lex_redirect (s, _("built in linker script"), 1);

	}

      parser_input = input_script;

      yyparse ();

      lex_string = NULL;

    }

  if (verbose)

    {

      if (saved_script_handle)

	info_msg (_("using external linker script:"));

      else

	info_msg (_("using internal linker script:"));

      info_msg ("\n==================================================\n");

      if (saved_script_handle)

	{

	  static const int ld_bufsz = 8193;

	  size_t n;

	  char *buf = (char *) xmalloc (ld_bufsz);

	  rewind (saved_script_handle);

	  while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)

	    {

	      buf[n] = 0;

	      info_msg ("%s", buf);

	    }

	  rewind (saved_script_handle);

	  free (buf);

	}

      else

	{

	  int isfile;

	  info_msg (ldemul_get_script (&isfile));

	}

      info_msg ("\n==================================================\n");

    }

  if (command_line.force_group_allocation

      || !bfd_link_relocatable (&link_info))

    link_info.resolve_section_groups = TRUE;

  else

    link_info.resolve_section_groups = FALSE;

  if (command_line.print_output_format)

    info_msg ("%s\n", lang_get_output_target ());

  lang_final ();

  /* If the only command line argument has been -v or --version or --verbose

     then ignore any input files provided by linker scripts and exit now.

     We do not want to create an output file when the linker is just invoked

     to provide version information.  */

  if (argc == 2 && version_printed)

    xexit (0);

  if (link_info.inhibit_common_definition && !bfd_link_dll (&link_info))

    einfo (_("%P%F: --no-define-common may not be used without -shared\n"));

  if (!lang_has_input_file)

    {

      if (version_printed || command_line.print_output_format)

	xexit (0);

      einfo (_("%P%F: no input files\n"));

    }

  if (trace_files)

    info_msg (_("%P: mode %s\n"), emulation);

  ldemul_after_parse ();

  if (config.map_filename)

    {

      if (strcmp (config.map_filename, "-") == 0)

	{

	  config.map_file = stdout;

	}

      else

	{

	  config.map_file = fopen (config.map_filename, FOPEN_WT);

	  if (config.map_file == (FILE *) NULL)

	    {

	      bfd_set_error (bfd_error_system_call);

	      einfo (_("%P%F: cannot open map file %s: %E\n"),

		     config.map_filename);

	    }

	}

    }

  lang_process ();

  /* Print error messages for any missing symbols, for any warning

     symbols, and possibly multiple definitions.  */

  if (bfd_link_relocatable (&link_info))

    link_info.output_bfd->flags &= ~EXEC_P;

  else

    link_info.output_bfd->flags |= EXEC_P;

  if ((link_info.compress_debug & COMPRESS_DEBUG))

    {

      link_info.output_bfd->flags |= BFD_COMPRESS;

      if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)

	link_info.output_bfd->flags |= BFD_COMPRESS_GABI;

    }

  ldwrite ();

  if (config.map_file != NULL)

    lang_map ();

  if (command_line.cref)

    output_cref (config.map_file != NULL ? config.map_file : stdout);

  if (nocrossref_list != NULL)

    check_nocrossrefs ();

  if (command_line.print_memory_usage)

    lang_print_memory_usage ();

#if 0

  {

    struct bfd_link_hash_entry *h;

    h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);

    fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);

  }

#endif

  ldexp_finish ();

  lang_finish ();

  /* Even if we're producing relocatable output, some non-fatal errors should

     be reported in the exit status.  (What non-fatal errors, if any, do we

     want to ignore for relocatable output?)  */

  if (!config.make_executable && !force_make_executable)

    {

      if (trace_files)

	einfo (_("%P: link errors found, deleting executable `%s'\n"),

	       output_filename);

      /* The file will be removed by ld_cleanup.  */

      xexit (1);

    }

  else

    {

      if (!bfd_close (link_info.output_bfd))

	einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);

      /* If the --force-exe-suffix is enabled, and we're making an

	 executable file and it doesn't end in .exe, copy it to one

	 which does.  */

      if (!bfd_link_relocatable (&link_info)

	  && command_line.force_exe_suffix)

	{

	  int len = strlen (output_filename);

	  if (len < 4

	      || (strcasecmp (output_filename + len - 4, ".exe") != 0

		  && strcasecmp (output_filename + len - 4, ".dll") != 0))

	    {

	      FILE *src;

	      FILE *dst;

	      const int bsize = 4096;

	      char *buf = (char *) xmalloc (bsize);

	      int l;

	      char *dst_name = (char *) xmalloc (len + 5);

	      strcpy (dst_name, output_filename);

	      strcat (dst_name, ".exe");

	      src = fopen (output_filename, FOPEN_RB);

	      dst = fopen (dst_name, FOPEN_WB);

	      if (!src)

		einfo (_("%P%F: unable to open for source of copy `%s'\n"),

		       output_filename);

	      if (!dst)

		einfo (_("%P%F: unable to open for destination of copy `%s'\n"),

		       dst_name);

	      while ((l = fread (buf, 1, bsize, src)) > 0)

		{

		  int done = fwrite (buf, 1, l, dst);

		  if (done != l)

		    einfo (_("%P: Error writing file `%s'\n"), dst_name);

		}

	      fclose (src);

	      if (fclose (dst) == EOF)

		einfo (_("%P: Error closing file `%s'\n"), dst_name);

	      free (dst_name);

	      free (buf);

	    }

	}

    }

  END_PROGRESS (program_name);

  if (config.stats)

    {

      long run_time = get_run_time () - start_time;

      fflush (stdout);

      fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),

	       program_name, run_time / 1000000, run_time % 1000000);

      fflush (stderr);

    }

  /* Prevent ld_cleanup from doing anything, after a successful link.  */

  output_filename = NULL;

  xexit (0);

  return 0;

}

/* If the configured sysroot is relocatable, try relocating it based on

   default prefix FROM.  Return the relocated directory if it exists,

   otherwise return null.  */

static char *

get_relative_sysroot (const char *from ATTRIBUTE_UNUSED)

{

#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE

  char *path;

  struct stat s;

  path = make_relative_prefix (program_name, from, TARGET_SYSTEM_ROOT);

  if (path)

    {

      if (stat (path, &s) == 0 && S_ISDIR (s.st_mode))

	return path;

      free (path);

    }

#endif

  return 0;

}

/* Return the sysroot directory.  Return "" if no sysroot is being used.  */

static const char *

get_sysroot (int argc, char **argv)

{

  int i;

  const char *path;

  for (i = 1; i < argc; i++)

    if (CONST_STRNEQ (argv[i], "--sysroot="))

      return argv[i] + strlen ("--sysroot=");

  path = get_relative_sysroot (BINDIR);

  if (path)

    return path;

  path = get_relative_sysroot (TOOLBINDIR);

  if (path)

    return path;

  return TARGET_SYSTEM_ROOT;

}

/* We need to find any explicitly given emulation in order to initialize the

   state that's needed by the lex&yacc argument parser (parse_args).  */

static char *

get_emulation (int argc, char **argv)

{

  char *emulation;

  int i;

  emulation = getenv (EMULATION_ENVIRON);

  if (emulation == NULL)

    emulation = DEFAULT_EMULATION;

  for (i = 1; i < argc; i++)

    {

      if (CONST_STRNEQ (argv[i], "-m"))

	{

	  if (argv[i][2] == '\0')

	    {

	      /* -m EMUL */

	      if (i < argc - 1)

		{

		  emulation = argv[i + 1];

		  i++;

		}

	      else

		einfo (_("%P%F: missing argument to -m\n"));

	    }

	  else if (strcmp (argv[i], "-mips1") == 0

		   || strcmp (argv[i], "-mips2") == 0

		   || strcmp (argv[i], "-mips3") == 0

		   || strcmp (argv[i], "-mips4") == 0

		   || strcmp (argv[i], "-mips5") == 0

		   || strcmp (argv[i], "-mips32") == 0

		   || strcmp (argv[i], "-mips32r2") == 0

		   || strcmp (argv[i], "-mips32r6") == 0

		   || strcmp (argv[i], "-mips64") == 0

		   || strcmp (argv[i], "-mips64r2") == 0

		   || strcmp (argv[i], "-mips64r6") == 0)

	    {

	      /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are

		 passed to the linker by some MIPS compilers.  They

		 generally tell the linker to use a slightly different

		 library path.  Perhaps someday these should be

		 implemented as emulations; until then, we just ignore

		 the arguments and hope that nobody ever creates

		 emulations named ips1, ips2 or ips3.  */

	    }

	  else if (strcmp (argv[i], "-m486") == 0)

	    {

	      /* FIXME: The argument -m486 is passed to the linker on

		 some Linux systems.  Hope that nobody creates an

		 emulation named 486.  */

	    }

	  else

	    {

	      /* -mEMUL */

	      emulation = &argv[i][2];

	    }

	}

    }

  return emulation;

}

void

add_ysym (const char *name)

{

  if (link_info.notice_hash == NULL)

    {

      link_info.notice_hash

	= (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));

      if (!bfd_hash_table_init_n (link_info.notice_hash,

				  bfd_hash_newfunc,

				  sizeof (struct bfd_hash_entry),

				  61))

	einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));

    }

  if (bfd_hash_lookup (link_info.notice_hash, name, TRUE, TRUE) == NULL)

    einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));

}

void

add_ignoresym (struct bfd_link_info *info, const char *name)

{

  if (info->ignore_hash == NULL)

    {

      info->ignore_hash = xmalloc (sizeof (struct bfd_hash_table));

      if (!bfd_hash_table_init_n (info->ignore_hash,

				  bfd_hash_newfunc,

				  sizeof (struct bfd_hash_entry),

				  61))

	einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));

    }

  if (bfd_hash_lookup (info->ignore_hash, name, TRUE, TRUE) == NULL)

    einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));

}

/* Record a symbol to be wrapped, from the --wrap option.  */

void

add_wrap (const char *name)

{

  if (link_info.wrap_hash == NULL)

    {

      link_info.wrap_hash

	= (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));

      if (!bfd_hash_table_init_n (link_info.wrap_hash,

				  bfd_hash_newfunc,

				  sizeof (struct bfd_hash_entry),

				  61))

	einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));

    }

  if (bfd_hash_lookup (link_info.wrap_hash, name, TRUE, TRUE) == NULL)

    einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));

}

/* Handle the -retain-symbols-file option.  */

void

add_keepsyms_file (const char *filename)

{

  FILE *file;

  char *buf;

  size_t bufsize;

  int c;

  if (link_info.strip == strip_some)

    einfo (_("%X%P: error: duplicate retain-symbols-file\n"));

  file = fopen (filename, "r");

  if (file == NULL)

    {

      bfd_set_error (bfd_error_system_call);

      einfo ("%X%P: %s: %E\n", filename);

      return;

    }

  link_info.keep_hash = (struct bfd_hash_table *)

      xmalloc (sizeof (struct bfd_hash_table));

  if (!bfd_hash_table_init (link_info.keep_hash, bfd_hash_newfunc,

			    sizeof (struct bfd_hash_entry)))

    einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));

  bufsize = 100;

  buf = (char *) xmalloc (bufsize);

  c = getc (file);

  while (c != EOF)

    {

      while (ISSPACE (c))

	c = getc (file);

      if (c != EOF)

	{

	  size_t len = 0;

	  while (!ISSPACE (c) && c != EOF)

	    {

	      buf[len] = c;

	      ++len;

	      if (len >= bufsize)

		{

		  bufsize *= 2;

		  buf = (char *) xrealloc (buf, bufsize);

		}

	      c = getc (file);

	    }

	  buf[len] = '\0';

	  if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)

	    einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));

	}

    }

  if (link_info.strip != strip_none)

    einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));

  free (buf);

  link_info.strip = strip_some;

  fclose (file);

}

/* Callbacks from the BFD linker routines.  */

/* This is called when BFD has decided to include an archive member in

   a link.  */

static bfd_boolean

add_archive_element (struct bfd_link_info *info,

		     bfd *abfd,

		     const char *name,

		     bfd **subsbfd ATTRIBUTE_UNUSED)

{

  lang_input_statement_type *input;

  lang_input_statement_type orig_input;

  input = (lang_input_statement_type *)

      xcalloc (1, sizeof (lang_input_statement_type));

  input->header.type = lang_input_statement_enum;

  input->filename = abfd->filename;

  input->local_sym_name = abfd->filename;

  input->the_bfd = abfd;

  /* Save the original data for trace files/tries below, as plugins

     (if enabled) may possibly alter it to point to a replacement

     BFD, but we still want to output the original BFD filename.  */

  orig_input = *input;

#ifdef ENABLE_PLUGINS

  if (link_info.lto_plugin_active)

    {

      /* We must offer this archive member to the plugins to claim.  */

      plugin_maybe_claim (input);

      if (input->flags.claimed)

	{

	  if (no_more_claiming)

	    {

	      /* Don't claim new IR symbols after all IR symbols have

		 been claimed.  */

	      if (trace_files || verbose)

		info_msg ("%I: no new IR symbols to claimi\n",

			  &orig_input);

	      input->flags.claimed = 0;

	      return FALSE;

	    }

	  input->flags.claim_archive = TRUE;

	  *subsbfd = input->the_bfd;

	}

    }

#endif /* ENABLE_PLUGINS */

  ldlang_add_file (input);

  if (config.map_file != NULL)

    {

      static bfd_boolean header_printed;

      struct bfd_link_hash_entry *h;

      bfd *from;

      int len;

      h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);

      if (h == NULL)

	from = NULL;

      else

	{

	  switch (h->type)

	    {

	    default:

	      from = NULL;

	      break;

	    case bfd_link_hash_defined:

	    case bfd_link_hash_defweak:

	      from = h->u.def.section->owner;

	      break;

	    case bfd_link_hash_undefined:

	    case bfd_link_hash_undefweak:

	      from = h->u.undef.abfd;

	      break;

	    case bfd_link_hash_common:

	      from = h->u.c.p->section->owner;

	      break;

	    }

	}

      if (!header_printed)

	{

	  minfo (_("Archive member included to satisfy reference by file (symbol)\n\n"));

	  header_printed = TRUE;

	}

      if (abfd->my_archive == NULL

	  || bfd_is_thin_archive (abfd->my_archive))

	{

	  minfo ("%s", bfd_get_filename (abfd));

	  len = strlen (bfd_get_filename (abfd));

	}