Add support for ARM-PE.

[binutils.git] / ld / ldmain.c

diff --git a/ld/ldmain.c b/ld/ldmain.c
index f3770c07f69c681f560d792ae6b635c27fdfb967..e6bf23dbdd559ddb72fa0bdbd3a7f71033c05d54 100644 (file)
--- a/ld/ldmain.c
+++ b/ld/ldmain.c
@@ -1,10 +1,12 @@
-/* Copyright (C) 1991 Free Software Foundation, Inc.
-   
+/* Main program of GNU linker.
+   Copyright (C) 1991, 92, 93, 94 Free Software Foundation, Inc.
+   Written by Steve Chamberlain [email protected]
+

 This file is part of GLD, the Gnu Linker.
 
 GLD is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 This file is part of GLD, the Gnu Linker.
 
 GLD 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 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)

 any later version.
 
 GLD is distributed in the hope that it will be useful,
 any later version.
 
 GLD is distributed in the hope that it will be useful,


@@ -16,17 +18,13 @@ You should have received a copy of the GNU General Public License
 along with GLD; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 along with GLD; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 

-/* 
- *  Written by Steve Chamberlain [email protected]
- *
- * $Id$ 
- *
- *
- */
-

 
 

-#include "sysdep.h"

 #include "bfd.h"
 #include "bfd.h"

+#include "sysdep.h"
+#include <stdio.h>
+#include "libiberty.h"
+#include "progress.h"
+#include "bfdlink.h"

 
 #include "config.h"
 #include "ld.h"
 
 #include "config.h"
 #include "ld.h"


@@ -34,830 +32,924 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "ldmisc.h"
 #include "ldwrite.h"
 #include "ldgram.h"
 #include "ldmisc.h"
 #include "ldwrite.h"
 #include "ldgram.h"

-#include "ldsym.h"
+#include "ldexp.h"

 #include "ldlang.h"
 #include "ldemul.h"
 #include "ldlex.h"
 #include "ldfile.h"
 #include "ldlang.h"
 #include "ldemul.h"
 #include "ldlex.h"
 #include "ldfile.h"

+#include "ldctor.h"
+
+/* 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>
+
+static char *get_emulation PARAMS ((int, char **));
+static void set_scripts_dir PARAMS ((void));

 
 

-/* IMPORTS */
-extern boolean lang_has_input_file;
-extern boolean trace_files;

 /* EXPORTS */
 
 char *default_target;
 /* EXPORTS */
 
 char *default_target;

-char *output_filename = "a.out";
+const char *output_filename = "a.out";
+

 /* Name this program was invoked by.  */
 char *program_name;
 
 /* The file that we're creating */
 bfd *output_bfd = 0;
 
 /* Name this program was invoked by.  */
 char *program_name;
 
 /* The file that we're creating */
 bfd *output_bfd = 0;
 

-extern boolean option_v;
-
-/* The local symbol prefix */
-char lprefix = 'L';
-
-/* Count the number of global symbols multiply defined.  */
-int multiple_def_count;
-
-
-/* Count the number of symbols defined through common declarations.
-   This count is referenced in symdef_library, linear_library, and
-   modified by enter_global_ref.
-
-   It is incremented when a symbol is created as a common, and
-   decremented when the common declaration is overridden
-
-   Another way of thinking of it is that this is a count of
-   all ldsym_types with a ->scoms field */
-
-unsigned int commons_pending;
-
-/* Count the number of global symbols referenced and not defined. 
-   common symbols are not included in this count.   */
-
-unsigned int undefined_global_sym_count;
-
-
-
-/* Count the number of warning symbols encountered. */
-int warning_count;
-
-/* have we had a load script ? */
-extern boolean had_script;
+/* Set by -G argument, for MIPS ECOFF target.  */
+int g_switch_value = 8;

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

+/* Nonzero means same, but note open failures, too.  */
+boolean trace_file_tries;

 
 

+/* Nonzero means version number was printed, so exit successfully
+   instead of complaining if no input files are given.  */
+boolean version_printed;

 
 

-/* 1 => write load map.  */
-boolean write_map;
-
+/* Nonzero means link in every member of an archive.  */
+boolean whole_archive;

 
 

-int unix_relocate;
-#ifdef GNU960
-/* Indicates whether output file will be b.out (default) or coff */
-enum target_flavour_enum output_flavor = BFD_BOUT_FORMAT;
-#endif
-
-/* Force the make_executable to be output, even if there are non-fatal
-   errors */
-boolean force_make_executable;
-
-/* A count of the total number of local symbols ever seen - by adding
- the symbol_count field of each newly read afile.*/
+args_type command_line;

 
 

-unsigned int total_symbols_seen;
+ld_config_type config;

 
 

-/* A count of the number of read files - the same as the number of elements
- in file_chain
- */
-unsigned int total_files_seen;
+static boolean check_for_scripts_dir PARAMS ((char *dir));
+static boolean add_archive_element PARAMS ((struct bfd_link_info *, bfd *,
+                                           const char *));
+static boolean multiple_definition PARAMS ((struct bfd_link_info *,
+                                           const char *,
+                                           bfd *, asection *, bfd_vma,
+                                           bfd *, asection *, bfd_vma));
+static boolean multiple_common PARAMS ((struct bfd_link_info *,
+                                       const char *, bfd *,
+                                       enum bfd_link_hash_type, bfd_vma,
+                                       bfd *, enum bfd_link_hash_type,
+                                       bfd_vma));
+static boolean add_to_set PARAMS ((struct bfd_link_info *,
+                                  struct bfd_link_hash_entry *,
+                                  bfd_reloc_code_real_type,
+                                  bfd *, asection *, bfd_vma));
+static boolean constructor_callback PARAMS ((struct bfd_link_info *,
+                                            boolean constructor,
+                                            const char *name,
+                                            bfd *, asection *, bfd_vma));
+static boolean warning_callback PARAMS ((struct bfd_link_info *,
+                                        const char *));
+static boolean undefined_symbol PARAMS ((struct bfd_link_info *,
+                                        const char *, bfd *,
+                                        asection *, bfd_vma));
+static boolean reloc_overflow PARAMS ((struct bfd_link_info *, const char *,
+                                      const char *, bfd_vma,
+                                      bfd *, asection *, bfd_vma));
+static boolean reloc_dangerous PARAMS ((struct bfd_link_info *, const char *,
+                                       bfd *, asection *, bfd_vma));
+static boolean unattached_reloc PARAMS ((struct bfd_link_info *,
+                                        const char *, bfd *, asection *,
+                                        bfd_vma));
+static boolean notice_ysym PARAMS ((struct bfd_link_info *, const char *,
+                                   bfd *, asection *, bfd_vma));
+
+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_ysym
+};
+
+struct bfd_link_info link_info;
+\f
+static void
+remove_output ()
+{
+  if (output_filename) 
+    {
+      if (output_bfd && output_bfd->iostream)
+       fclose((FILE *)(output_bfd->iostream));
+      if (delete_output_file_on_failure)
+       unlink (output_filename);
+    }
+}

 
 

-/* IMPORTS */
-args_type command_line;
-ld_config_type config;

 int
 main (argc, argv)
 int
 main (argc, argv)

-     char **argv;

      int argc;
      int argc;

+     char **argv;

 {
   char *emulation;
 {
   char *emulation;

+  long start_time = get_run_time ();
+

   program_name = argv[0];
   program_name = argv[0];

-  output_filename = "a.out";
-
-  bfd_init();
-#ifdef GNU960
-   {
-     int i;
- 
-     check_v960( argc, argv );
-     emulation = GLD960_EMULATION_NAME;
-     for ( i = 1; i < argc; i++ ){
-       if ( !strcmp(argv[i],"-Fcoff") ){
-       emulation = LNK960_EMULATION_NAME;
-       output_flavor = BFD_COFF_FORMAT;
-       break;
-       }
-     }
-   }
-#else
-   emulation =  (char *) getenv(EMULATION_ENVIRON); 
-#endif
+  xmalloc_set_program_name (program_name);

 
 

-  /* Initialize the data about options.  */
+  START_PROGRESS (program_name, 0);
+
+  bfd_init ();

 
 

-  trace_files = false;
-  write_map = false;
-  config.relocateable_output = false;
-  unix_relocate = 0;
+  xatexit (remove_output);
+
+  /* Initialize the data about options.  */
+  trace_files = trace_file_tries = version_printed = false;
+  whole_archive = false;
+  config.traditional_format = false;
+  config.build_constructors = true;
+  config.dynamic_link = false;

   command_line.force_common_definition = false;
   command_line.force_common_definition = false;

+  command_line.interpreter = NULL;
+  command_line.rpath = NULL;
+
+  link_info.callbacks = &link_callbacks;
+  link_info.relocateable = false;
+  link_info.shared = false;
+  link_info.strip = strip_none;
+  link_info.discard = discard_none;
+  link_info.lprefix_len = 1;
+  link_info.lprefix = "L";
+  link_info.keep_memory = true;
+  link_info.input_bfds = NULL;
+  link_info.create_object_symbols_section = NULL;
+  link_info.hash = NULL;
+  link_info.keep_hash = NULL;
+  link_info.notice_hash = NULL;
+
+  ldfile_add_arch ("");

 
 

-  ldfile_add_arch("");
-  ldfile_add_library_path("./");

   config.make_executable = true;
   force_make_executable = false;
   config.make_executable = true;
   force_make_executable = false;

-
-
-  /* Initialize the cumulative counts of symbols.  */
-  undefined_global_sym_count = 0;
-  warning_count = 0;
-  multiple_def_count = 0;
-  commons_pending = 0;
-
-  config.magic_demand_paged = true ;
+  config.magic_demand_paged = true;
+  config.text_read_only = true;

   config.make_executable = true;
   config.make_executable = true;

-  if (emulation == (char *)NULL) {
-    emulation= DEFAULT_EMULATION;
-  }
-
-  ldemul_choose_mode(emulation);
-  default_target =  ldemul_choose_target();
-  lang_init();
-  ldemul_before_parse();
+
+  emulation = get_emulation (argc, argv);
+  ldemul_choose_mode (emulation);
+  default_target = ldemul_choose_target ();
+  lang_init ();
+  ldemul_before_parse ();

   lang_has_input_file = false;
   lang_has_input_file = false;

-  parse_args(argc, argv);
-  lang_final(); 
-  if (trace_files) {
-    info("%P: mode %s\n", emulation);
-  }
-  if (lang_has_input_file == false) {
-    info("%P%F: No input files\n");
-  }
-
-  ldemul_after_parse();
-  lang_process();
+  parse_args (argc, argv);

 
 

-  /* Print error messages for any missing symbols, for any warning
-     symbols, and possibly multiple definitions */
+  if (link_info.relocateable)
+    {
+      if (command_line.relax)
+       einfo ("%P%F: -relax and -r may not be used together\n");
+      if (config.dynamic_link)
+       einfo ("%P%F: -r and -call_shared may not be used together\n");
+      if (link_info.shared)
+       einfo ("%P%F: -r and -shared may not be used together\n");
+    }

 
 

-  /* Print a map, if requested.  */
+  /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols).  I
+     don't see how else this can be handled, since in this case we
+     must preserve all externally visible symbols.  */
+  if (link_info.relocateable && link_info.strip == strip_all)
+    {
+      link_info.strip = strip_debugger;
+      if (link_info.discard == discard_none)
+       link_info.discard = discard_all;
+    }

 
 

-  if (write_map) {
-    ldsym_print_symbol_table ();
-    lang_map(stdout);
-  }
+  /* This essentially adds another -L directory so this must be done after
+     the -L's in argv have been processed.  */
+  set_scripts_dir ();

 
 

-  if (config.text_read_only) {
-    /* Look for a text section and mark the readonly attribute in it */
-    asection *found = bfd_get_section_by_name(output_bfd, ".text");
-    if (found == (asection *)NULL) {
-      info("%P%F: text marked read only, but no text section present");
-    }
-    found->flags |= SEC_READONLY;
-    output_bfd->flags |= WP_TEXT;
-  }
-  else {
-    output_bfd->flags |= WP_TEXT;
-  }
-    
-
-  if (config.relocateable_output) {
-    output_bfd->flags &=  ~( D_PAGED);
-    output_bfd->flags |= EXEC_P;
-    ldwrite();
-    bfd_close(output_bfd);
-  }
-  else {
-    output_bfd->flags |= EXEC_P;
+  if (had_script == false)
+    {
+      /* Read the emulation's appropriate default script.  */
+      int isfile;
+      char *s = ldemul_get_script (&isfile);

 
 

-    ldwrite();
-    bfd_close(output_bfd);
-    if (config.make_executable == false && force_make_executable == false) {
-      unlink(output_filename);
+      if (isfile)
+       ldfile_open_command_file (s);
+      else
+       {
+         if (trace_file_tries)
+           {
+             info_msg ("using internal linker script:\n");
+             info_msg ("==================================================\n");
+             info_msg (s);
+             info_msg ("\n==================================================\n");
+           }
+         lex_redirect (s);
+       }
+      parser_input = input_script;
+      yyparse ();

     }
     }

-    return (!config.make_executable);
-  }

 
 

-  return(0);
-} /* main() */
+  lang_final ();

 
 

+  if (lang_has_input_file == false)
+    {
+      if (version_printed)
+       xexit (0);
+      einfo ("%P%F: no input files\n");
+    }

 
 

-void
-Q_read_entry_symbols (desc, entry)
-     bfd *desc;
-     struct lang_input_statement_struct *entry;
-{
-  if (entry->asymbols == (asymbol **)NULL) {
-    bfd_size_type table_size = get_symtab_upper_bound(desc);
-    entry->asymbols = (asymbol **)ldmalloc(table_size);
-    entry->symbol_count =  bfd_canonicalize_symtab(desc, entry->asymbols) ;
-  }
-}
-
+  if (trace_files)
+    {
+      info_msg ("%P: mode %s\n", emulation);
+    }

 
 

-/*
- * turn this item into a reference 
- */
-static void
-refize(sp, nlist_p)
-ldsym_type *sp;
-asymbol **nlist_p;
-{
-  asymbol *sym = *nlist_p;
-  sym->value = 0;
-  sym->flags = BSF_UNDEFINED;
-  sym->section = (asection *)NULL;
-  sym->udata =(PTR)( sp->srefs_chain);
-  sp->srefs_chain = nlist_p;
-}
-/*
-This function is called for each name which is seen which has a global
-scope. It enters the name into the global symbol table in the correct
-symbol on the correct chain. Remember that each ldsym_type has three
-chains attatched, one of all definitions of a symbol, one of all
-references of a symbol and one of all common definitions of a symbol.
-
-When the function is over, the supplied is left connected to the bfd
-to which is was born, with its udata field pointing to the next member
-on the chain in which it has been inserted.
-
-A certain amount of jigery pokery is necessary since commons come
-along and upset things, we only keep one item in the common chain; the
-one with the biggest size seen sofar. When another common comes along
-it either bumps the previous definition into the ref chain, since it
-is bigger, or gets turned into a ref on the spot since the one on the
-common chain is already bigger. If a real definition comes along then
-the common gets bumped off anyway.
-
-Whilst all this is going on we keep a count of the number of multiple
-definitions seen, undefined global symbols and pending commons.
-*/
+  ldemul_after_parse ();

 
 
 
 

-void
-Q_enter_global_ref (nlist_p)
-     asymbol **nlist_p;
+  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)
+           {
+             einfo ("%P%F: cannot open map file %s: %E\n",
+                    config.map_filename);
+           }
+       }
+    }

 
 

-{
-  asymbol *sym = *nlist_p;
-  CONST char *name = sym->name;
-  ldsym_type *sp = ldsym_get (name);

 
 

-  flagword this_symbol_flags = sym->flags;
+  lang_process ();

 
 

+  /* Print error messages for any missing symbols, for any warning
+     symbols, and possibly multiple definitions */

 
 

-  ASSERT(sym->udata == 0);

 
 

+  if (config.text_read_only)
+    {
+      /* Look for a text section and mark the readonly attribute in it */
+      asection *found = bfd_get_section_by_name (output_bfd, ".text");

 
 

-  if (flag_is_constructor(this_symbol_flags))  {
-    /* Add this constructor to the list we keep */
-    ldlang_add_constructor(sp);
-    /* Turn any commons into refs */
-    if (sp->scoms_chain != (asymbol **)NULL) {
-      refize(sp, sp->scoms_chain);
-      sp->scoms_chain = 0;
+      if (found != (asection *) NULL)
+       {
+         found->flags |= SEC_READONLY;
+       }

     }
 
     }
 

+  if (link_info.relocateable)
+    output_bfd->flags &= ~EXEC_P;
+  else
+    output_bfd->flags |= EXEC_P;

 
 

-  }
-  else {  
-    if (flag_is_common(this_symbol_flags)) {
-      /* If we have a definition of this symbol already then
-         this common turns into a reference. Also we only
-         ever point to the largest common, so if we
-         have a common, but it's bigger that the new symbol
-         the turn this into a reference too. */
-      if (sp->sdefs_chain)  
-         {
-           /* This is a common symbol, but we already have a definition
-              for it, so just link it into the ref chain as if
-              it were a reference  */
-           refize(sp, nlist_p);
-         }
-      else  if (sp->scoms_chain) {
-       /* If we have a previous common, keep only the biggest */
-       if ( (*(sp->scoms_chain))->value > sym->value) {
-         /* other common is bigger, throw this one away */
-         refize(sp, nlist_p);
-       }
-       else if (sp->scoms_chain != nlist_p) {
-         /* other common is smaller, throw that away */
-         refize(sp, sp->scoms_chain);
-         sp->scoms_chain = nlist_p;
-       }
-      }
-      else {
-       /* This is the first time we've seen a common, so remember it
-          - if it was undefined before, we know it's defined now. If
-          the symbol has been marked as really being a constructor,
-          then treat this as a ref 
-          */
-       if (sp->flags & SYM_CONSTRUCTOR) {
-         /* Turn this into a ref */
-         refize(sp, nlist_p);
-       }
-       else {
-         /* treat like a common */
-         if (sp->srefs_chain)
-           undefined_global_sym_count--;
+  ldwrite ();
+
+  /* Even if we're producing relocateable output, some non-fatal errors should
+     be reported in the exit status.  (What non-fatal errors, if any, do we
+     want to ignore for relocateable output?)  */

 
 

-         commons_pending++;
-         sp->scoms_chain = nlist_p;
+  if (config.make_executable == false && force_make_executable == false)
+    {
+      if (trace_files == true)
+       {
+         einfo ("%P: link errors found, deleting executable `%s'\n",
+                output_filename);

        }
        }

-      }
-    }

 
 

-    else if (flag_is_defined(this_symbol_flags)) {
-      /* This is the definition of a symbol, add to def chain */
-      if (sp->sdefs_chain && (*(sp->sdefs_chain))->section != sym->section) {
-       /* Multiple definition */
-       asymbol *sy = *(sp->sdefs_chain);
-       lang_input_statement_type *stat = (lang_input_statement_type *) sy->the_bfd->usrdata;
-       lang_input_statement_type *stat1 = (lang_input_statement_type *) sym->the_bfd->usrdata;
-       asymbol ** stat1_symbols  = stat1 ? stat1->asymbols: 0;
-       asymbol ** stat_symbols = stat ? stat->asymbols:0;
-      
-       multiple_def_count++;
-       info("%C: multiple definition of `%T'\n",
-            sym->the_bfd,
-            sym->section,
-            stat1_symbols,
-            sym->value,
-            sym);
-          
-       info("%C: first seen here\n",
-            sy->the_bfd,
-            sy->section,
-            stat_symbols,
-            sy->value);
-      }
-      else {
-       sym->udata =(PTR)( sp->sdefs_chain);
-       sp->sdefs_chain = nlist_p;
-      }
-      /* A definition overrides a common symbol */
-      if (sp->scoms_chain) {
-       refize(sp, sp->scoms_chain);
-       sp->scoms_chain = 0;
-       commons_pending--;
-      }
-      else if (sp->srefs_chain) {
-       /* If previously was undefined, then remember as defined */
-       undefined_global_sym_count--;
-      }
+      if (output_bfd->iostream)
+       fclose ((FILE *) (output_bfd->iostream));
+
+      unlink (output_filename);
+      xexit (1);
+    }
+  else
+    {
+      if (! bfd_close (output_bfd))
+       einfo ("%F%B: final close failed: %E\n", output_bfd);

     }
     }

-    else {
-      if (sp->scoms_chain == (asymbol **)NULL 
-         && sp->srefs_chain == (asymbol **)NULL 
-         && sp->sdefs_chain == (asymbol **)NULL) {
-       /* And it's the first time we've seen it */
-       undefined_global_sym_count++;

 
 

-      }
+  END_PROGRESS (program_name);

 
 

-      refize(sp, nlist_p);
+  if (config.stats)
+    {
+      extern char **environ;
+      char *lim = (char *) sbrk (0);
+      long run_time = get_run_time () - start_time;
+
+      fprintf (stderr, "%s: total time in link: %ld.%06ld\n",
+              program_name, run_time / 1000000, run_time % 1000000);
+      fprintf (stderr, "%s: data size %ld\n", program_name,
+              (long) (lim - (char *) &environ));

     }
     }

-  }
-
-  ASSERT(sp->sdefs_chain == 0 || sp->scoms_chain == 0);
-  ASSERT(sp->scoms_chain ==0 || (*(sp->scoms_chain))->udata == 0);

 
 

+  /* Prevent remove_output from doing anything, after a successful link.  */
+  output_filename = NULL;

 
 

+  xexit (0);
+  return 0;

 }
 
 }
 

-static void
-Q_enter_file_symbols (entry)
-lang_input_statement_type *entry;
-{
-  asymbol **q ;
-  entry->common_section =
-    bfd_make_section(entry->the_bfd, "COMMON");
-  
-  ldlang_add_file(entry);
+/* 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 (argc, argv)
+     int argc;
+     char **argv;
+{
+  char *emulation;
+  int i;

 
 

-  if (trace_files || option_v) {
-    info("%I\n", entry);
-  }
+  emulation = (char *) getenv (EMULATION_ENVIRON);
+  if (emulation == NULL)
+    emulation = DEFAULT_EMULATION;

 
 

-  total_symbols_seen += entry->symbol_count;
-  total_files_seen ++;
-  for (q = entry->asymbols; *q; q++)
+  for (i = 1; i < argc; i++)

     {
     {

-      asymbol *p = *q;
-
-      if (flag_is_undefined_or_global_or_common_or_constructor(p->flags))
+      if (!strncmp (argv[i], "-m", 2))

        {
        {

-         Q_enter_global_ref(q);
+         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)
+           {
+             /* FIXME: The arguments -mips1, -mips2 and -mips3 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];
+           }

        }
        }

-      if (p->flags & BSF_INDIRECT) {
-       add_indirect(q);
-      }
-
-      if (p->flags & BSF_WARNING) {
-       add_warning(p);
-      }
-      ASSERT(p->flags != 0);

     }
     }

-}

 
 

+  return emulation;
+}

 
 

+/* If directory DIR contains an "ldscripts" subdirectory,
+   add DIR to the library search path and return true,
+   else return false.  */

 
 

-/* Searching libraries */
+static boolean
+check_for_scripts_dir (dir)
+     char *dir;
+{
+  size_t dirlen;
+  char *buf;
+  struct stat s;
+  boolean res;
+
+  dirlen = strlen (dir);
+  /* sizeof counts the terminating NUL.  */
+  buf = (char *) xmalloc (dirlen + sizeof("/ldscripts"));
+  sprintf (buf, "%s/ldscripts", dir);
+
+  res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
+  free (buf);
+  if (res)
+    ldfile_add_library_path (dir, false);
+  return res;
+}

 
 

-struct lang_input_statement_struct *decode_library_subfile ();
-void linear_library (), symdef_library ();
+/* Set the default directory for finding script files.
+   Libraries will be searched for here too, but that's ok.
+   We look for the "ldscripts" directory in:

 
 

-/* Search the library ENTRY, already open on descriptor DESC.
-   This means deciding which library members to load,
-   making a chain of `struct lang_input_statement_struct' for those members,
-   and entering their global symbols in the hash table.  */
+   SCRIPTDIR (passed from Makefile)
+   the dir where this program is (for using it from the build tree)
+   the dir where this program is/../lib (for installing the tool suite elsewhere) */

 
 

-void
-search_library (entry)
-     struct lang_input_statement_struct *entry;
+static void
+set_scripts_dir ()

 {
 {

+  char *end, *dir;
+  size_t dirlen;

 
 

-  /* No need to load a library if no undefined symbols */
-  if (!undefined_global_sym_count) return;
+  if (check_for_scripts_dir (SCRIPTDIR))
+    return;                    /* We've been installed normally.  */

 
 

-  if (bfd_has_map(entry->the_bfd)) 
-    symdef_library (entry);
+  /* Look for "ldscripts" in the dir where our binary is.  */
+  end = strrchr (program_name, '/');
+  if (end)
+    {
+      dirlen = end - program_name;
+      /* Make a copy of program_name in dir.
+        Leave room for later "/../lib".  */
+      dir = (char *) xmalloc (dirlen + 8);
+      strncpy (dir, program_name, dirlen);
+      dir[dirlen] = '\0';
+    }

   else
   else

-    linear_library (entry);
+    {
+      dirlen = 1;
+      dir = (char *) xmalloc (dirlen + 8);
+      strcpy (dir, ".");
+    }
+
+  if (check_for_scripts_dir (dir))
+    return;                    /* Don't free dir.  */
+
+  /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
+  strcpy (dir + dirlen, "/../lib");
+  if (check_for_scripts_dir (dir))
+    return;
+
+  free (dir);                  /* Well, we tried.  */
+}

 
 

+void
+add_ysym (name)
+     const char *name;
+{
+  if (link_info.notice_hash == (struct bfd_hash_table *) 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,
+                                  61))
+       einfo ("%P%F: bfd_hash_table_init failed: %E\n");
+    }      
+
+  if (bfd_hash_lookup (link_info.notice_hash, name, true, true)
+      == (struct bfd_hash_entry *) NULL)
+    einfo ("%P%F: bfd_hash_lookup failed: %E\n");

 }
 
 }
 

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

 
 

-#ifdef GNU960
-static
-boolean
-gnu960_check_format (abfd, format)
-bfd *abfd;
-bfd_format format;
+void
+add_keepsyms_file (filename)
+     const char *filename;

 {
 {

-  boolean retval;
+  FILE *file;
+  char *buf;
+  size_t bufsize;
+  int c;

 
 

-  if ((bfd_check_format(abfd,format) == true)
-      &&  (abfd->xvec->flavour == output_flavor) ){
-    return true;
-  }
+  if (link_info.strip == strip_some)
+    einfo ("%X%P: error: duplicate retain-symbols-file\n");

 
 

+  file = fopen (filename, "r");
+  if (file == (FILE *) NULL)
+    {
+      bfd_set_error (bfd_error_system_call);
+      einfo ("%X%P: %s: %E", filename);
+      return;
+    }

 
 

-  return false;
-}
-#endif
+  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))
+    einfo ("%P%F: bfd_hash_table_init failed: %E\n");

 
 

-void
-ldmain_open_file_read_symbol (entry)
-struct lang_input_statement_struct *entry;
-{
-  if (entry->asymbols == (asymbol **)NULL
-      &&entry->real == true 
-      && entry->filename != (char *)NULL)
+  bufsize = 100;
+  buf = (char *) xmalloc (bufsize);
+
+  c = getc (file);
+  while (c != EOF)

     {
     {

-      ldfile_open_file (entry);
+      while (isspace (c))
+       c = getc (file);

 
 

-#ifdef GNU960
-      if (gnu960_check_format(entry->the_bfd, bfd_object))
-#else
-      if (bfd_check_format(entry->the_bfd, bfd_object))
-#endif
+      if (c != EOF)

        {
        {

-         entry->the_bfd->usrdata = (PTR)entry;
+         size_t len = 0;

 
 

+         while (! isspace (c) && c != EOF)
+           {
+             buf[len] = c;
+             ++len;
+             if (len >= bufsize)
+               {
+                 bufsize *= 2;
+                 buf = xrealloc (buf, bufsize);
+               }
+             c = getc (file);
+           }

 
 

-         Q_read_entry_symbols (entry->the_bfd, entry);
-         Q_enter_file_symbols (entry);
-       }
-#ifdef GNU960
-      else if (gnu960_check_format(entry->the_bfd, bfd_archive)) 
-#else
-      else if (bfd_check_format(entry->the_bfd, bfd_archive)) 
-#endif
-       {
-         entry->the_bfd->usrdata = (PTR)entry;
+         buf[len] = '\0';

 
 

-         entry->subfiles = (lang_input_statement_type *)NULL;
-         search_library (entry);
-       }
-      else 
-       {
-         info("%F%B: malformed input file (not rel or archive) \n",
-                                               entry->the_bfd);
+         if (bfd_hash_lookup (link_info.keep_hash, buf, true, true)
+             == (struct bfd_hash_entry *) NULL)
+           einfo ("%P%F: bfd_hash_lookup for insertion failed: %E");

        }
     }
 
        }
     }
 

-}
-
+  if (link_info.strip != strip_none)
+    einfo ("%P: `-retain-symbols-file' overrides `-s' and `-S'\n");

 
 

-/* Construct and return a lang_input_statement_struct for a library member.
-   The library's lang_input_statement_struct is library_entry,
-   and the library is open on DESC.
-   SUBFILE_OFFSET is the byte index in the library of this member's header.
-   We store the length of the member into *LENGTH_LOC.  */
-
-lang_input_statement_type *
-decode_library_subfile (library_entry, subfile_offset)
-     struct lang_input_statement_struct *library_entry;
-     bfd *subfile_offset;
+  link_info.strip = strip_some;
+}
+\f
+/* Callbacks from the BFD linker routines.  */
+
+/* This is called when BFD has decided to include an archive member in
+   a link.  */
+
+/*ARGSUSED*/
+static boolean
+add_archive_element (info, abfd, name)
+     struct bfd_link_info *info;
+     bfd *abfd;
+     const char *name;

 {
 {

-  register struct lang_input_statement_struct *subentry;
-  subentry = (struct lang_input_statement_struct *) ldmalloc ((bfd_size_type)(sizeof (struct lang_input_statement_struct)));
-  subentry->filename = subfile_offset -> filename;
-  subentry->local_sym_name  = subfile_offset->filename;
-  subentry->asymbols = 0;
-  subentry->the_bfd = subfile_offset;
-  subentry->subfiles = 0;
-  subentry->next = 0;
-  subentry->superfile = library_entry;
-  subentry->is_archive = false;
-
-  subentry->just_syms_flag = false;
-  subentry->loaded = false;
-  subentry->chain = 0;
-
-  return subentry;
+  lang_input_statement_type *input;
+
+  input = ((lang_input_statement_type *)
+          xmalloc ((bfd_size_type) sizeof (lang_input_statement_type)));
+  input->filename = abfd->filename;
+  input->local_sym_name = abfd->filename;
+  input->the_bfd = abfd;
+  input->asymbols = NULL;
+  input->next = NULL;
+  input->just_syms_flag = false;
+  input->loaded = false;
+  input->search_dirs_flag = false;
+
+  /* FIXME: The following fields are not set: header.next,
+     header.type, closed, passive_position, symbol_count,
+     next_real_file, is_archive, target, real, common_section,
+     common_output_section, complained.  This bit of code is from the
+     old decode_library_subfile function.  I don't know whether any of
+     those fields matters.  */
+
+  ldlang_add_file (input);
+
+  if (config.map_file != (FILE *) NULL)
+    minfo ("%s needed due to %T\n", abfd->filename, name);
+
+  if (trace_files || trace_file_tries)
+    info_msg ("%I\n", input);
+
+  return true;

 }
 
 }
 

-boolean  subfile_wanted_p ();
-void
-clear_syms(entry, offset)
-struct lang_input_statement_struct *entry;
-file_ptr offset;
+/* This is called when BFD has discovered a symbol which is defined
+   multiple times.  */
+
+/*ARGSUSED*/
+static boolean
+multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
+     struct bfd_link_info *info;
+     const char *name;
+     bfd *obfd;
+     asection *osec;
+     bfd_vma oval;
+     bfd *nbfd;
+     asection *nsec;
+     bfd_vma nval;

 {
 {

-  carsym *car;
-  unsigned long indx = bfd_get_next_mapent(entry->the_bfd,
-                                          BFD_NO_MORE_SYMBOLS,
-                                          &car);
-  while (indx != BFD_NO_MORE_SYMBOLS) {
-    if (car->file_offset == offset) {
-      car->name = 0;
-    }
-    indx = bfd_get_next_mapent(entry->the_bfd, indx, &car);
-  }
-
+  einfo ("%X%C: multiple definition of `%T'\n",
+        nbfd, nsec, nval, name);
+  if (obfd != (bfd *) NULL)
+    einfo ("%D: first defined here\n", obfd, osec, oval);
+  return true;

 }
 
 }
 

-/* Search a library that has a map
- */
-void
-symdef_library (entry)
-     struct lang_input_statement_struct *entry;
-
+/* This is called when there is a definition of a common symbol, or
+   when a common symbol is found for a symbol that is already defined,
+   or when two common symbols are found.  We only do something if
+   -warn-common was used.  */
+
+/*ARGSUSED*/
+static boolean
+multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
+     struct bfd_link_info *info;
+     const char *name;
+     bfd *obfd;
+     enum bfd_link_hash_type otype;
+     bfd_vma osize;
+     bfd *nbfd;
+     enum bfd_link_hash_type ntype;
+     bfd_vma nsize;

 {
 {

-  register struct lang_input_statement_struct *prev = 0;
-
-  boolean not_finished = true;
-
-
-  while (not_finished == true)
-      {
-       carsym *exported_library_name;
-       bfd *prev_archive_member_bfd = 0;    
-
-       int idx = bfd_get_next_mapent(entry->the_bfd,
-                                     BFD_NO_MORE_SYMBOLS,
-                                     &exported_library_name);
-
-       not_finished = false;
+  if (! config.warn_common)
+    return true;

 
 

-       while (idx != BFD_NO_MORE_SYMBOLS  && undefined_global_sym_count)
-           {
+  if (ntype == bfd_link_hash_defined
+      || ntype == bfd_link_hash_defweak
+      || ntype == bfd_link_hash_indirect)
+    {
+      ASSERT (otype == bfd_link_hash_common);
+      einfo ("%B: warning: definition of `%T' overriding common\n",
+            nbfd, name);
+      if (obfd != NULL)
+       einfo ("%B: warning: common is here\n", obfd);
+    }
+  else if (otype == bfd_link_hash_defined
+          || otype == bfd_link_hash_defweak
+          || otype == bfd_link_hash_indirect)
+    {
+      ASSERT (ntype == bfd_link_hash_common);
+      einfo ("%B: warning: common of `%T' overridden by definition\n",
+            nbfd, name);
+      if (obfd != NULL)
+       einfo ("%B: warning: defined here\n", obfd);
+    }
+  else
+    {
+      ASSERT (otype == bfd_link_hash_common && ntype == bfd_link_hash_common);
+      if (osize > nsize)
+       {
+         einfo ("%B: warning: common of `%T' overridden by larger common\n",
+                nbfd, name);
+         if (obfd != NULL)
+           einfo ("%B: warning: larger common is here\n", obfd);
+       }
+      else if (nsize > osize)
+       {
+         einfo ("%B: warning: common of `%T' overriding smaller common\n",
+                nbfd, name);
+         if (obfd != NULL)
+           einfo ("%B: warning: smaller common is here\n", obfd);
+       }
+      else
+       {
+         einfo ("%B: warning: multiple common of `%T'\n", nbfd, name);
+         if (obfd != NULL)
+           einfo ("%B: warning: previous common is here\n", obfd);
+       }
+    }

 
 

-             if (exported_library_name->name) 
-                 {
+  return true;
+}

 
 

-                   ldsym_type *sp =  ldsym_get_soft (exported_library_name->name);
+/* This is called when BFD has discovered a set element.  H is the
+   entry in the linker hash table for the set.  SECTION and VALUE
+   represent a value which should be added to the set.  */
+
+/*ARGSUSED*/
+static boolean
+add_to_set (info, h, reloc, abfd, section, value)
+     struct bfd_link_info *info;
+     struct bfd_link_hash_entry *h;
+     bfd_reloc_code_real_type reloc;
+     bfd *abfd;
+     asection *section;
+     bfd_vma value;
+{
+  if (! config.build_constructors)
+    return true;

 
 

-                   /* If we find a symbol that appears to be needed, think carefully
-                      about the archive member that the symbol is in.  */
-                   /* So - if it exists, and is referenced somewhere and is
-                      undefined or */
-                   if (sp && sp->srefs_chain && !sp->sdefs_chain)
-                       {
-                         bfd *archive_member_bfd = bfd_get_elt_at_index(entry->the_bfd, idx);
-                         struct lang_input_statement_struct *archive_member_lang_input_statement_struct;
+  ldctor_add_set_entry (h, reloc, section, value);

 
 

-#ifdef GNU960
-                         if (archive_member_bfd && gnu960_check_format(archive_member_bfd, bfd_object)) 
-#else
-                           if (archive_member_bfd && bfd_check_format(archive_member_bfd, bfd_object)) 
-#endif
-                               {
+  if (h->type == bfd_link_hash_new)
+    {
+      h->type = bfd_link_hash_undefined;
+      h->u.undef.abfd = abfd;
+      /* We don't call bfd_link_add_undef to add this to the list of
+        undefined symbols because we are going to define it
+        ourselves.  */
+    }

 
 

-                                 /* Don't think carefully about any archive member
-                                    more than once in a given pass.  */
-                                 if (prev_archive_member_bfd != archive_member_bfd)
-                                     {
+  return true;
+}

 
 

-                                       prev_archive_member_bfd = archive_member_bfd;
+/* This is called when BFD has discovered a constructor.  This is only
+   called for some object file formats--those which do not handle
+   constructors in some more clever fashion.  This is similar to
+   adding an element to a set, but less general.  */
+
+static boolean
+constructor_callback (info, constructor, name, abfd, section, value)
+     struct bfd_link_info *info;
+     boolean constructor;
+     const char *name;
+     bfd *abfd;
+     asection *section;
+     bfd_vma value;
+{
+  char *set_name;
+  char *s;
+  struct bfd_link_hash_entry *h;

 
 

-                                       /* Read the symbol table of the archive member.  */
+  if (! config.build_constructors)
+    return true;

 
 

-                                       if (archive_member_bfd->usrdata != (PTR)NULL) {
+  /* Ensure that BFD_RELOC_CTOR exists now, so that we can give a
+     useful error message.  */
+  if (bfd_reloc_type_lookup (output_bfd, BFD_RELOC_CTOR) == NULL)
+    einfo ("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported");
+
+  set_name = (char *) alloca (1 + sizeof "__CTOR_LIST__");
+  s = set_name;
+  if (bfd_get_symbol_leading_char (abfd) != '\0')
+    *s++ = bfd_get_symbol_leading_char (abfd);
+  if (constructor)
+    strcpy (s, "__CTOR_LIST__");
+  else
+    strcpy (s, "__DTOR_LIST__");

 
 

-                                         archive_member_lang_input_statement_struct =(lang_input_statement_type *) archive_member_bfd->usrdata;
-                                       }
-                                       else {
+  if (config.map_file != (FILE *) NULL)
+    fprintf (config.map_file,
+            "Adding %s to constructor/destructor set %s\n", name, set_name);

 
 

-                                         archive_member_lang_input_statement_struct =
-                                           decode_library_subfile (entry, archive_member_bfd);
-                                         archive_member_bfd->usrdata = (PTR) archive_member_lang_input_statement_struct;
+  h = bfd_link_hash_lookup (info->hash, set_name, true, true, true);
+  if (h == (struct bfd_link_hash_entry *) NULL)
+    einfo ("%P%F: bfd_link_hash_lookup failed: %E");
+  if (h->type == bfd_link_hash_new)
+    {
+      h->type = bfd_link_hash_undefined;
+      h->u.undef.abfd = abfd;
+      /* We don't call bfd_link_add_undef to add this to the list of
+        undefined symbols because we are going to define it
+        ourselves.  */
+    }

 
 

-                                       }
+  ldctor_add_set_entry (h, BFD_RELOC_CTOR, section, value);
+  return true;
+}

 
 

-                                       if (archive_member_lang_input_statement_struct == 0) {
-                                         info ("%F%I contains invalid archive member %s\n",
-                                               entry,
-                                               sp->name);
-                                       }
+/* This is called when there is a reference to a warning symbol.  */

 
 

-                                       if (archive_member_lang_input_statement_struct->loaded == false)  
-                                           {
+/*ARGSUSED*/
+static boolean
+warning_callback (info, warning)
+     struct bfd_link_info *info;
+     const char *warning;
+{
+  einfo ("%P: %s\n", warning);
+  return true;
+}

 
 

-                                             Q_read_entry_symbols (archive_member_bfd, archive_member_lang_input_statement_struct);
-                                             /* Now scan the symbol table and decide whether to load.  */
+/* This is called when an undefined symbol is found.  */

 
 

+/*ARGSUSED*/
+static boolean
+undefined_symbol (info, name, abfd, section, address)
+     struct bfd_link_info *info;
+     const char *name;
+     bfd *abfd;
+     asection *section;
+     bfd_vma address;
+{
+  static char *error_name;
+  static unsigned int error_count;

 
 

-                                             if (subfile_wanted_p (archive_member_lang_input_statement_struct) == true)
+#define MAX_ERRORS_IN_A_ROW 5

 
 

-                                                 {
-                                                   /* This member is needed; load it.
-                                                      Since we are loading something on this pass,
-                                                      we must make another pass through the symdef data.  */
+  if (config.warn_once)
+    {
+      static struct bfd_hash_table *hash;

 
 

-                                                   not_finished = true;
+      /* Only warn once about a particular undefined symbol.  */

 
 

-                                                   Q_enter_file_symbols (archive_member_lang_input_statement_struct);
+      if (hash == NULL)
+       {
+         hash = ((struct bfd_hash_table *)
+                 xmalloc (sizeof (struct bfd_hash_table)));
+         if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
+           einfo ("%F%P: bfd_hash_table_init failed: %E\n");
+       }

 
 

-                                                   if (prev)
-                                                     prev->chain = archive_member_lang_input_statement_struct;
-                                                   else
-                                                     entry->subfiles = archive_member_lang_input_statement_struct;
+      if (bfd_hash_lookup (hash, name, false, false) != NULL)
+       return true;

 
 

+      if (bfd_hash_lookup (hash, name, true, true) == NULL)
+       einfo ("%F%P: bfd_hash_lookup failed: %E\n");
+    }

 
 

-                                                   prev = archive_member_lang_input_statement_struct;
+  /* We never print more than a reasonable number of errors in a row
+     for a single symbol.  */
+  if (error_name != (char *) NULL
+      && strcmp (name, error_name) == 0)
+    ++error_count;
+  else
+    {
+      error_count = 0;
+      if (error_name != (char *) NULL)
+       free (error_name);
+      error_name = buystring (name);
+    }

 
 

+  if (section != NULL)
+    {
+      if (error_count < MAX_ERRORS_IN_A_ROW)
+       einfo ("%X%C: undefined reference to `%T'\n",
+              abfd, section, address, name);
+      else if (error_count == MAX_ERRORS_IN_A_ROW)
+       einfo ("%D: more undefined references to `%T' follow\n",
+              abfd, section, address, name);
+    }
+  else
+    {
+      if (error_count < MAX_ERRORS_IN_A_ROW)
+       einfo ("%X%B: undefined reference to `%T'\n",
+              abfd, name);
+      else if (error_count == MAX_ERRORS_IN_A_ROW)
+       einfo ("%B: more undefined references to `%T' follow\n",
+              abfd, name);
+    }

 
 

-                                                   /* Clear out this member's symbols from the symdef data
-                                                      so that following passes won't waste time on them.  */
-                                                   clear_syms(entry, exported_library_name->file_offset);
-                                                   archive_member_lang_input_statement_struct->loaded = true;
-                                                 }
-                                           }
-                                     }
-                               }
-                       }
-                 }
-             idx = bfd_get_next_mapent(entry->the_bfd, idx, &exported_library_name);
-           }
-      }
+  return true;

 }
 
 }
 

-void
-linear_library (entry)
-struct lang_input_statement_struct *entry;
+/* This is called when a reloc overflows.  */
+
+/*ARGSUSED*/
+static boolean
+reloc_overflow (info, name, reloc_name, addend, abfd, section, address)
+     struct bfd_link_info *info;
+     const char *name;
+     const char *reloc_name;
+     bfd_vma addend;
+     bfd *abfd;
+     asection *section;
+     bfd_vma address;

 {
 {

-  boolean more_to_do = true;
-  register struct lang_input_statement_struct *prev = 0;
-
-  while (more_to_do) {
-
-    bfd *  archive = bfd_openr_next_archived_file(entry->the_bfd,0);
-
-    more_to_do = false;
-    while (archive) {
-#ifdef GNU960
-      if (gnu960_check_format(archive, bfd_object)) 
-#else
-      if (bfd_check_format(archive, bfd_object)) 
-#endif
-       {
-         register struct lang_input_statement_struct *subentry;
-
-         subentry = decode_library_subfile (entry,
-                                            archive);
-
-         archive->usrdata = (PTR) subentry;
-         if (!subentry) return;
-         if (subentry->loaded == false) {
-           Q_read_entry_symbols (archive, subentry);
-
-           if (subfile_wanted_p (subentry) == true)
-             {
-               Q_enter_file_symbols (subentry);
-
-               if (prev)
-                 prev->chain = subentry;
-               else 
-                 entry->subfiles = subentry;
-               prev = subentry;
-
-               more_to_do = true;
-               subentry->loaded = true;
-             }
-         }
-       }
-      archive = bfd_openr_next_archived_file(entry->the_bfd,archive);
- 
-    }
-
-  }
+  if (abfd == (bfd *) NULL)
+    einfo ("%P%X: generated");
+  else
+    einfo ("%X%C:", abfd, section, address);
+  einfo (" relocation truncated to fit: %s %T", reloc_name, name);
+  if (addend != 0)
+    einfo ("+%v", addend);
+  einfo ("\n");
+  return true;

 }
 
 }
 

-  /* ENTRY is an entry for a library member.
-     Its symbols have been read into core, but not entered.
-     Return nonzero if we ought to load this member.  */
+/* This is called when a dangerous relocation is made.  */

 
 

-boolean
-subfile_wanted_p (entry)
-struct lang_input_statement_struct *entry;
+/*ARGSUSED*/
+static boolean
+reloc_dangerous (info, message, abfd, section, address)
+     struct bfd_link_info *info;
+     const char *message;
+     bfd *abfd;
+     asection *section;
+     bfd_vma address;

 {
 {

-  asymbol **q;
-
-  for (q = entry->asymbols; *q; q++)
-    {
-      asymbol *p = *q;
-
-      /* If the symbol has an interesting definition, we could
-        potentially want it.  */
-
-      if (p->flags & BSF_INDIRECT) {
-       /* Grab out the name we've indirected to, and keep the insides
-          */
-       add_indirect(q);
-      }
-
-      if (p->flags & BSF_FORT_COMM 
-         || p->flags & BSF_GLOBAL)
-       {
-         register ldsym_type *sp = ldsym_get_soft (p->name);
-
-
-         /* If this symbol has not been hashed,
-            we can't be looking for it. */
-         if (sp != (ldsym_type *)NULL 
-             && sp->sdefs_chain == (asymbol **)NULL) {
-           if (sp->srefs_chain  != (asymbol **)NULL
-               || sp->scoms_chain != (asymbol **)NULL)
-             {
-               /* This is a symbol we are looking for.  It is either
-                  not yet defined or common.  */
-
-               if (flag_is_common(p->flags))
-                 {
-
-                   /* If the symbol in the table is a constructor, we won't to
-                      anything fancy with it */
-                   if ((sp->flags & SYM_CONSTRUCTOR) == 0) {
-                   /* This libary member has something to
-                      say about this element. We should 
-                      remember if its a new size  */
-                   /* Move something from the ref list to the com list */
-                   if(sp->scoms_chain) {
-                     /* Already a common symbol, maybe update it */
-                     if (p->value > (*(sp->scoms_chain))->value) {
-                       (*(sp->scoms_chain))->value = p->value;
-                     }
-                   }
-                   else {
-                     /* Take a value from the ref chain
-                        Here we are moving a symbol from the owning bfd
-                        to another bfd. We must set up the
-                        common_section portion of the bfd thing */
-
-                     
-
-                     sp->scoms_chain = sp->srefs_chain;
-                     sp->srefs_chain =
-                       (asymbol **)((*(sp->srefs_chain))->udata);
-                     (*(sp->scoms_chain))->udata = (PTR)NULL;
-
-                     (*(  sp->scoms_chain))->flags = BSF_FORT_COMM;
-                     /* Remember the size of this item */
-                     sp->scoms_chain[0]->value = p->value;
-                     commons_pending++;
-                     undefined_global_sym_count--;
-                   } {
-                     asymbol *com = *(sp->scoms_chain);
-                     if (((lang_input_statement_type *)
-                          (com->the_bfd->usrdata))->common_section ==
-                         (asection *)NULL) {
-                       ((lang_input_statement_type *)
-                        (com->the_bfd->usrdata))->common_section = 
-                          bfd_make_section(com->the_bfd, "COMMON");
-                     }
-                   }
-                 }
-                   ASSERT(p->udata == 0);
-                 }
-             
-               else {
-                 if (write_map)
-                   {
-                     info("%I needed due to %s\n",entry, sp->name);
-                   }
-                 return true;
-               }
-             }
-         }
-       }
-    }
+  if (abfd == (bfd *) NULL)
+    einfo ("%P%X: generated");
+  else
+    einfo ("%X%C:", abfd, section, address);
+  einfo ("dangerous relocation: %s\n", message);
+  return true;
+}

 
 

-  return false;
+/* This is called when a reloc is being generated attached to a symbol
+   that is not being output.  */
+
+/*ARGSUSED*/
+static boolean
+unattached_reloc (info, name, abfd, section, address)
+     struct bfd_link_info *info;
+     const char *name;
+     bfd *abfd;
+     asection *section;
+     bfd_vma address;
+{
+  if (abfd == (bfd *) NULL)
+    einfo ("%P%X: generated");
+  else
+    einfo ("%X%C:", abfd, section, address);
+  einfo (" reloc refers to symbol `%T' which is not being output\n", name);
+  return true;

 }
 
 }
 

+/* This is called when a symbol in notice_hash is found.  Symbols are
+   put in notice_hash using the -y option.  */
+
+/*ARGSUSED*/
+static boolean
+notice_ysym (info, name, abfd, section, value)
+     struct bfd_link_info *info;
+     const char *name;
+     bfd *abfd;
+     asection *section;
+     bfd_vma value;
+{
+  einfo ("%B: %s %s\n", abfd,
+        bfd_is_und_section (section) ? "reference to" : "definition of",
+        name);
+  return true;
+}