projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
bfd/
[deliverable/binutils-gdb.git] / ld / ldmain.c
diff --git a/ld/ldmain.c b/ld/ldmain.c
index 578e34f84e0d07f6eac11cb7bc221ded3a95349d..1784b16c16acb87825b96c336a0a8169e12b7246 100644 (file)
--- a/ld/ldmain.c
+++ b/ld/ldmain.c
@@ -1,24 +1,25 @@
 /* Main program of GNU linker.
 /* Main program of GNU linker.
-   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+   2002, 2003, 2004, 2005, 2006
    Free Software Foundation, Inc.
    Written by Steve Chamberlain steve@cygnus.com
 
    Free Software Foundation, Inc.
    Written by Steve Chamberlain steve@cygnus.com
 
-This file is part of GLD, the Gnu Linker.
+   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 2, or (at your option)
-any later version.
+   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 2, or (at your option)
+   any later version.
 
 
-GLD 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.
+   GLD 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 GLD; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+   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, 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
 
 #include "bfd.h"
 #include "sysdep.h"
@@ -33,15 +34,15 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "ldmain.h"
 #include "ldmisc.h"
 #include "ldwrite.h"
 #include "ldmain.h"
 #include "ldmisc.h"
 #include "ldwrite.h"
-#include "ldgram.h"
 #include "ldexp.h"
 #include "ldlang.h"
 #include "ldexp.h"
 #include "ldlang.h"
+#include <ldgram.h>
 #include "ldlex.h"
 #include "ldfile.h"
 #include "ldemul.h"
 #include "ldctor.h"
 
 #include "ldlex.h"
 #include "ldfile.h"
 #include "ldemul.h"
 #include "ldctor.h"
 
-/* Somewhere above, sys/stat.h got included . . . .  */
+/* Somewhere above, sys/stat.h got included.  */
 #if !defined(S_ISDIR) && defined(S_IFDIR)
 #define        S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #endif
 #if !defined(S_ISDIR) && defined(S_IFDIR)
 #define        S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #endif
@@ -49,13 +50,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include <string.h>
 
 #ifdef HAVE_SBRK
 #include <string.h>
 
 #ifdef HAVE_SBRK
-#ifdef NEED_DECLARATION_SBRK
-extern PTR sbrk ();
+#if !HAVE_DECL_SBRK
+extern void *sbrk ();
 #endif
 #endif
 
 #endif
 #endif
 
-static char *get_emulation PARAMS ((int, char **));
-static void set_scripts_dir PARAMS ((void));
+#ifndef TARGET_SYSTEM_ROOT
+#define TARGET_SYSTEM_ROOT ""
+#endif
 
 /* EXPORTS */
 
 
 /* EXPORTS */
 
@@ -65,6 +67,13 @@ const char *output_filename = "a.out";
 /* Name this program was invoked by.  */
 char *program_name;
 
 /* 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;
+
 /* The file that we're creating.  */
 bfd *output_bfd = 0;
 
 /* The file that we're creating.  */
 bfd *output_bfd = 0;
 
@@ -72,65 +81,75 @@ bfd *output_bfd = 0;
 int g_switch_value = 8;
 
 /* Nonzero means print names of input files as processed.  */
 int g_switch_value = 8;
 
 /* Nonzero means print names of input files as processed.  */
-boolean trace_files;
+bfd_boolean trace_files;
 
 /* Nonzero means same, but note open failures, too.  */
 
 /* Nonzero means same, but note open failures, too.  */
-boolean trace_file_tries;
+bfd_boolean trace_file_tries;
 
 /* Nonzero means version number was printed, so exit successfully
    instead of complaining if no input files are given.  */
 
 /* Nonzero means version number was printed, so exit successfully
    instead of complaining if no input files are given.  */
-boolean version_printed;
+bfd_boolean version_printed;
 
 /* Nonzero means link in every member of an archive.  */
 
 /* Nonzero means link in every member of an archive.  */
-boolean whole_archive;
+bfd_boolean whole_archive;
+
+/* Nonzero means create DT_NEEDED entries only if a dynamic library
+   actually satisfies some reference in a regular object.  */
+bfd_boolean as_needed;
+
+/* Nonzero means never create DT_NEEDED entries for dynamic libraries
+   in DT_NEEDED tags.  */
+bfd_boolean add_needed = TRUE;
 
 
-/* True if we should demangle symbol names.  */
-boolean demangling;
+/* TRUE if we should demangle symbol names.  */
+bfd_boolean demangling;
 
 args_type command_line;
 
 ld_config_type config;
 
 
 args_type command_line;
 
 ld_config_type config;
 
-static void remove_output PARAMS ((void));
-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 *, const char *, bfd *,
-                                        asection *, bfd_vma));
-static void warning_find_reloc PARAMS ((bfd *, asection *, PTR));
-static boolean undefined_symbol PARAMS ((struct bfd_link_info *,
-                                        const char *, bfd *,
-                                        asection *, bfd_vma, boolean));
-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 PARAMS ((struct bfd_link_info *, const char *,
-                              bfd *, asection *, bfd_vma));
-
-static struct bfd_link_callbacks link_callbacks = {
+sort_type sort_section;
+
+static const char *get_sysroot
+  (int, char **);
+static char *get_emulation
+  (int, char **);
+static void set_scripts_dir
+  (void);
+static bfd_boolean add_archive_element
+  (struct bfd_link_info *, bfd *, const char *);
+static bfd_boolean multiple_definition
+  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
+   bfd *, asection *, bfd_vma);
+static bfd_boolean multiple_common
+  (struct bfd_link_info *, const char *, bfd *, enum bfd_link_hash_type,
+   bfd_vma, bfd *, enum bfd_link_hash_type, bfd_vma);
+static bfd_boolean add_to_set
+  (struct bfd_link_info *, struct bfd_link_hash_entry *,
+   bfd_reloc_code_real_type, bfd *, asection *, bfd_vma);
+static bfd_boolean constructor_callback
+  (struct bfd_link_info *, bfd_boolean, const char *, bfd *,
+   asection *, bfd_vma);
+static bfd_boolean warning_callback
+  (struct bfd_link_info *, const char *, const char *, bfd *,
+   asection *, bfd_vma);
+static void warning_find_reloc
+  (bfd *, asection *, void *);
+static bfd_boolean undefined_symbol
+  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma,
+   bfd_boolean);
+static bfd_boolean reloc_overflow
+  (struct bfd_link_info *, struct bfd_link_hash_entry *, const char *,
+   const char *, bfd_vma, bfd *, asection *, bfd_vma);
+static bfd_boolean reloc_dangerous
+  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
+static bfd_boolean unattached_reloc
+  (struct bfd_link_info *, const char *, bfd *, asection *, bfd_vma);
+static bfd_boolean notice
+  (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_archive_element,
   multiple_definition,
   multiple_common,
@@ -141,27 +160,26 @@ static struct bfd_link_callbacks link_callbacks = {
   reloc_overflow,
   reloc_dangerous,
   unattached_reloc,
   reloc_overflow,
   reloc_dangerous,
   unattached_reloc,
-  notice
+  notice,
+  einfo
 };
 
 struct bfd_link_info link_info;
 \f
 static void
 };
 
 struct bfd_link_info link_info;
 \f
 static void
-remove_output ()
+remove_output (void)
 {
   if (output_filename)
     {
 {
   if (output_filename)
     {
-      if (output_bfd && output_bfd->iostream)
-       fclose ((FILE *) (output_bfd->iostream));
+      if (output_bfd)
+       bfd_cache_close (output_bfd);
       if (delete_output_file_on_failure)
       if (delete_output_file_on_failure)
-       unlink (output_filename);
+       unlink_if_ordinary (output_filename);
     }
 }
 
 int
     }
 }
 
 int
-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)
 {
   char *emulation;
   long start_time = get_run_time ();
 {
   char *emulation;
   long start_time = get_run_time ();
@@ -180,12 +198,31 @@ main (argc, argv)
 
   START_PROGRESS (program_name, 0);
 
 
   START_PROGRESS (program_name, 0);
 
+  expandargv (&argc, &argv);
+
   bfd_init ();
 
   bfd_set_error_program_name (program_name);
 
   xatexit (remove_output);
 
   bfd_init ();
 
   bfd_set_error_program_name (program_name);
 
   xatexit (remove_output);
 
+  /* Set up the sysroot directory.  */
+  ld_sysroot = get_sysroot (argc, argv);
+  if (*ld_sysroot)
+    {
+      if (*TARGET_SYSTEM_ROOT == 0)
+       {
+         einfo ("%P%F: this linker was not configured to use sysroots\n");
+         ld_sysroot = "";
+       }
+      else
+       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
   /* 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
@@ -196,20 +233,31 @@ main (argc, argv)
       xexit (1);
     }
 
       xexit (1);
     }
 
+#if YYDEBUG
+  {
+    extern int yydebug;
+    yydebug = 1;
+  }
+#endif
+
   /* Initialize the data about options.  */
   /* Initialize the data about options.  */
-  trace_files = trace_file_tries = version_printed = false;
-  whole_archive = false;
-  config.build_constructors = true;
-  config.dynamic_link = false;
-  config.has_shared = false;
+  trace_files = trace_file_tries = version_printed = FALSE;
+  whole_archive = FALSE;
+  config.build_constructors = TRUE;
+  config.dynamic_link = FALSE;
+  config.has_shared = FALSE;
   config.split_by_reloc = (unsigned) -1;
   config.split_by_file = (bfd_size_type) -1;
   config.split_by_reloc = (unsigned) -1;
   config.split_by_file = (bfd_size_type) -1;
-  command_line.force_common_definition = false;
-  command_line.inhibit_common_definition = false;
+  config.hash_table_size = 0;
+  command_line.force_common_definition = FALSE;
+  command_line.inhibit_common_definition = FALSE;
   command_line.interpreter = NULL;
   command_line.rpath = NULL;
   command_line.interpreter = NULL;
   command_line.rpath = NULL;
-  command_line.warn_mismatch = true;
-  command_line.check_section_addresses = true;
+  command_line.warn_mismatch = TRUE;
+  command_line.check_section_addresses = TRUE;
+  command_line.accept_unknown_input_arch = FALSE;
+
+  sort_section = none;
 
   /* We initialize DEMANGLING based on the environment variable
      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
 
   /* We initialize DEMANGLING based on the environment variable
      COLLECT_NO_DEMANGLE.  The gcc collect2 program will demangle the
@@ -218,62 +266,95 @@ main (argc, argv)
      interface by default.  */
   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 
      interface by default.  */
   demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
 
-  link_info.callbacks = &link_callbacks;
-  link_info.relocateable = false;
-  link_info.emitrelocations = false;
-  link_info.shared = false;
-  link_info.symbolic = false;
-  link_info.export_dynamic = false;
-  link_info.static_link = false;
-  link_info.traditional_format = false;
-  link_info.optimize = false;
-  link_info.no_undefined = false;
-  link_info.allow_shlib_undefined = false;
+  link_info.relocatable = FALSE;
+  link_info.emitrelocations = FALSE;
+  link_info.task_link = FALSE;
+  link_info.shared = FALSE;
+  link_info.pie = FALSE;
+  link_info.executable = FALSE;
+  link_info.symbolic = FALSE;
+  link_info.export_dynamic = FALSE;
+  link_info.static_link = FALSE;
+  link_info.traditional_format = FALSE;
+  link_info.optimize = FALSE;
+  link_info.unresolved_syms_in_objects = RM_NOT_YET_SET;
+  link_info.unresolved_syms_in_shared_libs = RM_NOT_YET_SET;
+  link_info.allow_multiple_definition = FALSE;
+  link_info.allow_undefined_version = TRUE;
+  link_info.create_default_symver = FALSE;
+  link_info.default_imported_symver = FALSE;
+  link_info.keep_memory = TRUE;
+  link_info.notice_all = FALSE;
+  link_info.nocopyreloc = FALSE;
+  link_info.new_dtags = FALSE;
+  link_info.combreloc = TRUE;
+  link_info.eh_frame_hdr = FALSE;
+  link_info.relro = FALSE;
+  link_info.strip_discarded = TRUE;
   link_info.strip = strip_none;
   link_info.discard = discard_sec_merge;
   link_info.strip = strip_none;
   link_info.discard = discard_sec_merge;
-  link_info.keep_memory = true;
-  link_info.input_bfds = NULL;
-  link_info.create_object_symbols_section = NULL;
+  link_info.common_skip_ar_aymbols = bfd_link_common_skip_none;
+  link_info.callbacks = &link_callbacks;
   link_info.hash = NULL;
   link_info.keep_hash = NULL;
   link_info.hash = NULL;
   link_info.keep_hash = NULL;
-  link_info.notice_all = false;
   link_info.notice_hash = NULL;
   link_info.wrap_hash = NULL;
   link_info.notice_hash = NULL;
   link_info.wrap_hash = NULL;
-  link_info.mpc860c0 = 0;
+  link_info.input_bfds = NULL;
+  link_info.create_object_symbols_section = NULL;
+  link_info.gc_sym_list = NULL;
+  link_info.base_file = NULL;
+  link_info.emit_hash = TRUE;
+  link_info.emit_gnu_hash = FALSE;
   /* 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";
   /* 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.new_dtags = false;
-  link_info.flags = (bfd_vma) 0;
-  link_info.flags_1 = (bfd_vma) 0;
-  link_info.pei386_auto_import = false;
-  link_info.combreloc = false;
+  link_info.pei386_auto_import = -1;
+  link_info.pei386_runtime_pseudo_reloc = FALSE;
   link_info.spare_dynamic_tags = 5;
   link_info.spare_dynamic_tags = 5;
+  link_info.flags = 0;
+  link_info.flags_1 = 0;
+  link_info.relax_pass = 1;
+  link_info.warn_shared_textrel = FALSE;
+  link_info.gc_sections = FALSE;
+  link_info.print_gc_sections = FALSE;
+  link_info.dynamic = NULL;
+  link_info.reduce_memory_overheads = FALSE;
+
+  config.maxpagesize = 0;
+  config.commonpagesize = 0;
 
   ldfile_add_arch ("");
 
 
   ldfile_add_arch ("");
 
-  config.make_executable = true;
-  force_make_executable = false;
-  config.magic_demand_paged = true;
-  config.text_read_only = true;
+  config.make_executable = TRUE;
+  force_make_executable = FALSE;
+  config.magic_demand_paged = TRUE;
+  config.text_read_only = TRUE;
 
   emulation = get_emulation (argc, argv);
   ldemul_choose_mode (emulation);
 
   emulation = get_emulation (argc, argv);
   ldemul_choose_mode (emulation);
-  default_target = ldemul_choose_target ();
+  default_target = ldemul_choose_target (argc, argv);
   lang_init ();
   ldemul_before_parse ();
   lang_init ();
   ldemul_before_parse ();
-  lang_has_input_file = false;
+  lang_has_input_file = FALSE;
   parse_args (argc, argv);
 
   parse_args (argc, argv);
 
+  if (config.hash_table_size != 0)
+    bfd_hash_set_default_size (config.hash_table_size);
+
+  if (config.maxpagesize != 0)
+    bfd_emul_set_maxpagesize (default_target, config.maxpagesize);
+
+  if (config.commonpagesize != 0)
+    bfd_emul_set_commonpagesize (default_target,
+                                config.commonpagesize);
+
   ldemul_set_symbols ();
 
   ldemul_set_symbols ();
 
-  if (link_info.relocateable)
+  if (link_info.relocatable)
     {
     {
-      if (command_line.gc_sections)
+      if (link_info.gc_sections)
        einfo ("%P%F: --gc-sections and -r may not be used together\n");
        einfo ("%P%F: --gc-sections and -r may not be used together\n");
-      if (link_info.mpc860c0)
-       einfo (_("%P%F: -r and --mpc860c0 may not be used together\n"));
       else if (command_line.relax)
        einfo (_("%P%F: --relax and -r may not be used together\n"));
       if (link_info.shared)
       else if (command_line.relax)
        einfo (_("%P%F: --relax and -r may not be used together\n"));
       if (link_info.shared)
@@ -288,10 +369,13 @@ main (argc, argv)
        einfo (_("%P%F: -f may not be used without -shared\n"));
     }
 
        einfo (_("%P%F: -f may not be used without -shared\n"));
     }
 
+  if (! link_info.shared || link_info.pie)
+    link_info.executable = TRUE;
+
   /* 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.  */
   /* 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)
+  if (link_info.relocatable && link_info.strip == strip_all)
     {
       link_info.strip = strip_debugger;
       if (link_info.discard == discard_sec_merge)
     {
       link_info.strip = strip_debugger;
       if (link_info.discard == discard_sec_merge)
@@ -307,12 +391,12 @@ main (argc, argv)
   if (saved_script_handle == NULL)
     {
       int isfile;
   if (saved_script_handle == NULL)
     {
       int isfile;
-      char *s = ldemul_get_script (& isfile);
+      char *s = ldemul_get_script (&isfile);
 
       if (isfile)
        ldfile_open_command_file (s);
       else
 
       if (isfile)
        ldfile_open_command_file (s);
       else
-       {       
+       {
          lex_string = s;
          lex_redirect (s);
        }
          lex_string = s;
          lex_redirect (s);
        }
@@ -323,9 +407,11 @@ main (argc, argv)
 
   if (trace_file_tries)
     {
 
   if (trace_file_tries)
     {
-      info_msg (_("using %s linker script:\n"),
-               saved_script_handle ? "external" : "internal");
-      info_msg ("==================================================\n");
+      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)
        {
 
       if (saved_script_handle)
        {
@@ -336,7 +422,7 @@ main (argc, argv)
          rewind (saved_script_handle);
          while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
            {
          rewind (saved_script_handle);
          while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
            {
-             buf [n] = 0;
+             buf[n] = 0;
              info_msg (buf);
            }
          rewind (saved_script_handle);
              info_msg (buf);
            }
          rewind (saved_script_handle);
@@ -346,15 +432,15 @@ main (argc, argv)
        {
          int isfile;
 
        {
          int isfile;
 
-         info_msg (ldemul_get_script (& isfile));
+         info_msg (ldemul_get_script (&isfile));
        }
        }
-      
+
       info_msg ("\n==================================================\n");
     }
 
   lang_final ();
 
       info_msg ("\n==================================================\n");
     }
 
   lang_final ();
 
-  if (lang_has_input_file == false)
+  if (!lang_has_input_file)
     {
       if (version_printed)
        xexit (0);
     {
       if (version_printed)
        xexit (0);
@@ -362,9 +448,7 @@ main (argc, argv)
     }
 
   if (trace_files)
     }
 
   if (trace_files)
-    {
-      info_msg (_("%P: mode %s\n"), emulation);
-    }
+    info_msg (_("%P: mode %s\n"), emulation);
 
   ldemul_after_parse ();
 
 
   ldemul_after_parse ();
 
@@ -390,22 +474,7 @@ main (argc, argv)
 
   /* Print error messages for any missing symbols, for any warning
      symbols, and possibly multiple definitions.  */
 
   /* Print error messages for any missing symbols, for any warning
      symbols, and possibly multiple definitions.  */
-
-  if (! link_info.relocateable)
-    {
-      /* Look for a text section and switch the readonly attribute in it.  */
-      asection *found = bfd_get_section_by_name (output_bfd, ".text");
-
-      if (found != (asection *) NULL)
-       {
-         if (config.text_read_only)
-           found->flags |= SEC_READONLY;
-         else
-           found->flags &= ~SEC_READONLY;
-       }
-    }
-
-  if (link_info.relocateable)
+  if (link_info.relocatable)
     output_bfd->flags &= ~EXEC_P;
   else
     output_bfd->flags |= EXEC_P;
     output_bfd->flags &= ~EXEC_P;
   else
     output_bfd->flags |= EXEC_P;
@@ -419,20 +488,18 @@ main (argc, argv)
   if (nocrossref_list != NULL)
     check_nocrossrefs ();
 
   if (nocrossref_list != NULL)
     check_nocrossrefs ();
 
-  /* 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?)  */
+  lang_finish ();
 
 
-  if (config.make_executable == false && force_make_executable == false)
+  /* 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 == true)
-       {
-         einfo (_("%P: link errors found, deleting executable `%s'\n"),
-                output_filename);
-       }
+      if (trace_files)
+       einfo (_("%P: link errors found, deleting executable `%s'\n"),
+              output_filename);
 
       /* The file will be removed by remove_output.  */
 
       /* The file will be removed by remove_output.  */
-
       xexit (1);
     }
   else
       xexit (1);
     }
   else
@@ -443,9 +510,10 @@ main (argc, argv)
       /* 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 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 (! link_info.relocateable && command_line.force_exe_suffix)
+      if (! link_info.relocatable && command_line.force_exe_suffix)
        {
          int len = strlen (output_filename);
        {
          int len = strlen (output_filename);
+
          if (len < 4
              || (strcasecmp (output_filename + len - 4, ".exe") != 0
                  && strcasecmp (output_filename + len - 4, ".dll") != 0))
          if (len < 4
              || (strcasecmp (output_filename + len - 4, ".exe") != 0
                  && strcasecmp (output_filename + len - 4, ".dll") != 0))
@@ -456,28 +524,29 @@ main (argc, argv)
              char *buf = xmalloc (bsize);
              int l;
              char *dst_name = xmalloc (len + 5);
              char *buf = xmalloc (bsize);
              int l;
              char *dst_name = 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)
              strcpy (dst_name, output_filename);
              strcat (dst_name, ".exe");
              src = fopen (output_filename, FOPEN_RB);
              dst = fopen (dst_name, FOPEN_WB);
 
              if (!src)
-               einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename);
+               einfo (_("%X%P: unable to open for source of copy `%s'\n"),
+                      output_filename);
              if (!dst)
              if (!dst)
-               einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name);
+               einfo (_("%X%P: 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);
              while ((l = fread (buf, 1, bsize, src)) > 0)
                {
                  int done = fwrite (buf, 1, l, dst);
+
                  if (done != l)
                  if (done != l)
-                   {
-                     einfo (_("%P: Error writing file `%s'\n"), dst_name);
-                   }
+                   einfo (_("%P: Error writing file `%s'\n"), dst_name);
                }
                }
+
              fclose (src);
              if (fclose (dst) == EOF)
              fclose (src);
              if (fclose (dst) == EOF)
-               {
-                 einfo (_("%P: Error closing file `%s'\n"), dst_name);
-               }
+               einfo (_("%P: Error closing file `%s'\n"), dst_name);
              free (dst_name);
              free (buf);
            }
              free (dst_name);
              free (buf);
            }
@@ -489,7 +558,7 @@ main (argc, argv)
   if (config.stats)
     {
 #ifdef HAVE_SBRK
   if (config.stats)
     {
 #ifdef HAVE_SBRK
-      char *lim = (char *) sbrk (0);
+      char *lim = sbrk (0);
 #endif
       long run_time = get_run_time () - start_time;
 
 #endif
       long run_time = get_run_time () - start_time;
 
@@ -508,13 +577,56 @@ main (argc, argv)
   return 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 *
 /* 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;
+get_emulation (int argc, char **argv)
 {
   char *emulation;
   int i;
 {
   char *emulation;
   int i;
@@ -525,7 +637,7 @@ get_emulation (argc, argv)
 
   for (i = 1; i < argc; i++)
     {
 
   for (i = 1; i < argc; i++)
     {
-      if (!strncmp (argv[i], "-m", 2))
+      if (CONST_STRNEQ (argv[i], "-m"))
        {
          if (argv[i][2] == '\0')
            {
        {
          if (argv[i][2] == '\0')
            {
@@ -536,17 +648,17 @@ get_emulation (argc, argv)
                  i++;
                }
              else
                  i++;
                }
              else
-               {
-                 einfo (_("%P%F: missing argument to -m\n"));
-               }
+               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
            }
          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], "-mips32") == 0
+                  || strcmp (argv[i], "-mips32r2") == 0
                   || strcmp (argv[i], "-mips64") == 0
                   || strcmp (argv[i], "-mips64") == 0
-                  || strcmp (argv[i], "-mips4") == 0
-                  || strcmp (argv[i], "-mips5") == 0)
+                  || strcmp (argv[i], "-mips64r2") == 0)
            {
              /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
                 passed to the linker by some MIPS compilers.  They
            {
              /* FIXME: The arguments -mips1, -mips2, -mips3, etc. are
                 passed to the linker by some MIPS compilers.  They
@@ -574,27 +686,26 @@ get_emulation (argc, argv)
 }
 
 /* If directory DIR contains an "ldscripts" subdirectory,
 }
 
 /* If directory DIR contains an "ldscripts" subdirectory,
-   add DIR to the library search path and return true,
-   else return false.  */
+   add DIR to the library search path and return TRUE,
+   else return FALSE.  */
 
 
-static boolean
-check_for_scripts_dir (dir)
-     char *dir;
+static bfd_boolean
+check_for_scripts_dir (char *dir)
 {
   size_t dirlen;
   char *buf;
   struct stat s;
 {
   size_t dirlen;
   char *buf;
   struct stat s;
-  boolean res;
+  bfd_boolean res;
 
   dirlen = strlen (dir);
   /* sizeof counts the terminating NUL.  */
 
   dirlen = strlen (dir);
   /* sizeof counts the terminating NUL.  */
-  buf = (char *) xmalloc (dirlen + sizeof ("/ldscripts"));
+  buf = xmalloc (dirlen + sizeof ("/ldscripts"));
   sprintf (buf, "%s/ldscripts", dir);
 
   res = stat (buf, &s) == 0 && S_ISDIR (s.st_mode);
   free (buf);
   if (res)
   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);
+    ldfile_add_library_path (dir, FALSE);
   return res;
 }
 
   return res;
 }
 
@@ -602,15 +713,37 @@ check_for_scripts_dir (dir)
    Libraries will be searched for here too, but that's ok.
    We look for the "ldscripts" directory in:
 
    Libraries will be searched for here too, but that's ok.
    We look for the "ldscripts" directory in:
 
+   SCRIPTDIR (passed from Makefile)
+            (adjusted according to the current location of the binary)
    SCRIPTDIR (passed from Makefile)
    the dir where this program is (for using it from the build tree)
    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) */
+   the dir where this program is/../lib
+            (for installing the tool suite elsewhere).  */
 
 static void
 
 static void
-set_scripts_dir ()
+set_scripts_dir (void)
 {
   char *end, *dir;
   size_t dirlen;
 {
   char *end, *dir;
   size_t dirlen;
+  bfd_boolean found;
+
+  dir = make_relative_prefix (program_name, BINDIR, SCRIPTDIR);
+  if (dir)
+    {
+      found = check_for_scripts_dir (dir);
+      free (dir);
+      if (found)
+       return;
+    }
+
+  dir = make_relative_prefix (program_name, TOOLBINDIR, SCRIPTDIR);
+  if (dir)
+    {
+      found = check_for_scripts_dir (dir);
+      free (dir);
+      if (found)
+       return;
+    }
 
   if (check_for_scripts_dir (SCRIPTDIR))
     /* We've been installed normally.  */
 
   if (check_for_scripts_dir (SCRIPTDIR))
     /* We've been installed normally.  */
@@ -622,81 +755,76 @@ set_scripts_dir ()
   {
     /* We could have \foo\bar, or /foo\bar.  */
     char *bslash = strrchr (program_name, '\\');
   {
     /* We could have \foo\bar, or /foo\bar.  */
     char *bslash = strrchr (program_name, '\\');
+
     if (end == NULL || (bslash != NULL && bslash > end))
       end = bslash;
   }
 #endif
 
   if (end == NULL)
     if (end == NULL || (bslash != NULL && bslash > end))
       end = bslash;
   }
 #endif
 
   if (end == NULL)
-    {
-      /* Don't look for ldscripts in the current directory.  There is
-         too much potential for confusion.  */
-      return;
-    }
+    /* Don't look for ldscripts in the current directory.  There is
+       too much potential for confusion.  */
+    return;
 
   dirlen = end - program_name;
   /* Make a copy of program_name in dir.
      Leave room for later "/../lib".  */
 
   dirlen = end - program_name;
   /* Make a copy of program_name in dir.
      Leave room for later "/../lib".  */
-  dir = (char *) xmalloc (dirlen + 8);
+  dir = xmalloc (dirlen + 8);
   strncpy (dir, program_name, dirlen);
   dir[dirlen] = '\0';
 
   if (check_for_scripts_dir (dir))
   strncpy (dir, program_name, dirlen);
   dir[dirlen] = '\0';
 
   if (check_for_scripts_dir (dir))
-    /* Don't free dir.  */
-    return;
+    {
+      free (dir);
+      return;
+    }
 
   /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
   strcpy (dir + dirlen, "/../lib");
 
   /* Look for "ldscripts" in <the dir where our binary is>/../lib.  */
   strcpy (dir + dirlen, "/../lib");
-  if (check_for_scripts_dir (dir))
-    return;
-
-  /* Well, we tried.  */
+  check_for_scripts_dir (dir);
   free (dir);
 }
 
 void
   free (dir);
 }
 
 void
-add_ysym (name)
-     const char *name;
+add_ysym (const char *name)
 {
 {
-  if (link_info.notice_hash == (struct bfd_hash_table *) NULL)
+  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,
-                                  61))
+      link_info.notice_hash = 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"));
     }
 
        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)
+  if (bfd_hash_lookup (link_info.notice_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
     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 }
 
 /* Record a symbol to be wrapped, from the --wrap option.  */
 
 void
-add_wrap (name)
-     const char *name;
+add_wrap (const char *name)
 {
   if (link_info.wrap_hash == NULL)
     {
 {
   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,
-                                  61))
+      link_info.wrap_hash = 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"));
     }
        einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
     }
-  if (bfd_hash_lookup (link_info.wrap_hash, name, true, true) == NULL)
+
+  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
     einfo (_("%P%F: bfd_hash_lookup failed: %E\n"));
 }
 
 /* Handle the -retain-symbols-file option.  */
 
 void
-add_keepsyms_file (filename)
-     const char *filename;
+add_keepsyms_file (const char *filename)
 {
   FILE *file;
   char *buf;
 {
   FILE *file;
   char *buf;
@@ -707,20 +835,20 @@ add_keepsyms_file (filename)
     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 
   file = fopen (filename, "r");
     einfo (_("%X%P: error: duplicate retain-symbols-file\n"));
 
   file = fopen (filename, "r");
-  if (file == (FILE *) NULL)
+  if (file == NULL)
     {
       bfd_set_error (bfd_error_system_call);
       einfo ("%X%P: %s: %E\n", filename);
       return;
     }
 
     {
       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))
+  link_info.keep_hash = 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;
     einfo (_("%P%F: bfd_hash_table_init failed: %E\n"));
 
   bufsize = 100;
-  buf = (char *) xmalloc (bufsize);
+  buf = xmalloc (bufsize);
 
   c = getc (file);
   while (c != EOF)
 
   c = getc (file);
   while (c != EOF)
@@ -746,8 +874,7 @@ add_keepsyms_file (filename)
 
          buf[len] = '\0';
 
 
          buf[len] = '\0';
 
-         if (bfd_hash_lookup (link_info.keep_hash, buf, true, true)
-             == (struct bfd_hash_entry *) NULL)
+         if (bfd_hash_lookup (link_info.keep_hash, buf, TRUE, TRUE) == NULL)
            einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
        }
     }
            einfo (_("%P%F: bfd_hash_lookup for insertion failed: %E\n"));
        }
     }
@@ -755,6 +882,7 @@ add_keepsyms_file (filename)
   if (link_info.strip != strip_none)
     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 
   if (link_info.strip != strip_none)
     einfo (_("%P: `-retain-symbols-file' overrides `-s' and `-S'\n"));
 
+  free (buf);
   link_info.strip = strip_some;
 }
 \f
   link_info.strip = strip_some;
 }
 \f
@@ -763,24 +891,22 @@ add_keepsyms_file (filename)
 /* This is called when BFD has decided to include an archive member in
    a link.  */
 
 /* This is called when BFD has decided to include an archive member in
    a link.  */
 
-static boolean
-add_archive_element (info, abfd, name)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     bfd *abfd;
-     const char *name;
+static bfd_boolean
+add_archive_element (struct bfd_link_info *info,
+                    bfd *abfd,
+                    const char *name)
 {
   lang_input_statement_type *input;
 
 {
   lang_input_statement_type *input;
 
-  input = ((lang_input_statement_type *)
-          xmalloc (sizeof (lang_input_statement_type)));
+  input = xmalloc (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->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;
+  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,
 
   /* FIXME: The following fields are not set: header.next,
      header.type, closed, passive_position, symbol_count,
@@ -790,14 +916,14 @@ add_archive_element (info, abfd, name)
 
   ldlang_add_file (input);
 
 
   ldlang_add_file (input);
 
-  if (config.map_file != (FILE *) NULL)
+  if (config.map_file != NULL)
     {
     {
-      static boolean header_printed;
+      static bfd_boolean header_printed;
       struct bfd_link_hash_entry *h;
       bfd *from;
       int len;
 
       struct bfd_link_hash_entry *h;
       bfd *from;
       int len;
 
-      h = bfd_link_hash_lookup (link_info.hash, name, false, false, true);
+      h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 
       if (h == NULL)
        from = NULL;
 
       if (h == NULL)
        from = NULL;
@@ -829,10 +955,9 @@ add_archive_element (info, abfd, name)
        {
          char buf[100];
 
        {
          char buf[100];
 
-         sprintf (buf, "%-29s %s\n\n", _("Archive member included"),
-                  _("because of file (symbol)"));
+         sprintf (buf, _("Archive member included because of file (symbol)\n\n"));
          minfo ("%s", buf);
          minfo ("%s", buf);
-         header_printed = true;
+         header_printed = TRUE;
        }
 
       if (bfd_my_archive (abfd) == NULL)
        }
 
       if (bfd_my_archive (abfd) == NULL)
@@ -871,22 +996,21 @@ add_archive_element (info, abfd, name)
   if (trace_files || trace_file_tries)
     info_msg ("%I\n", input);
 
   if (trace_files || trace_file_tries)
     info_msg ("%I\n", input);
 
-  return true;
+  return TRUE;
 }
 
 /* This is called when BFD has discovered a symbol which is defined
    multiple times.  */
 
 }
 
 /* This is called when BFD has discovered a symbol which is defined
    multiple times.  */
 
-static boolean
-multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *name;
-     bfd *obfd;
-     asection *osec;
-     bfd_vma oval;
-     bfd *nbfd;
-     asection *nsec;
-     bfd_vma nval;
+static bfd_boolean
+multiple_definition (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                    const char *name,
+                    bfd *obfd,
+                    asection *osec,
+                    bfd_vma oval,
+                    bfd *nbfd,
+                    asection *nsec,
+                    bfd_vma nval)
 {
   /* If either section has the output_section field set to
      bfd_abs_section_ptr, it means that the section is being
 {
   /* If either section has the output_section field set to
      bfd_abs_section_ptr, it means that the section is being
@@ -899,11 +1023,11 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
       || (nsec->output_section != NULL
          && ! bfd_is_abs_section (nsec)
          && bfd_is_abs_section (nsec->output_section)))
       || (nsec->output_section != NULL
          && ! bfd_is_abs_section (nsec)
          && bfd_is_abs_section (nsec->output_section)))
-    return true;
+    return TRUE;
 
   einfo (_("%X%C: multiple definition of `%T'\n"),
         nbfd, nsec, nval, name);
 
   einfo (_("%X%C: multiple definition of `%T'\n"),
         nbfd, nsec, nval, name);
-  if (obfd != (bfd *) NULL)
+  if (obfd != NULL)
     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 
   if (command_line.relax)
     einfo (_("%D: first defined here\n"), obfd, osec, oval);
 
   if (command_line.relax)
@@ -912,7 +1036,7 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
       command_line.relax = 0;
     }
 
       command_line.relax = 0;
     }
 
-  return true;
+  return TRUE;
 }
 
 /* This is called when there is a definition of a common symbol, or
 }
 
 /* This is called when there is a definition of a common symbol, or
@@ -920,19 +1044,18 @@ multiple_definition (info, name, obfd, osec, oval, nbfd, nsec, nval)
    or when two common symbols are found.  We only do something if
    -warn-common was used.  */
 
    or when two common symbols are found.  We only do something if
    -warn-common was used.  */
 
-static boolean
-multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     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;
+static bfd_boolean
+multiple_common (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                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)
 {
   if (! config.warn_common)
 {
   if (! config.warn_common)
-    return true;
+    return TRUE;
 
   if (ntype == bfd_link_hash_defined
       || ntype == bfd_link_hash_defweak
 
   if (ntype == bfd_link_hash_defined
       || ntype == bfd_link_hash_defweak
@@ -979,30 +1102,29 @@ multiple_common (info, name, obfd, otype, osize, nbfd, ntype, nsize)
        }
     }
 
        }
     }
 
-  return true;
+  return TRUE;
 }
 
 /* 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.  */
 
 }
 
 /* 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.  */
 
-static boolean
-add_to_set (info, h, reloc, abfd, section, value)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     struct bfd_link_hash_entry *h;
-     bfd_reloc_code_real_type reloc;
-     bfd *abfd;
-     asection *section;
-     bfd_vma value;
+static bfd_boolean
+add_to_set (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+           struct bfd_link_hash_entry *h,
+           bfd_reloc_code_real_type reloc,
+           bfd *abfd,
+           asection *section,
+           bfd_vma value)
 {
   if (config.warn_constructors)
     einfo (_("%P: warning: global constructor %s used\n"),
           h->root.string);
 
   if (! config.build_constructors)
 {
   if (config.warn_constructors)
     einfo (_("%P: warning: global constructor %s used\n"),
           h->root.string);
 
   if (! config.build_constructors)
-    return true;
+    return TRUE;
 
 
-  ldctor_add_set_entry (h, reloc, (const char *) NULL, section, value);
+  ldctor_add_set_entry (h, reloc, NULL, section, value);
 
   if (h->type == bfd_link_hash_new)
     {
 
   if (h->type == bfd_link_hash_new)
     {
@@ -1013,7 +1135,7 @@ add_to_set (info, h, reloc, abfd, section, value)
         ourselves.  */
     }
 
         ourselves.  */
     }
 
-  return true;
+  return TRUE;
 }
 
 /* This is called when BFD has discovered a constructor.  This is only
 }
 
 /* This is called when BFD has discovered a constructor.  This is only
@@ -1021,14 +1143,13 @@ add_to_set (info, h, reloc, abfd, section, value)
    constructors in some more clever fashion.  This is similar to
    adding an element to a set, but less general.  */
 
    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;
+static bfd_boolean
+constructor_callback (struct bfd_link_info *info,
+                     bfd_boolean constructor,
+                     const char *name,
+                     bfd *abfd,
+                     asection *section,
+                     bfd_vma value)
 {
   char *s;
   struct bfd_link_hash_entry *h;
 {
   char *s;
   struct bfd_link_hash_entry *h;
@@ -1038,12 +1159,12 @@ constructor_callback (info, constructor, name, abfd, section, value)
     einfo (_("%P: warning: global constructor %s used\n"), name);
 
   if (! config.build_constructors)
     einfo (_("%P: warning: global constructor %s used\n"), name);
 
   if (! config.build_constructors)
-    return true;
+    return TRUE;
 
   /* 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
 
   /* 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
-      && (link_info.relocateable
+      && (info->relocatable
          || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
 
          || bfd_reloc_type_lookup (abfd, BFD_RELOC_CTOR) == NULL))
     einfo (_("%P%F: BFD backend error: BFD_RELOC_CTOR unsupported\n"));
 
@@ -1055,7 +1176,7 @@ constructor_callback (info, constructor, name, abfd, section, value)
   else
     strcpy (s, "__DTOR_LIST__");
 
   else
     strcpy (s, "__DTOR_LIST__");
 
-  h = bfd_link_hash_lookup (info->hash, set_name, true, true, true);
+  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\n"));
   if (h->type == bfd_link_hash_new)
   if (h == (struct bfd_link_hash_entry *) NULL)
     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
   if (h->type == bfd_link_hash_new)
@@ -1068,14 +1189,15 @@ constructor_callback (info, constructor, name, abfd, section, value)
     }
 
   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
     }
 
   ldctor_add_set_entry (h, BFD_RELOC_CTOR, name, section, value);
-  return true;
+  return TRUE;
 }
 
 /* A structure used by warning_callback to pass information through
    bfd_map_over_sections.  */
 
 }
 
 /* A structure used by warning_callback to pass information through
    bfd_map_over_sections.  */
 
-struct warning_callback_info {
-  boolean found;
+struct warning_callback_info
+{
+  bfd_boolean found;
   const char *warning;
   const char *symbol;
   asymbol **asymbols;
   const char *warning;
   const char *symbol;
   asymbol **asymbols;
@@ -1083,27 +1205,26 @@ struct warning_callback_info {
 
 /* This is called when there is a reference to a warning symbol.  */
 
 
 /* This is called when there is a reference to a warning symbol.  */
 
-static boolean
-warning_callback (info, warning, symbol, abfd, section, address)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *warning;
-     const char *symbol;
-     bfd *abfd;
-     asection *section;
-     bfd_vma address;
+static bfd_boolean
+warning_callback (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                 const char *warning,
+                 const char *symbol,
+                 bfd *abfd,
+                 asection *section,
+                 bfd_vma address)
 {
   /* This is a hack to support warn_multiple_gp.  FIXME: This should
      have a cleaner interface, but what?  */
   if (! config.warn_multiple_gp
       && strcmp (warning, "using multiple gp values") == 0)
 {
   /* This is a hack to support warn_multiple_gp.  FIXME: This should
      have a cleaner interface, but what?  */
   if (! config.warn_multiple_gp
       && strcmp (warning, "using multiple gp values") == 0)
-    return true;
+    return TRUE;
 
   if (section != NULL)
 
   if (section != NULL)
-    einfo ("%C: %s\n", abfd, section, address, warning);
+    einfo ("%C: %s%s\n", abfd, section, address, _("warning: "), warning);
   else if (abfd == NULL)
   else if (abfd == NULL)
-    einfo ("%P: %s\n", warning);
+    einfo ("%P: %s%s\n", _("warning: "), warning);
   else if (symbol == NULL)
   else if (symbol == NULL)
-    einfo ("%B: %s\n", abfd, warning);
+    einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
   else
     {
       lang_input_statement_type *entry;
   else
     {
       lang_input_statement_type *entry;
@@ -1112,7 +1233,6 @@ warning_callback (info, warning, symbol, abfd, section, address)
 
       /* Look through the relocs to see if we can find a plausible
         address.  */
 
       /* Look through the relocs to see if we can find a plausible
         address.  */
-
       entry = (lang_input_statement_type *) abfd->usrdata;
       if (entry != NULL && entry->asymbols != NULL)
        asymbols = entry->asymbols;
       entry = (lang_input_statement_type *) abfd->usrdata;
       if (entry != NULL && entry->asymbols != NULL)
        asymbols = entry->asymbols;
@@ -1124,7 +1244,7 @@ warning_callback (info, warning, symbol, abfd, section, address)
          symsize = bfd_get_symtab_upper_bound (abfd);
          if (symsize < 0)
            einfo (_("%B%F: could not read symbols: %E\n"), abfd);
          symsize = bfd_get_symtab_upper_bound (abfd);
          if (symsize < 0)
            einfo (_("%B%F: could not read symbols: %E\n"), abfd);
-         asymbols = (asymbol **) xmalloc (symsize);
+         asymbols = xmalloc (symsize);
          symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
          if (symbol_count < 0)
            einfo (_("%B%F: could not read symbols: %E\n"), abfd);
          symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
          if (symbol_count < 0)
            einfo (_("%B%F: could not read symbols: %E\n"), abfd);
@@ -1135,20 +1255,20 @@ warning_callback (info, warning, symbol, abfd, section, address)
            }
        }
 
            }
        }
 
-      info.found = false;
+      info.found = FALSE;
       info.warning = warning;
       info.symbol = symbol;
       info.asymbols = asymbols;
       info.warning = warning;
       info.symbol = symbol;
       info.asymbols = asymbols;
-      bfd_map_over_sections (abfd, warning_find_reloc, (PTR) &info);
+      bfd_map_over_sections (abfd, warning_find_reloc, &info);
 
       if (! info.found)
 
       if (! info.found)
-       einfo ("%B: %s\n", abfd, warning);
+       einfo ("%B: %s%s\n", abfd, _("warning: "), warning);
 
       if (entry == NULL)
        free (asymbols);
     }
 
 
       if (entry == NULL)
        free (asymbols);
     }
 
-  return true;
+  return TRUE;
 }
 
 /* This is called by warning_callback for each section.  It checks the
 }
 
 /* This is called by warning_callback for each section.  It checks the
@@ -1157,12 +1277,9 @@ warning_callback (info, warning, symbol, abfd, section, address)
    to give an error message with a file and line number.  */
 
 static void
    to give an error message with a file and line number.  */
 
 static void
-warning_find_reloc (abfd, sec, iarg)
-     bfd *abfd;
-     asection *sec;
-     PTR iarg;
+warning_find_reloc (bfd *abfd, asection *sec, void *iarg)
 {
 {
-  struct warning_callback_info *info = (struct warning_callback_info *) iarg;
+  struct warning_callback_info *info = iarg;
   long relsize;
   arelent **relpp;
   long relcount;
   long relsize;
   arelent **relpp;
   long relcount;
@@ -1177,7 +1294,7 @@ warning_find_reloc (abfd, sec, iarg)
   if (relsize == 0)
     return;
 
   if (relsize == 0)
     return;
 
-  relpp = (arelent **) xmalloc (relsize);
+  relpp = xmalloc (relsize);
   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
   if (relcount < 0)
     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
   if (relcount < 0)
     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
@@ -1193,8 +1310,9 @@ warning_find_reloc (abfd, sec, iarg)
          && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
        {
          /* We found a reloc for the symbol we are looking for.  */
          && strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), info->symbol) == 0)
        {
          /* We found a reloc for the symbol we are looking for.  */
-         einfo ("%C: %s\n", abfd, sec, q->address, info->warning);
-         info->found = true;
+         einfo ("%C: %s%s\n", abfd, sec, q->address, _("warning: "),
+                info->warning);
+         info->found = TRUE;
          break;
        }
     }
          break;
        }
     }
@@ -1204,14 +1322,13 @@ warning_find_reloc (abfd, sec, iarg)
 
 /* This is called when an undefined symbol is found.  */
 
 
 /* This is called when an undefined symbol is found.  */
 
-static boolean
-undefined_symbol (info, name, abfd, section, address, fatal)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *name;
-     bfd *abfd;
-     asection *section;
-     bfd_vma address;
-     boolean fatal ATTRIBUTE_UNUSED;
+static bfd_boolean
+undefined_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                 const char *name,
+                 bfd *abfd,
+                 asection *section,
+                 bfd_vma address,
+                 bfd_boolean error)
 {
   static char *error_name;
   static unsigned int error_count;
 {
   static char *error_name;
   static unsigned int error_count;
@@ -1223,31 +1340,30 @@ undefined_symbol (info, name, abfd, section, address, fatal)
       static struct bfd_hash_table *hash;
 
       /* Only warn once about a particular undefined symbol.  */
       static struct bfd_hash_table *hash;
 
       /* Only warn once about a particular undefined symbol.  */
-
       if (hash == NULL)
        {
       if (hash == NULL)
        {
-         hash = ((struct bfd_hash_table *)
-                 xmalloc (sizeof (struct bfd_hash_table)));
-         if (! bfd_hash_table_init (hash, bfd_hash_newfunc))
+         hash = xmalloc (sizeof (struct bfd_hash_table));
+         if (!bfd_hash_table_init (hash, bfd_hash_newfunc,
+                                   sizeof (struct bfd_hash_entry)))
            einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
        }
 
            einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
        }
 
-      if (bfd_hash_lookup (hash, name, false, false) != NULL)
-       return true;
+      if (bfd_hash_lookup (hash, name, FALSE, FALSE) != NULL)
+       return TRUE;
 
 
-      if (bfd_hash_lookup (hash, name, true, true) == NULL)
+      if (bfd_hash_lookup (hash, name, TRUE, TRUE) == NULL)
        einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
     }
 
   /* We never print more than a reasonable number of errors in a row
      for a single symbol.  */
        einfo (_("%F%P: bfd_hash_lookup failed: %E\n"));
     }
 
   /* We never print more than a reasonable number of errors in a row
      for a single symbol.  */
-  if (error_name != (char *) NULL
+  if (error_name != NULL
       && strcmp (name, error_name) == 0)
     ++error_count;
   else
     {
       error_count = 0;
       && strcmp (name, error_name) == 0)
     ++error_count;
   else
     {
       error_count = 0;
-      if (error_name != (char *) NULL)
+      if (error_name != NULL)
        free (error_name);
       error_name = xstrdup (name);
     }
        free (error_name);
       error_name = xstrdup (name);
     }
@@ -1256,107 +1372,169 @@ undefined_symbol (info, name, abfd, section, address, fatal)
     {
       if (error_count < MAX_ERRORS_IN_A_ROW)
        {
     {
       if (error_count < MAX_ERRORS_IN_A_ROW)
        {
-         einfo (_("%C: undefined reference to `%T'\n"),
-                abfd, section, address, name);
-         if (fatal)
-           einfo ("%X");
+         if (error)
+           einfo (_("%X%C: undefined reference to `%T'\n"),
+                  abfd, section, address, name);
+         else
+           einfo (_("%C: warning: undefined reference to `%T'\n"),
+                  abfd, section, address, name);
        }
       else if (error_count == MAX_ERRORS_IN_A_ROW)
        }
       else if (error_count == MAX_ERRORS_IN_A_ROW)
-       einfo (_("%D: more undefined references to `%T' follow\n"),
-              abfd, section, address, name);
+       {
+         if (error)
+           einfo (_("%X%D: more undefined references to `%T' follow\n"),
+                  abfd, section, address, name);
+         else
+           einfo (_("%D: warning: more undefined references to `%T' follow\n"),
+                  abfd, section, address, name);
+       }
+      else if (error)
+       einfo ("%X");
     }
   else
     {
       if (error_count < MAX_ERRORS_IN_A_ROW)
        {
     }
   else
     {
       if (error_count < MAX_ERRORS_IN_A_ROW)
        {
-         einfo (_("%B: undefined reference to `%T'\n"),
-                abfd, name);
-         if (fatal)
-           einfo ("%X");
+         if (error)
+           einfo (_("%X%B: undefined reference to `%T'\n"),
+                  abfd, name);
+         else
+           einfo (_("%B: warning: undefined reference to `%T'\n"),
+                  abfd, name);
        }
       else if (error_count == MAX_ERRORS_IN_A_ROW)
        }
       else if (error_count == MAX_ERRORS_IN_A_ROW)
-       einfo (_("%B: more undefined references to `%T' follow\n"),
-              abfd, name);
+       {
+         if (error)
+           einfo (_("%X%B: more undefined references to `%T' follow\n"),
+                  abfd, name);
+         else
+           einfo (_("%B: warning: more undefined references to `%T' follow\n"),
+                  abfd, name);
+       }
+      else if (error)
+       einfo ("%X");
     }
 
     }
 
-  return true;
+  return TRUE;
 }
 
 }
 
+/* Counter to limit the number of relocation overflow error messages
+   to print.  Errors are printed as it is decremented.  When it's
+   called and the counter is zero, a final message is printed
+   indicating more relocations were omitted.  When it gets to -1, no
+   such errors are printed.  If it's initially set to a value less
+   than -1, all such errors will be printed (--verbose does this).  */
+
+int overflow_cutoff_limit = 10;
+
 /* This is called when a reloc overflows.  */
 
 /* This is called when a reloc overflows.  */
 
-static boolean
-reloc_overflow (info, name, reloc_name, addend, abfd, section, address)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *name;
-     const char *reloc_name;
-     bfd_vma addend;
-     bfd *abfd;
-     asection *section;
-     bfd_vma address;
+static bfd_boolean
+reloc_overflow (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+               struct bfd_link_hash_entry *entry,
+               const char *name,
+               const char *reloc_name,
+               bfd_vma addend,
+               bfd *abfd,
+               asection *section,
+               bfd_vma address)
 {
 {
-  if (abfd == (bfd *) NULL)
-    einfo (_("%P%X: generated"));
+  if (overflow_cutoff_limit == -1)
+    return TRUE;
+
+  einfo ("%X%C:", abfd, section, address);
+
+  if (overflow_cutoff_limit >= 0
+      && overflow_cutoff_limit-- == 0)
+    {
+      einfo (_(" additional relocation overflows omitted from the output\n"));
+      return TRUE;
+    }
+
+  if (entry)
+    {
+      while (entry->type == bfd_link_hash_indirect
+            || entry->type == bfd_link_hash_warning)
+       entry = entry->u.i.link;
+      switch (entry->type)
+       {
+       case bfd_link_hash_undefined:
+       case bfd_link_hash_undefweak:
+         einfo (_(" relocation truncated to fit: %s against undefined symbol `%T'"),
+                reloc_name, entry->root.string);
+         break;
+       case bfd_link_hash_defined:
+       case bfd_link_hash_defweak:
+         einfo (_(" relocation truncated to fit: %s against symbol `%T' defined in %A section in %B"),
+                reloc_name, entry->root.string,
+                entry->u.def.section,
+                entry->u.def.section == bfd_abs_section_ptr
+                ? output_bfd : entry->u.def.section->owner);
+         break;
+       default:
+         abort ();
+         break;
+       }
+    }
   else
   else
-    einfo ("%X%C:", abfd, section, address);
-  einfo (_(" relocation truncated to fit: %s %T"), reloc_name, name);
+    einfo (_(" relocation truncated to fit: %s against `%T'"),
+          reloc_name, name);
   if (addend != 0)
     einfo ("+%v", addend);
   einfo ("\n");
   if (addend != 0)
     einfo ("+%v", addend);
   einfo ("\n");
-  return true;
+  return TRUE;
 }
 
 /* This is called when a dangerous relocation is made.  */
 
 }
 
 /* This is called when a dangerous relocation is made.  */
 
-static boolean
-reloc_dangerous (info, message, abfd, section, address)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *message;
-     bfd *abfd;
-     asection *section;
-     bfd_vma address;
+static bfd_boolean
+reloc_dangerous (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                const char *message,
+                bfd *abfd,
+                asection *section,
+                bfd_vma address)
 {
 {
-  if (abfd == (bfd *) NULL)
-    einfo (_("%P%X: generated"));
-  else
-    einfo ("%X%C:", abfd, section, address);
-  einfo (_("dangerous relocation: %s\n"), message);
-  return true;
+  einfo (_("%X%C: dangerous relocation: %s\n"),
+        abfd, section, address, message);
+  return TRUE;
 }
 
 /* This is called when a reloc is being generated attached to a symbol
    that is not being output.  */
 
 }
 
 /* This is called when a reloc is being generated attached to a symbol
    that is not being output.  */
 
-static boolean
-unattached_reloc (info, name, abfd, section, address)
-     struct bfd_link_info *info ATTRIBUTE_UNUSED;
-     const char *name;
-     bfd *abfd;
-     asection *section;
-     bfd_vma address;
+static bfd_boolean
+unattached_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+                 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;
+  einfo (_("%X%C: reloc refers to symbol `%T' which is not being output\n"),
+        abfd, section, address, name);
+  return TRUE;
 }
 
 /* This is called if link_info.notice_all is set, or when a symbol in
    link_info.notice_hash is found.  Symbols are put in notice_hash
    using the -y option.  */
 
 }
 
 /* This is called if link_info.notice_all is set, or when a symbol in
    link_info.notice_hash is found.  Symbols are put in notice_hash
    using the -y option.  */
 
-static boolean
-notice (info, name, abfd, section, value)
-     struct bfd_link_info *info;
-     const char *name;
-     bfd *abfd;
-     asection *section;
-     bfd_vma value;
+static bfd_boolean
+notice (struct bfd_link_info *info,
+       const char *name,
+       bfd *abfd,
+       asection *section,
+       bfd_vma value)
 {
 {
+  if (name == NULL)
+    {
+      if (command_line.cref || nocrossref_list != NULL)
+       return handle_asneeded_cref (abfd, value);
+      return TRUE;
+    }
+
   if (! info->notice_all
       || (info->notice_hash != NULL
   if (! info->notice_all
       || (info->notice_hash != NULL
-         && bfd_hash_lookup (info->notice_hash, name, false, false) != NULL))
+         && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL))
     {
       if (bfd_is_und_section (section))
        einfo ("%B: reference to %s\n", abfd, name);
     {
       if (bfd_is_und_section (section))
        einfo ("%B: reference to %s\n", abfd, name);
@@ -1367,5 +1545,5 @@ notice (info, name, abfd, section, value)
   if (command_line.cref || nocrossref_list != NULL)
     add_cref (name, abfd, section, value);
 
   if (command_line.cref || nocrossref_list != NULL)
     add_cref (name, abfd, section, value);
 
-  return true;
+  return TRUE;
 }
 }
GDB Binutils - Deliverables
This page took 0.044355 seconds and 4 git commands to generate.