[GDBserver] Replace "reinsert_breakpoint" with "single_step_breakpoint"

[deliverable/binutils-gdb.git] / binutils / nlmconv.c

diff --git a/binutils/nlmconv.c b/binutils/nlmconv.c
index 6b2812408df794cb8c124277e5ba5007e62038a4..eff15c5e2a8355b63f4787ff4585a9e0c98f0885 100644 (file)
--- a/binutils/nlmconv.c
+++ b/binutils/nlmconv.c
@@ -1,12 +1,11 @@
 /* nlmconv.c -- NLM conversion program
 /* nlmconv.c -- NLM conversion program

-   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
-   Free Software Foundation, Inc.
+   Copyright (C) 1993-2016 Free Software Foundation, Inc.

 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GNU Binutils.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

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

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,7 +15,9 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software

-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+   MA 02110-1301, USA.  */
+

 
 /* Written by Ian Lance Taylor <ian@cygnus.com>.
 
 
 /* Written by Ian Lance Taylor <ian@cygnus.com>.
 


@@ -32,15 +33,14 @@
 #endif
 #endif
 
 #endif
 #endif
 

+#include "sysdep.h"

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

-#include "bucomm.h"
+#include "filenames.h"

 #include "safe-ctype.h"
 
 #include "ansidecl.h"
 #include <time.h>
 #include "safe-ctype.h"
 
 #include "ansidecl.h"
 #include <time.h>

-#include <sys/stat.h>
-#include <sys/file.h>

 #include <assert.h>
 #include "getopt.h"
 
 #include <assert.h>
 #include "getopt.h"
 


@@ -53,14 +53,12 @@
 #include "coff/ecoff.h"
 #endif
 
 #include "coff/ecoff.h"
 #endif
 

+#include "bucomm.h"
+

 /* If strerror is just a macro, we want to use the one from libiberty
    since it will handle undefined values.  */
 #undef strerror
 /* If strerror is just a macro, we want to use the one from libiberty
    since it will handle undefined values.  */
 #undef strerror

-extern char *strerror PARAMS ((int));
-
-#ifndef localtime
-extern struct tm *localtime ();
-#endif
+extern char *strerror (int);

 
 #ifndef SEEK_SET
 #define SEEK_SET 0
 
 #ifndef SEEK_SET
 #define SEEK_SET 0


@@ -122,47 +120,37 @@ static struct option long_options[] =
 
 /* Local routines.  */
 
 
 /* Local routines.  */
 

-int main PARAMS ((int, char **));
-
-static void show_usage PARAMS ((FILE *, int));
-static const char *select_output_format PARAMS ((enum bfd_architecture,
-                                                unsigned long, boolean));
-static void setup_sections PARAMS ((bfd *, asection *, PTR));
-static void copy_sections PARAMS ((bfd *, asection *, PTR));
-static void mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
-                                  long *, char *,
-                                  bfd_size_type));
-static void default_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
-                                          long *, char *,
-                                          bfd_size_type));
-static char *link_inputs PARAMS ((struct string_list *, char *));
+int main (int, char **);
+
+static void show_usage (FILE *, int);
+static const char *select_output_format
+  (enum bfd_architecture, unsigned long, bfd_boolean);
+static void setup_sections (bfd *, asection *, void *);
+static void copy_sections (bfd *, asection *, void *);
+static void mangle_relocs
+  (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
+static void default_mangle_relocs
+  (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);
+static char *link_inputs (struct string_list *, char *, char *);

 
 #ifdef NLMCONV_I386
 
 #ifdef NLMCONV_I386

-static void i386_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
-                                       long *, char *,
-                                       bfd_size_type));
+static void i386_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

 #endif
 
 #ifdef NLMCONV_ALPHA
 #endif
 
 #ifdef NLMCONV_ALPHA

-static void alpha_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
-                                        long *, char *,
-                                        bfd_size_type));
+static void alpha_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

 #endif
 
 #ifdef NLMCONV_POWERPC
 #endif
 
 #ifdef NLMCONV_POWERPC

-static void powerpc_build_stubs PARAMS ((bfd *, bfd *, asymbol ***, long *));
-static void powerpc_resolve_stubs PARAMS ((bfd *, bfd *));
-static void powerpc_mangle_relocs PARAMS ((bfd *, asection *, arelent ***,
-                                          long *, char *,
-                                          bfd_size_type));
+static void powerpc_build_stubs (bfd *, bfd *, asymbol ***, long *);
+static void powerpc_resolve_stubs (bfd *, bfd *);
+static void powerpc_mangle_relocs (bfd *, asection *, arelent ***, long *, char *, bfd_size_type);

 #endif
 \f
 /* The main routine.  */
 
 int
 #endif
 \f
 /* The main routine.  */
 
 int

-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)

 {
   int opt;
   char *input_file = NULL;
 {
   int opt;
   char *input_file = NULL;


@@ -186,7 +174,7 @@ main (argc, argv)
   asymbol *endsym;
   long i;
   char inlead, outlead;
   asymbol *endsym;
   long i;
   char inlead, outlead;

-  boolean gotstart, gotexit, gotcheck;
+  bfd_boolean gotstart, gotexit, gotcheck;

   struct stat st;
   FILE *custom_data = NULL;
   FILE *help_data = NULL;
   struct stat st;
   FILE *custom_data = NULL;
   FILE *help_data = NULL;


@@ -207,7 +195,7 @@ main (argc, argv)
   bfd *sharedbfd;
   size_t shared_offset = 0;
   size_t shared_size = 0;
   bfd *sharedbfd;
   size_t shared_offset = 0;
   size_t shared_size = 0;

-  Nlm_Internal_Fixed_Header sharedhdr;
+  static Nlm_Internal_Fixed_Header sharedhdr;

   int len;
   char *modname;
   char **matching;
   int len;
   char *modname;
   char **matching;


@@ -223,6 +211,9 @@ main (argc, argv)
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
 
   program_name = argv[0];
   xmalloc_set_program_name (program_name);

+  bfd_set_error_program_name (program_name);
+
+  expandargv (&argc, &argv);

 
   bfd_init ();
   set_default_bfd_target ();
 
   bfd_init ();
   set_default_bfd_target ();


@@ -276,7 +267,7 @@ main (argc, argv)
          ++optind;
          if (optind < argc)
            show_usage (stderr, 1);
          ++optind;
          if (optind < argc)
            show_usage (stderr, 1);

-         if (strcmp (input_file, output_file) == 0)
+         if (filename_cmp (input_file, output_file) == 0)

            {
              fatal (_("input and output files must be different"));
            }
            {
              fatal (_("input and output files must be different"));
            }


@@ -285,29 +276,29 @@ main (argc, argv)
 
   /* Initialize the header information to default values.  */
   fixed_hdr = &fixed_hdr_struct;
 
   /* Initialize the header information to default values.  */
   fixed_hdr = &fixed_hdr_struct;

-  memset ((PTR) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);
+  memset ((void *) &fixed_hdr_struct, 0, sizeof fixed_hdr_struct);

   var_hdr = &var_hdr_struct;
   var_hdr = &var_hdr_struct;

-  memset ((PTR) &var_hdr_struct, 0, sizeof var_hdr_struct);
+  memset ((void *) &var_hdr_struct, 0, sizeof var_hdr_struct);

   version_hdr = &version_hdr_struct;
   version_hdr = &version_hdr_struct;

-  memset ((PTR) &version_hdr_struct, 0, sizeof version_hdr_struct);
+  memset ((void *) &version_hdr_struct, 0, sizeof version_hdr_struct);

   copyright_hdr = &copyright_hdr_struct;
   copyright_hdr = &copyright_hdr_struct;

-  memset ((PTR) &copyright_hdr_struct, 0, sizeof copyright_hdr_struct);
+  memset ((void *) &copyright_hdr_struct, 0, sizeof copyright_hdr_struct);

   extended_hdr = &extended_hdr_struct;
   extended_hdr = &extended_hdr_struct;

-  memset ((PTR) &extended_hdr_struct, 0, sizeof extended_hdr_struct);
+  memset ((void *) &extended_hdr_struct, 0, sizeof extended_hdr_struct);

   check_procedure = NULL;
   custom_file = NULL;
   check_procedure = NULL;
   custom_file = NULL;

-  debug_info = false;
+  debug_info = FALSE;

   exit_procedure = "_Stop";
   export_symbols = NULL;
   map_file = NULL;
   exit_procedure = "_Stop";
   export_symbols = NULL;
   map_file = NULL;

-  full_map = false;
+  full_map = FALSE;

   help_file = NULL;
   import_symbols = NULL;
   message_file = NULL;
   modules = NULL;
   sharelib_file = NULL;
   start_procedure = "_Prelude";
   help_file = NULL;
   import_symbols = NULL;
   message_file = NULL;
   modules = NULL;
   sharelib_file = NULL;
   start_procedure = "_Prelude";

-  verbose = false;
+  verbose = FALSE;

   rpc_file = NULL;
 
   parse_errors = 0;
   rpc_file = NULL;
 
   parse_errors = 0;


@@ -330,7 +321,7 @@ main (argc, argv)
       if (input_files->next == NULL)
        input_file = input_files->string;
       else
       if (input_files->next == NULL)
        input_file = input_files->string;
       else

-       input_file = link_inputs (input_files, ld_arg);
+       input_file = link_inputs (input_files, ld_arg, map_file);

     }
   else if (input_file == NULL)
     {
     }
   else if (input_file == NULL)
     {


@@ -376,7 +367,8 @@ main (argc, argv)
 
   assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);
 
 
   assert (bfd_get_flavour (outbfd) == bfd_target_nlm_flavour);
 

-  if (bfd_arch_get_compatible (inbfd, outbfd) == NULL)
+  /* XXX: Should we accept the unknown bfd format here ?  */
+  if (bfd_arch_get_compatible (inbfd, outbfd, TRUE) == NULL)

     non_fatal (_("warning: input and output formats are not compatible"));
 
   /* Move the values read from the command file into outbfd.  */
     non_fatal (_("warning: input and output formats are not compatible"));
 
   /* Move the values read from the command file into outbfd.  */


@@ -402,9 +394,10 @@ main (argc, argv)
   bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);
   if (bss_sec == NULL)
     {
   bss_sec = bfd_get_section_by_name (outbfd, NLM_UNINITIALIZED_DATA_NAME);
   if (bss_sec == NULL)
     {

-      bss_sec = bfd_make_section (outbfd, NLM_UNINITIALIZED_DATA_NAME);
+      bss_sec = bfd_make_section_with_flags (outbfd,
+                                            NLM_UNINITIALIZED_DATA_NAME,
+                                            SEC_ALLOC);

       if (bss_sec == NULL
       if (bss_sec == NULL

-         || ! bfd_set_section_flags (outbfd, bss_sec, SEC_ALLOC)

          || ! bfd_set_section_alignment (outbfd, bss_sec, 1))
        bfd_fatal (_("make .bss section"));
     }
          || ! bfd_set_section_alignment (outbfd, bss_sec, 1))
        bfd_fatal (_("make .bss section"));
     }


@@ -413,11 +406,10 @@ main (argc, argv)
      so that programs which understand it can resurrect the original
      sections from the NLM.  We will put a pointer to .nlmsections in
      the NLM header area.  */
      so that programs which understand it can resurrect the original
      sections from the NLM.  We will put a pointer to .nlmsections in
      the NLM header area.  */

-  secsec = bfd_make_section (outbfd, ".nlmsections");
+  secsec = bfd_make_section_with_flags (outbfd, ".nlmsections",
+                                       SEC_HAS_CONTENTS);

   if (secsec == NULL)
     bfd_fatal (_("make .nlmsections section"));
   if (secsec == NULL)
     bfd_fatal (_("make .nlmsections section"));

-  if (! bfd_set_section_flags (outbfd, secsec, SEC_HAS_CONTENTS))
-    bfd_fatal (_("set .nlmsections flags"));

 
 #ifdef NLMCONV_POWERPC
   /* For PowerPC NetWare we need to build stubs for calls to undefined
 
 #ifdef NLMCONV_POWERPC
   /* For PowerPC NetWare we need to build stubs for calls to undefined


@@ -430,7 +422,7 @@ main (argc, argv)
 #endif
 
   /* Set up the sections.  */
 #endif
 
   /* Set up the sections.  */

-  bfd_map_over_sections (inbfd, setup_sections, (PTR) outbfd);
+  bfd_map_over_sections (inbfd, setup_sections, (void *) outbfd);

 
   text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);
 
 
   text_sec = bfd_get_section_by_name (outbfd, NLM_CODE_NAME);
 


@@ -440,7 +432,7 @@ main (argc, argv)
     {
       bfd_size_type add;
 
     {
       bfd_size_type add;
 

-      vma = bfd_get_section_size_before_reloc (data_sec);
+      vma = bfd_get_section_size (data_sec);

       align = 1 << bss_sec->alignment_power;
       add = ((vma + align - 1) &~ (align - 1)) - vma;
       vma += add;
       align = 1 << bss_sec->alignment_power;
       add = ((vma + align - 1) &~ (align - 1)) - vma;
       vma += add;


@@ -450,7 +442,7 @@ main (argc, argv)
        {
          bfd_size_type data_size;
 
        {
          bfd_size_type data_size;
 

-         data_size = bfd_get_section_size_before_reloc (data_sec);
+         data_size = bfd_get_section_size (data_sec);

          if (! bfd_set_section_size (outbfd, data_sec, data_size + add))
            bfd_fatal (_("set .data size"));
        }
          if (! bfd_set_section_size (outbfd, data_sec, data_size + add))
            bfd_fatal (_("set .data size"));
        }


@@ -459,16 +451,16 @@ main (argc, argv)
   /* Adjust symbol information.  */
   inlead = bfd_get_symbol_leading_char (inbfd);
   outlead = bfd_get_symbol_leading_char (outbfd);
   /* Adjust symbol information.  */
   inlead = bfd_get_symbol_leading_char (inbfd);
   outlead = bfd_get_symbol_leading_char (outbfd);

-  gotstart = false;
-  gotexit = false;
-  gotcheck = false;
+  gotstart = FALSE;
+  gotexit = FALSE;
+  gotcheck = FALSE;

   newsymalloc = 10;
   newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *));
   newsymcount = 0;
   endsym = NULL;
   for (i = 0; i < symcount; i++)
     {
   newsymalloc = 10;
   newsyms = (asymbol **) xmalloc (newsymalloc * sizeof (asymbol *));
   newsymcount = 0;
   endsym = NULL;
   for (i = 0; i < symcount; i++)
     {

-      register asymbol *sym;
+      asymbol *sym;

 
       sym = symbols[i];
 
 
       sym = symbols[i];
 


@@ -483,23 +475,23 @@ main (argc, argv)
                    ++sym->name;
                  else
                    {
                    ++sym->name;
                  else
                    {

-                     char *new;
+                     char *new_name;

 
 

-                     new = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);
-                     new[0] = outlead;
-                     strcpy (new + 1, bfd_asymbol_name (sym) + 1);
-                     sym->name = new;
+                     new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 1);
+                     new_name[0] = outlead;
+                     strcpy (new_name + 1, bfd_asymbol_name (sym) + 1);
+                     sym->name = new_name;

                    }
                }
            }
          else
            {
                    }
                }
            }
          else
            {

-             char *new;
+             char *new_name;

 
 

-             new = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);
-             new[0] = outlead;
-             strcpy (new + 1, bfd_asymbol_name (sym));
-             sym->name = new;
+             new_name = xmalloc (strlen (bfd_asymbol_name (sym)) + 2);
+             new_name[0] = outlead;
+             strcpy (new_name + 1, bfd_asymbol_name (sym));
+             sym->name = new_name;

            }
        }
 
            }
        }
 


@@ -508,14 +500,14 @@ main (argc, argv)
         symbols into the .bss section, and mark them as exported.  */
       if (bfd_is_com_section (bfd_get_section (sym)))
        {
         symbols into the .bss section, and mark them as exported.  */
       if (bfd_is_com_section (bfd_get_section (sym)))
        {

-         bfd_vma size;
+         bfd_vma size = sym->value;

 
          sym->section = bss_sec;
 
          sym->section = bss_sec;

-         size = sym->value;
-         sym->value = bss_sec->_raw_size;
-         bss_sec->_raw_size += size;
+         sym->value = bfd_get_section_size (bss_sec);
+         size += sym->value;

          align = 1 << bss_sec->alignment_power;
          align = 1 << bss_sec->alignment_power;

-         bss_sec->_raw_size = (bss_sec->_raw_size + align - 1) &~ (align - 1);
+         size = (size + align - 1) & ~(align - 1);
+         bfd_set_section_size (outbfd, bss_sec, size);

          sym->flags |= BSF_EXPORT | BSF_GLOBAL;
        }
       else if (bfd_get_section (sym)->output_section != NULL)
          sym->flags |= BSF_EXPORT | BSF_GLOBAL;
        }
       else if (bfd_get_section (sym)->output_section != NULL)


@@ -564,7 +556,7 @@ main (argc, argv)
       /* If this is a global symbol, check the export list.  */
       if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)
        {
       /* If this is a global symbol, check the export list.  */
       if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) != 0)
        {

-         register struct string_list *l;
+         struct string_list *l;

          int found_simple;
 
          /* Unfortunately, a symbol can appear multiple times on the
          int found_simple;
 
          /* Unfortunately, a symbol can appear multiple times on the


@@ -587,7 +579,7 @@ main (argc, argv)
                        {
                          newsymalloc += 10;
                          newsyms = ((asymbol **)
                        {
                          newsymalloc += 10;
                          newsyms = ((asymbol **)

-                                    xrealloc ((PTR) newsyms,
+                                    xrealloc ((void *) newsyms,

                                               (newsymalloc
                                                * sizeof (asymbol *))));
                        }
                                               (newsymalloc
                                                * sizeof (asymbol *))));
                        }


@@ -612,7 +604,7 @@ main (argc, argv)
         Change the prefix if necessary.  */
       if (bfd_is_und_section (bfd_get_section (sym)))
        {
         Change the prefix if necessary.  */
       if (bfd_is_und_section (bfd_get_section (sym)))
        {

-         register struct string_list *l;
+         struct string_list *l;

 
          for (l = import_symbols; l != NULL; l = l->next)
            {
 
          for (l = import_symbols; l != NULL; l = l->next)
            {


@@ -653,7 +645,7 @@ main (argc, argv)
                val += bfd_section_size (outbfd, text_sec);
              if (! bfd_set_start_address (outbfd, val))
                bfd_fatal (_("set start address"));
                val += bfd_section_size (outbfd, text_sec);
              if (! bfd_set_start_address (outbfd, val))
                bfd_fatal (_("set start address"));

-             gotstart = true;
+             gotstart = TRUE;

            }
          if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0)
            {
            }
          if (strcmp (bfd_asymbol_name (sym), exit_procedure) == 0)
            {


@@ -662,7 +654,7 @@ main (argc, argv)
                  && text_sec != (asection *) NULL)
                val += bfd_section_size (outbfd, text_sec);
              nlm_fixed_header (outbfd)->exitProcedureOffset = val;
                  && text_sec != (asection *) NULL)
                val += bfd_section_size (outbfd, text_sec);
              nlm_fixed_header (outbfd)->exitProcedureOffset = val;

-             gotexit = true;
+             gotexit = TRUE;

            }
          if (check_procedure != NULL
              && strcmp (bfd_asymbol_name (sym), check_procedure) == 0)
            }
          if (check_procedure != NULL
              && strcmp (bfd_asymbol_name (sym), check_procedure) == 0)


@@ -672,14 +664,14 @@ main (argc, argv)
                  && text_sec != (asection *) NULL)
                val += bfd_section_size (outbfd, text_sec);
              nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val;
                  && text_sec != (asection *) NULL)
                val += bfd_section_size (outbfd, text_sec);
              nlm_fixed_header (outbfd)->checkUnloadProcedureOffset = val;

-             gotcheck = true;
+             gotcheck = TRUE;

            }
        }
     }
 
   if (endsym != NULL)
     {
            }
        }
     }
 
   if (endsym != NULL)
     {

-      endsym->value = bfd_get_section_size_before_reloc (bss_sec);
+      endsym->value = bfd_get_section_size (bss_sec);

 
       /* FIXME: If any relocs referring to _end use inplace addends,
         then I think they need to be updated.  This is handled by
 
       /* FIXME: If any relocs referring to _end use inplace addends,
         then I think they need to be updated.  This is handled by


@@ -721,11 +713,10 @@ main (argc, argv)
       else
        {
          custom_size = st.st_size;
       else
        {
          custom_size = st.st_size;

-         custom_section = bfd_make_section (outbfd, ".nlmcustom");
+         custom_section = bfd_make_section_with_flags (outbfd, ".nlmcustom",
+                                                       SEC_HAS_CONTENTS);

          if (custom_section == NULL
          if (custom_section == NULL

-             || ! bfd_set_section_size (outbfd, custom_section, custom_size)
-             || ! bfd_set_section_flags (outbfd, custom_section,
-                                         SEC_HAS_CONTENTS))
+             || ! bfd_set_section_size (outbfd, custom_section, custom_size))

            bfd_fatal (_("custom section"));
        }
     }
            bfd_fatal (_("custom section"));
        }
     }


@@ -742,13 +733,12 @@ main (argc, argv)
       else
        {
          help_size = st.st_size;
       else
        {
          help_size = st.st_size;

-         help_section = bfd_make_section (outbfd, ".nlmhelp");
+         help_section = bfd_make_section_with_flags (outbfd, ".nlmhelp",
+                                                     SEC_HAS_CONTENTS);

          if (help_section == NULL
          if (help_section == NULL

-             || ! bfd_set_section_size (outbfd, help_section, help_size)
-             || ! bfd_set_section_flags (outbfd, help_section,
-                                         SEC_HAS_CONTENTS))
+             || ! bfd_set_section_size (outbfd, help_section, help_size))

            bfd_fatal (_("help section"));
            bfd_fatal (_("help section"));

-         strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+         LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

        }
     }
   if (message_file != NULL)
        }
     }
   if (message_file != NULL)


@@ -764,13 +754,13 @@ main (argc, argv)
       else
        {
          message_size = st.st_size;
       else
        {
          message_size = st.st_size;

-         message_section = bfd_make_section (outbfd, ".nlmmessages");
+         message_section = bfd_make_section_with_flags (outbfd,
+                                                        ".nlmmessages",
+                                                        SEC_HAS_CONTENTS);

          if (message_section == NULL
          if (message_section == NULL

-             || ! bfd_set_section_size (outbfd, message_section, message_size)
-             || ! bfd_set_section_flags (outbfd, message_section,
-                                         SEC_HAS_CONTENTS))
+             || ! bfd_set_section_size (outbfd, message_section, message_size))

            bfd_fatal (_("message section"));
            bfd_fatal (_("message section"));

-         strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+         LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

        }
     }
   if (modules != NULL)
        }
     }
   if (modules != NULL)


@@ -780,11 +770,10 @@ main (argc, argv)
       module_size = 0;
       for (l = modules; l != NULL; l = l->next)
        module_size += strlen (l->string) + 1;
       module_size = 0;
       for (l = modules; l != NULL; l = l->next)
        module_size += strlen (l->string) + 1;

-      module_section = bfd_make_section (outbfd, ".nlmmodules");
+      module_section = bfd_make_section_with_flags (outbfd, ".nlmmodules",
+                                                   SEC_HAS_CONTENTS);

       if (module_section == NULL
       if (module_section == NULL

-         || ! bfd_set_section_size (outbfd, module_section, module_size)
-         || ! bfd_set_section_flags (outbfd, module_section,
-                                     SEC_HAS_CONTENTS))
+         || ! bfd_set_section_size (outbfd, module_section, module_size))

        bfd_fatal (_("module section"));
     }
   if (rpc_file != NULL)
        bfd_fatal (_("module section"));
     }
   if (rpc_file != NULL)


@@ -800,13 +789,12 @@ main (argc, argv)
       else
        {
          rpc_size = st.st_size;
       else
        {
          rpc_size = st.st_size;

-         rpc_section = bfd_make_section (outbfd, ".nlmrpc");
+         rpc_section = bfd_make_section_with_flags (outbfd, ".nlmrpc",
+                                                    SEC_HAS_CONTENTS);

          if (rpc_section == NULL
          if (rpc_section == NULL

-             || ! bfd_set_section_size (outbfd, rpc_section, rpc_size)
-             || ! bfd_set_section_flags (outbfd, rpc_section,
-                                         SEC_HAS_CONTENTS))
+             || ! bfd_set_section_size (outbfd, rpc_section, rpc_size))

            bfd_fatal (_("rpc section"));
            bfd_fatal (_("rpc section"));

-         strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+         LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

        }
     }
   if (sharelib_file != NULL)
        }
     }
   if (sharelib_file != NULL)


@@ -856,27 +844,27 @@ main (argc, argv)
              if (shared_offset > (size_t) sharedhdr.publicsOffset)
                shared_offset = sharedhdr.publicsOffset;
              shared_size = st.st_size - shared_offset;
              if (shared_offset > (size_t) sharedhdr.publicsOffset)
                shared_offset = sharedhdr.publicsOffset;
              shared_size = st.st_size - shared_offset;

-             shared_section = bfd_make_section (outbfd, ".nlmshared");
+             shared_section = bfd_make_section_with_flags (outbfd,
+                                                           ".nlmshared",
+                                                           SEC_HAS_CONTENTS);

              if (shared_section == NULL
                  || ! bfd_set_section_size (outbfd, shared_section,
              if (shared_section == NULL
                  || ! bfd_set_section_size (outbfd, shared_section,

-                                            shared_size)
-                 || ! bfd_set_section_flags (outbfd, shared_section,
-                                             SEC_HAS_CONTENTS))
+                                            shared_size))

                bfd_fatal (_("shared section"));
                bfd_fatal (_("shared section"));

-             strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+             LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

            }
        }
     }
 
   /* Check whether a version was given.  */
            }
        }
     }
 
   /* Check whether a version was given.  */

-  if (strncmp (version_hdr->stamp, "VeRsIoN#", 8) != 0)
+  if (!CONST_STRNEQ (version_hdr->stamp, "VeRsIoN#"))

     non_fatal (_("warning: No version number given"));
 
   /* At least for now, always create an extended header, because that
      is what NLMLINK does.  */
     non_fatal (_("warning: No version number given"));
 
   /* At least for now, always create an extended header, because that
      is what NLMLINK does.  */

-  strncpy (nlm_extended_header (outbfd)->stamp, "MeSsAgEs", 8);
+  LITMEMCPY (nlm_extended_header (outbfd)->stamp, "MeSsAgEs");

 
 

-  strncpy (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx", 8);
+  LITMEMCPY (nlm_cygnus_ext_header (outbfd)->stamp, "CyGnUsEx");

 
   /* If the date was not given, force it in.  */
   if (nlm_version_header (outbfd)->month == 0
 
   /* If the date was not given, force it in.  */
   if (nlm_version_header (outbfd)->month == 0


@@ -891,7 +879,7 @@ main (argc, argv)
       nlm_version_header (outbfd)->month = ptm->tm_mon + 1;
       nlm_version_header (outbfd)->day = ptm->tm_mday;
       nlm_version_header (outbfd)->year = ptm->tm_year + 1900;
       nlm_version_header (outbfd)->month = ptm->tm_mon + 1;
       nlm_version_header (outbfd)->day = ptm->tm_mday;
       nlm_version_header (outbfd)->year = ptm->tm_year + 1900;

-      strncpy (version_hdr->stamp, "VeRsIoN#", 8);
+      LITMEMCPY (version_hdr->stamp, "VeRsIoN#");

     }
 
 #ifdef NLMCONV_POWERPC
     }
 
 #ifdef NLMCONV_POWERPC


@@ -901,12 +889,12 @@ main (argc, argv)
 #endif
 
   /* Copy over the sections.  */
 #endif
 
   /* Copy over the sections.  */

-  bfd_map_over_sections (inbfd, copy_sections, (PTR) outbfd);
+  bfd_map_over_sections (inbfd, copy_sections, (void *) outbfd);

 
   /* Finish up the header information.  */
   if (custom_file != NULL)
     {
 
   /* Finish up the header information.  */
   if (custom_file != NULL)
     {

-      PTR data;
+      void *data;

 
       data = xmalloc (custom_size);
       if (fread (data, 1, custom_size, custom_data) != custom_size)
 
       data = xmalloc (custom_size);
       if (fread (data, 1, custom_size, custom_data) != custom_size)


@@ -931,11 +919,11 @@ main (argc, argv)
         export information and the debugging information.  */
       nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1;
     }
         export information and the debugging information.  */
       nlm_fixed_header (outbfd)->debugInfoOffset = (file_ptr) -1;
     }

-  if (map_file != NULL)
-    non_fatal (_("warning: MAP and FULLMAP are not supported; try ld -M"));
+  if (full_map)
+    non_fatal (_("warning: FULLMAP is not supported; try ld -M"));

   if (help_file != NULL)
     {
   if (help_file != NULL)
     {

-      PTR data;
+      void *data;

 
       data = xmalloc (help_size);
       if (fread (data, 1, help_size, help_data) != help_size)
 
       data = xmalloc (help_size);
       if (fread (data, 1, help_size, help_data) != help_size)


@@ -953,7 +941,7 @@ main (argc, argv)
     }
   if (message_file != NULL)
     {
     }
   if (message_file != NULL)
     {

-      PTR data;
+      void *data;

 
       data = xmalloc (message_size);
       if (fread (data, 1, message_size, message_data) != message_size)
 
       data = xmalloc (message_size);
       if (fread (data, 1, message_size, message_data) != message_size)


@@ -978,7 +966,7 @@ main (argc, argv)
     }
   if (modules != NULL)
     {
     }
   if (modules != NULL)
     {

-      PTR data;
+      void *data;

       unsigned char *set;
       struct string_list *l;
       bfd_size_type c;
       unsigned char *set;
       struct string_list *l;
       bfd_size_type c;


@@ -989,7 +977,7 @@ main (argc, argv)
       for (l = modules; l != NULL; l = l->next)
        {
          *set = strlen (l->string);
       for (l = modules; l != NULL; l = l->next)
        {
          *set = strlen (l->string);

-         strncpy (set + 1, l->string, *set);
+         strncpy ((char *) set + 1, l->string, *set);

          set += *set + 1;
          ++c;
        }
          set += *set + 1;
          ++c;
        }


@@ -1002,7 +990,7 @@ main (argc, argv)
     }
   if (rpc_file != NULL)
     {
     }
   if (rpc_file != NULL)
     {

-      PTR data;
+      void *data;

 
       data = xmalloc (rpc_size);
       if (fread (data, 1, rpc_size, rpc_data) != rpc_size)
 
       data = xmalloc (rpc_size);
       if (fread (data, 1, rpc_size, rpc_data) != rpc_size)


@@ -1020,7 +1008,7 @@ main (argc, argv)
     }
   if (sharelib_file != NULL)
     {
     }
   if (sharelib_file != NULL)
     {

-      PTR data;
+      void *data;

 
       data = xmalloc (shared_size);
       if (fseek (shared_data, shared_offset, SEEK_SET) != 0
 
       data = xmalloc (shared_size);
       if (fseek (shared_data, shared_offset, SEEK_SET) != 0


@@ -1066,18 +1054,24 @@ main (argc, argv)
        sharedhdr.exitProcedureOffset;
       free (data);
     }
        sharedhdr.exitProcedureOffset;
       free (data);
     }

-  len = strlen (output_file);
-  if (len > NLM_MODULE_NAME_SIZE - 2)
-    len = NLM_MODULE_NAME_SIZE - 2;
-  nlm_fixed_header (outbfd)->moduleName[0] = len;
-
-  strncpy (nlm_fixed_header (outbfd)->moduleName + 1, output_file,
-          NLM_MODULE_NAME_SIZE - 2);
-  nlm_fixed_header (outbfd)->moduleName[NLM_MODULE_NAME_SIZE - 1] = '\0';
-  for (modname = nlm_fixed_header (outbfd)->moduleName;
-       *modname != '\0';
-       modname++)
-    *modname = TOUPPER (*modname);
+
+  {
+    const int    max_len  = NLM_MODULE_NAME_SIZE - 2;
+    const char * filename = lbasename (output_file);
+
+    len = strlen (filename);
+    if (len > max_len)
+      len = max_len;
+    nlm_fixed_header (outbfd)->moduleName[0] = len;
+
+    strncpy (nlm_fixed_header (outbfd)->moduleName + 1, filename, max_len);
+    nlm_fixed_header (outbfd)->moduleName[max_len + 1] = '\0';
+
+    for (modname = nlm_fixed_header (outbfd)->moduleName;
+        *modname != '\0';
+        modname++)
+      *modname = TOUPPER (*modname);
+  }

 
   strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG",
           NLM_OLD_THREAD_NAME_LENGTH);
 
   strncpy (nlm_variable_header (outbfd)->oldThreadName, " LONG",
           NLM_OLD_THREAD_NAME_LENGTH);


@@ -1100,9 +1094,7 @@ main (argc, argv)
 /* Show a usage message and exit.  */
 
 static void
 /* Show a usage message and exit.  */
 
 static void

-show_usage (file, status)
-     FILE *file;
-     int status;
+show_usage (FILE *file, int status)

 {
   fprintf (file, _("Usage: %s [option(s)] [in-file [out-file]]\n"), program_name);
   fprintf (file, _(" Convert an object file into a NetWare Loadable Module\n"));
 {
   fprintf (file, _("Usage: %s [option(s)] [in-file [out-file]]\n"), program_name);
   fprintf (file, _(" Convert an object file into a NetWare Loadable Module\n"));


@@ -1112,10 +1104,11 @@ show_usage (file, status)
   -T --header-file=<file>       Read <file> for NLM header information\n\
   -l --linker=<linker>          Use <linker> for any linking\n\
   -d --debug                    Display on stderr the linker command line\n\
   -T --header-file=<file>       Read <file> for NLM header information\n\
   -l --linker=<linker>          Use <linker> for any linking\n\
   -d --debug                    Display on stderr the linker command line\n\

+  @<file>                       Read options from <file>.\n\

   -h --help                     Display this information\n\
   -v --version                  Display the program's version\n\
 "));
   -h --help                     Display this information\n\
   -v --version                  Display the program's version\n\
 "));

-  if (status == 0)
+  if (REPORT_BUGS_TO[0] && status == 0)

     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
   exit (status);
 }
     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
   exit (status);
 }


@@ -1124,10 +1117,8 @@ show_usage (file, status)
    and endianness.  This chooses the appropriate NLM target.  */
 
 static const char *
    and endianness.  This chooses the appropriate NLM target.  */
 
 static const char *

-select_output_format (arch, mach, bigendian)
-     enum bfd_architecture arch;
-     unsigned long mach;
-     boolean bigendian ATTRIBUTE_UNUSED;
+select_output_format (enum bfd_architecture arch, unsigned long mach,
+                     bfd_boolean bigendian ATTRIBUTE_UNUSED)

 {
   switch (arch)
     {
 {
   switch (arch)
     {


@@ -1159,10 +1150,7 @@ select_output_format (arch, mach, bigendian)
    name, size, etc.  */
 
 static void
    name, size, etc.  */
 
 static void

-setup_sections (inbfd, insec, data_ptr)
-     bfd *inbfd ATTRIBUTE_UNUSED;
-     asection *insec;
-     PTR data_ptr;
+setup_sections (bfd *inbfd ATTRIBUTE_UNUSED, asection *insec, void *data_ptr)

 {
   bfd *outbfd = (bfd *) data_ptr;
   flagword f;
 {
   bfd *outbfd = (bfd *) data_ptr;
   flagword f;


@@ -1229,17 +1217,14 @@ setup_sections (inbfd, insec, data_ptr)
 /* Copy the section contents.  */
 
 static void
 /* Copy the section contents.  */
 
 static void

-copy_sections (inbfd, insec, data_ptr)
-     bfd *inbfd;
-     asection *insec;
-     PTR data_ptr;
+copy_sections (bfd *inbfd, asection *insec, void *data_ptr)

 {
   static bfd_size_type secsecoff = 0;
   bfd *outbfd = (bfd *) data_ptr;
   const char *inname;
   asection *outsec;
   bfd_size_type size;
 {
   static bfd_size_type secsecoff = 0;
   bfd *outbfd = (bfd *) data_ptr;
   const char *inname;
   asection *outsec;
   bfd_size_type size;

-  PTR contents;
+  void *contents;

   long reloc_size;
   bfd_byte buf[4];
   bfd_size_type add;
   long reloc_size;
   bfd_byte buf[4];
   bfd_size_type add;


@@ -1249,11 +1234,7 @@ copy_sections (inbfd, insec, data_ptr)
   outsec = insec->output_section;
   assert (outsec != NULL);
 
   outsec = insec->output_section;
   assert (outsec != NULL);
 

-  size = bfd_get_section_size_before_reloc (insec);
-
-  /* FIXME: Why are these necessary?  */
-  insec->_cooked_size = insec->_raw_size;
-  insec->reloc_done = true;
+  size = bfd_get_section_size (insec);

 
   if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0)
     contents = NULL;
 
   if ((bfd_get_section_flags (inbfd, insec) & SEC_HAS_CONTENTS) == 0)
     contents = NULL;


@@ -1309,7 +1290,7 @@ copy_sections (inbfd, insec, data_ptr)
     }
 
   /* Add this section to .nlmsections.  */
     }
 
   /* Add this section to .nlmsections.  */

-  if (! bfd_set_section_contents (outbfd, secsec, (PTR) inname, secsecoff,
+  if (! bfd_set_section_contents (outbfd, secsec, (void *) inname, secsecoff,

                                  strlen (inname) + 1))
     bfd_fatal (_("set .nlmsection contents"));
   secsecoff += strlen (inname) + 1;
                                  strlen (inname) + 1))
     bfd_fatal (_("set .nlmsection contents"));
   secsecoff += strlen (inname) + 1;


@@ -1341,14 +1322,9 @@ copy_sections (inbfd, insec, data_ptr)
    by the input formats.  */
 
 static void
    by the input formats.  */
 
 static void

-mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
-              contents_size)
-     bfd *outbfd;
-     asection *insec;
-     arelent ***relocs_ptr;
-     long *reloc_count_ptr;
-     char *contents;
-     bfd_size_type contents_size;
+mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,
+              long *reloc_count_ptr, char *contents,
+              bfd_size_type contents_size)

 {
   switch (bfd_get_arch (outbfd))
     {
 {
   switch (bfd_get_arch (outbfd))
     {


@@ -1381,20 +1357,16 @@ mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
    the output_offset.  */
 
 static void
    the output_offset.  */
 
 static void

-default_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
-                      contents_size)
-     bfd *outbfd ATTRIBUTE_UNUSED;
-     asection *insec;
-     arelent ***relocs_ptr;
-     long *reloc_count_ptr;
-     char *contents ATTRIBUTE_UNUSED;
-     bfd_size_type contents_size ATTRIBUTE_UNUSED;
+default_mangle_relocs (bfd *outbfd ATTRIBUTE_UNUSED, asection *insec,
+                      arelent ***relocs_ptr, long *reloc_count_ptr,
+                      char *contents ATTRIBUTE_UNUSED,
+                      bfd_size_type contents_size ATTRIBUTE_UNUSED)

 {
   if (insec->output_offset != 0)
     {
       long reloc_count;
 {
   if (insec->output_offset != 0)
     {
       long reloc_count;

-      register arelent **relocs;
-      register long i;
+      arelent **relocs;
+      long i;

 
       reloc_count = *reloc_count_ptr;
       relocs = *relocs_ptr;
 
       reloc_count = *reloc_count_ptr;
       relocs = *relocs_ptr;


@@ -1416,25 +1388,20 @@ static reloc_howto_type nlm_i386_pcrel_howto =
         0,                     /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */
         0,                     /* rightshift */
         2,                     /* size (0 = byte, 1 = short, 2 = long) */
         32,                    /* bitsize */

-        true,                  /* pc_relative */
+        TRUE,                  /* pc_relative */

         0,                     /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         0,                     /* special_function */
         "DISP32",              /* name */
         0,                     /* bitpos */
         complain_overflow_signed, /* complain_on_overflow */
         0,                     /* special_function */
         "DISP32",              /* name */

-        true,                  /* partial_inplace */
+        TRUE,                  /* partial_inplace */

         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */
         0xffffffff,            /* src_mask */
         0xffffffff,            /* dst_mask */

-        true);                 /* pcrel_offset */
+        TRUE);                 /* pcrel_offset */

 
 static void
 
 static void

-i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
-                   contents_size)
-     bfd *outbfd;
-     asection *insec;
-     arelent ***relocs_ptr;
-     long *reloc_count_ptr;
-     char *contents;
-     bfd_size_type contents_size;
+i386_mangle_relocs (bfd *outbfd, asection *insec, arelent ***relocs_ptr,
+                   long *reloc_count_ptr, char *contents,
+                   bfd_size_type contents_size)

 {
   long reloc_count, i;
   arelent **relocs;
 {
   long reloc_count, i;
   arelent **relocs;


@@ -1449,6 +1416,9 @@ i386_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
       bfd_vma addend;
 
       rel = *relocs++;
       bfd_vma addend;
 
       rel = *relocs++;

+      /* PR 17512: file: 057f89c1.  */
+      if (rel->sym_ptr_ptr == NULL)
+       continue;

       sym = *rel->sym_ptr_ptr;
 
       /* We're moving the relocs from the input section to the output
       sym = *rel->sym_ptr_ptr;
 
       /* We're moving the relocs from the input section to the output


@@ -1574,29 +1544,25 @@ static reloc_howto_type nlm32_alpha_nw_howto =
         0,                     /* rightshift */
         0,                     /* size (0 = byte, 1 = short, 2 = long) */
         0,                     /* bitsize */
         0,                     /* rightshift */
         0,                     /* size (0 = byte, 1 = short, 2 = long) */
         0,                     /* bitsize */

-        false,                 /* pc_relative */
+        FALSE,                 /* pc_relative */

         0,                     /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         0,                     /* special_function */
         "NW_RELOC",            /* name */
         0,                     /* bitpos */
         complain_overflow_dont, /* complain_on_overflow */
         0,                     /* special_function */
         "NW_RELOC",            /* name */

-        false,                 /* partial_inplace */
+        FALSE,                 /* partial_inplace */

         0,                     /* src_mask */
         0,                     /* dst_mask */
         0,                     /* src_mask */
         0,                     /* dst_mask */

-        false);                /* pcrel_offset */
+        FALSE);                /* pcrel_offset */

 
 static void
 
 static void

-alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
-                    contents_size)
-     bfd *outbfd;
-     asection *insec;
-     register arelent ***relocs_ptr;
-     long *reloc_count_ptr;
-     char *contents ATTRIBUTE_UNUSED;
-     bfd_size_type contents_size ATTRIBUTE_UNUSED;
+alpha_mangle_relocs (bfd *outbfd, asection *insec,
+                    arelent ***relocs_ptr, long *reloc_count_ptr,
+                    char *contents ATTRIBUTE_UNUSED,
+                    bfd_size_type contents_size ATTRIBUTE_UNUSED)

 {
   long old_reloc_count;
   arelent **old_relocs;
 {
   long old_reloc_count;
   arelent **old_relocs;

-  register arelent **relocs;
+  arelent **relocs;

 
   old_reloc_count = *reloc_count_ptr;
   old_relocs = *relocs_ptr;
 
   old_reloc_count = *reloc_count_ptr;
   old_relocs = *relocs_ptr;


@@ -1645,15 +1611,14 @@ alpha_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
   ++relocs;
   ++(*reloc_count_ptr);
 
   ++relocs;
   ++(*reloc_count_ptr);
 

-  memcpy ((PTR) relocs, (PTR) old_relocs,
-         (size_t) old_reloc_count * sizeof (arelent *));
+  memcpy (relocs, old_relocs, (size_t) old_reloc_count * sizeof (arelent *));

   relocs[old_reloc_count] = (arelent *) NULL;
 
   free (old_relocs);
 
   if (insec->output_offset != 0)
     {
   relocs[old_reloc_count] = (arelent *) NULL;
 
   free (old_relocs);
 
   if (insec->output_offset != 0)
     {

-      register bfd_size_type i;
+      bfd_size_type i;

 
       for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++)
        (*relocs)->address += insec->output_offset;
 
       for (i = 0; i < (bfd_size_type) old_reloc_count; i++, relocs++)
        (*relocs)->address += insec->output_offset;


@@ -1722,11 +1687,8 @@ static bfd_size_type powerpc_initial_got_size;
    build a stub for each one.  */
 
 static void
    build a stub for each one.  */
 
 static void

-powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
-     bfd *inbfd;
-     bfd *outbfd ATTRIBUTE_UNUSED;
-     asymbol ***symbols_ptr;
-     long *symcount_ptr;
+powerpc_build_stubs (bfd *inbfd, bfd *outbfd ATTRIBUTE_UNUSED,
+                    asymbol ***symbols_ptr, long *symcount_ptr)

 {
   asection *stub_sec;
   asection *got_sec;
 {
   asection *stub_sec;
   asection *got_sec;


@@ -1737,13 +1699,12 @@ powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
 
   /* Make a section to hold stubs.  We don't set SEC_HAS_CONTENTS for
      the section to prevent copy_sections from reading from it.  */
 
   /* Make a section to hold stubs.  We don't set SEC_HAS_CONTENTS for
      the section to prevent copy_sections from reading from it.  */

-  stub_sec = bfd_make_section (inbfd, ".stubs");
+  stub_sec = bfd_make_section_with_flags (inbfd, ".stubs",
+                                         (SEC_CODE
+                                          | SEC_RELOC
+                                          | SEC_ALLOC
+                                          | SEC_LOAD));

   if (stub_sec == (asection *) NULL
   if (stub_sec == (asection *) NULL

-      || ! bfd_set_section_flags (inbfd, stub_sec,
-                                 (SEC_CODE
-                                  | SEC_RELOC
-                                  | SEC_ALLOC
-                                  | SEC_LOAD))

       || ! bfd_set_section_alignment (inbfd, stub_sec, 2))
     bfd_fatal (".stubs");
 
       || ! bfd_set_section_alignment (inbfd, stub_sec, 2))
     bfd_fatal (".stubs");
 


@@ -1751,14 +1712,13 @@ powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
   got_sec = bfd_get_section_by_name (inbfd, ".got");
   if (got_sec == (asection *) NULL)
     {
   got_sec = bfd_get_section_by_name (inbfd, ".got");
   if (got_sec == (asection *) NULL)
     {

-      got_sec = bfd_make_section (inbfd, ".got");
+      got_sec = bfd_make_section_with_flags (inbfd, ".got",
+                                            (SEC_DATA
+                                             | SEC_RELOC
+                                             | SEC_ALLOC
+                                             | SEC_LOAD
+                                             | SEC_HAS_CONTENTS));

       if (got_sec == (asection *) NULL
       if (got_sec == (asection *) NULL

-         || ! bfd_set_section_flags (inbfd, got_sec,
-                                     (SEC_DATA
-                                      | SEC_RELOC
-                                      | SEC_ALLOC
-                                      | SEC_LOAD
-                                      | SEC_HAS_CONTENTS))

          || ! bfd_set_section_alignment (inbfd, got_sec, 2))
        bfd_fatal (".got");
     }
          || ! bfd_set_section_alignment (inbfd, got_sec, 2))
        bfd_fatal (".got");
     }


@@ -1787,9 +1747,9 @@ powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
 
       /* Make a new undefined symbol with the same name but without
         the leading `.'.  */
 
       /* Make a new undefined symbol with the same name but without
         the leading `.'.  */

-      newsym = (asymbol *) xmalloc (sizeof (asymbol));
+      newsym = xmalloc (sizeof (asymbol));

       *newsym = *sym;
       *newsym = *sym;

-      newname = (char *) xmalloc (strlen (bfd_asymbol_name (sym)));
+      newname = xmalloc (strlen (bfd_asymbol_name (sym)));

       strcpy (newname, bfd_asymbol_name (sym) + 1);
       newsym->name = newname;
 
       strcpy (newname, bfd_asymbol_name (sym) + 1);
       newsym->name = newname;
 


@@ -1842,9 +1802,7 @@ powerpc_build_stubs (inbfd, outbfd, symbols_ptr, symcount_ptr)
    of the output section, and create new relocs in the TOC.  */
 
 static void
    of the output section, and create new relocs in the TOC.  */
 
 static void

-powerpc_resolve_stubs (inbfd, outbfd)
-     bfd *inbfd;
-     bfd *outbfd;
+powerpc_resolve_stubs (bfd *inbfd, bfd *outbfd)

 {
   bfd_byte buf[POWERPC_STUB_SIZE];
   unsigned int i;
 {
   bfd_byte buf[POWERPC_STUB_SIZE];
   unsigned int i;


@@ -1905,31 +1863,26 @@ powerpc_resolve_stubs (inbfd, outbfd)
    any further reloc.  */
 
 static void
    any further reloc.  */
 
 static void

-powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
-                      contents_size)
-     bfd *outbfd;
-     asection *insec;
-     register arelent ***relocs_ptr;
-     long *reloc_count_ptr;
-     char *contents;
-     bfd_size_type contents_size ATTRIBUTE_UNUSED;
+powerpc_mangle_relocs (bfd *outbfd, asection *insec,
+                      arelent ***relocs_ptr,
+                      long *reloc_count_ptr, char *contents,
+                      bfd_size_type contents_size ATTRIBUTE_UNUSED)

 {
   reloc_howto_type *toc_howto;
   long reloc_count;
 {
   reloc_howto_type *toc_howto;
   long reloc_count;

-  register arelent **relocs;
-  register long i;
+  arelent **relocs;
+  long i;

 
   toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16);
   if (toc_howto == (reloc_howto_type *) NULL)
 
   toc_howto = bfd_reloc_type_lookup (insec->owner, BFD_RELOC_PPC_TOC16);
   if (toc_howto == (reloc_howto_type *) NULL)

-    abort ();
+    fatal (_("Unable to locate PPC_TOC16 reloc information"));

 
   /* If this is the .got section, clear out all the contents beyond
      the initial size.  We must do this here because copy_sections is
      going to write out whatever we return in the contents field.  */
   if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0)
     memset (contents + powerpc_initial_got_size, 0,
 
   /* If this is the .got section, clear out all the contents beyond
      the initial size.  We must do this here because copy_sections is
      going to write out whatever we return in the contents field.  */
   if (strcmp (bfd_get_section_name (insec->owner, insec), ".got") == 0)
     memset (contents + powerpc_initial_got_size, 0,

-           (size_t) (bfd_get_section_size_after_reloc (insec)
-                     - powerpc_initial_got_size));
+           (size_t) (bfd_get_section_size (insec) - powerpc_initial_got_size));

 
   reloc_count = *reloc_count_ptr;
   relocs = *relocs_ptr;
 
   reloc_count = *reloc_count_ptr;
   relocs = *relocs_ptr;


@@ -1961,6 +1914,10 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
            }
        }
 
            }
        }
 

+      /* PR 17512: file: 70cfde95.  */
+      if (rel->howto == NULL)
+       continue;
+

       /* We must be able to resolve all PC relative relocs at this
         point.  If we get a branch to an undefined symbol we build a
         stub, since NetWare will resolve undefined symbols into a
       /* We must be able to resolve all PC relative relocs at this
         point.  If we get a branch to an undefined symbol we build a
         stub, since NetWare will resolve undefined symbols into a


@@ -1978,6 +1935,13 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
            {
              bfd_vma val;
 
            {
              bfd_vma val;
 

+             if (rel->address > contents_size - 4)
+               {
+                 non_fatal (_("Out of range relocation: %lx"),
+                            (long) rel->address);
+                 break;
+               }
+

              assert (rel->howto->size == 2 && rel->howto->pcrel_offset);
              val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)
              assert (rel->howto->size == 2 && rel->howto->pcrel_offset);
              val = bfd_get_32 (outbfd, (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)


@@ -2027,6 +1991,13 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
          switch (rel->howto->size)
            {
            case 1:
          switch (rel->howto->size)
            {
            case 1:

+             if (rel->address > contents_size - 2)
+               {
+                 non_fatal (_("Out of range relocation: %lx"),
+                            (long) rel->address);
+                 break;
+               }
+

              val = bfd_get_16 (outbfd,
                                (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)
              val = bfd_get_16 (outbfd,
                                (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)


@@ -2042,6 +2013,14 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
              break;
 
            case 2:
              break;
 
            case 2:

+             /* PR 17512: file: 0455a112.  */
+             if (rel->address > contents_size - 4)
+               {
+                 non_fatal (_("Out of range relocation: %lx"),
+                            (long) rel->address);
+                 break;
+               }
+

              val = bfd_get_32 (outbfd,
                                (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)
              val = bfd_get_32 (outbfd,
                                (bfd_byte *) contents + rel->address);
              val = ((val &~ rel->howto->dst_mask)


@@ -2053,7 +2032,7 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
              break;
 
            default:
              break;
 
            default:

-             abort ();
+             fatal (_("Unsupported relocation size: %d"), rel->howto->size);

            }
 
          if (! bfd_is_und_section (bfd_get_section (sym)))
            }
 
          if (! bfd_is_und_section (bfd_get_section (sym)))


@@ -2088,9 +2067,7 @@ powerpc_mangle_relocs (outbfd, insec, relocs_ptr, reloc_count_ptr, contents,
    file.  */
 
 static char *
    file.  */
 
 static char *

-link_inputs (inputs, ld)
-     struct string_list *inputs;
-     char *ld;
+link_inputs (struct string_list *inputs, char *ld, char * mfile)

 {
   size_t c;
   struct string_list *q;
 {
   size_t c;
   struct string_list *q;


@@ -2105,7 +2082,7 @@ link_inputs (inputs, ld)
   for (q = inputs; q != NULL; q = q->next)
     ++c;
 
   for (q = inputs; q != NULL; q = q->next)
     ++c;
 

-  argv = (char **) alloca ((c + 5) * sizeof(char *));
+  argv = (char **) xmalloc ((c + 7) * sizeof (char *));

 
 #ifndef __MSDOS__
   if (ld == NULL)
 
 #ifndef __MSDOS__
   if (ld == NULL)


@@ -2137,7 +2114,19 @@ link_inputs (inputs, ld)
   argv[1] = (char *) "-Ur";
   argv[2] = (char *) "-o";
   argv[3] = unlink_on_exit;
   argv[1] = (char *) "-Ur";
   argv[2] = (char *) "-o";
   argv[3] = unlink_on_exit;

-  i = 4;
+  /* If we have been given the name of a mapfile and that
+     name is not 'stderr' then pass it on to the linker.  */
+  if (mfile
+      && * mfile
+      && strcmp (mfile, "stderr") == 0)
+    {
+      argv[4] = (char *) "-Map";
+      argv[5] = mfile;
+      i = 6;
+    }
+  else
+    i = 4;
+

   for (q = inputs; q != NULL; q = q->next, i++)
     argv[i] = q->string;
   argv[i] = NULL;
   for (q = inputs; q != NULL; q = q->next, i++)
     argv[i] = q->string;
   argv[i] = NULL;


@@ -2151,6 +2140,8 @@ link_inputs (inputs, ld)
 
   pid = pexecute (ld, argv, program_name, (char *) NULL, &errfmt, &errarg,
                  PEXECUTE_SEARCH | PEXECUTE_ONE);
 
   pid = pexecute (ld, argv, program_name, (char *) NULL, &errfmt, &errarg,
                  PEXECUTE_SEARCH | PEXECUTE_ONE);

+  free (argv);
+

   if (pid == -1)
     {
       fprintf (stderr, _("%s: execution of %s failed: "), program_name, ld);
   if (pid == -1)
     {
       fprintf (stderr, _("%s: execution of %s failed: "), program_name, ld);