BFD messages

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

diff --git a/bfd/bfd.c b/bfd/bfd.c
index c02edbec08a3b041de9fb70a5d742531398e0342..288b5b14fe202e9f14d1b2b2ee1b53ce1e552cb5 100644 (file)
--- a/bfd/bfd.c
+++ b/bfd/bfd.c
@@ -1,5 +1,5 @@
 /* Generic BFD library interface and support routines.
 /* Generic BFD library interface and support routines.

-   Copyright (C) 1990-2015 Free Software Foundation, Inc.
+   Copyright (C) 1990-2018 Free Software Foundation, Inc.

    Written by Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.
    Written by Cygnus Support.
 
    This file is part of BFD, the Binary File Descriptor library.


@@ -46,7 +46,7 @@ CODE_FRAGMENT
 .
 .enum bfd_plugin_format
 .  {
 .
 .enum bfd_plugin_format
 .  {

-.    bfd_plugin_uknown = 0,
+.    bfd_plugin_unknown = 0,

 .    bfd_plugin_yes = 1,
 .    bfd_plugin_no = 2
 .  };
 .    bfd_plugin_yes = 1,
 .    bfd_plugin_no = 2
 .  };


@@ -91,7 +91,7 @@ CODE_FRAGMENT
 .  ENUM_BITFIELD (bfd_direction) direction : 2;
 .
 .  {* Format_specific flags.  *}
 .  ENUM_BITFIELD (bfd_direction) direction : 2;
 .
 .  {* Format_specific flags.  *}

-.  flagword flags : 18;
+.  flagword flags : 20;

 .
 .  {* Values that may appear in the flags field of a BFD.  These also
 .     appear in the object_flags field of the bfd_target structure, where
 .
 .  {* Values that may appear in the flags field of a BFD.  These also
 .     appear in the object_flags field of the bfd_target structure, where


@@ -100,59 +100,59 @@ CODE_FRAGMENT
 .     the object_flags values have mostly just been copied from backend
 .     to another, and are not necessarily correct).  *}
 .
 .     the object_flags values have mostly just been copied from backend
 .     to another, and are not necessarily correct).  *}
 .

-.#define BFD_NO_FLAGS  0x00
+.#define BFD_NO_FLAGS                0x0

 .
 .  {* BFD contains relocation entries.  *}
 .
 .  {* BFD contains relocation entries.  *}

-.#define HAS_RELOC     0x01
+.#define HAS_RELOC                   0x1

 .
 .  {* BFD is directly executable.  *}
 .
 .  {* BFD is directly executable.  *}

-.#define EXEC_P        0x02
+.#define EXEC_P                      0x2

 .
 .  {* BFD has line number information (basically used for F_LNNO in a
 .     COFF header).  *}
 .
 .  {* BFD has line number information (basically used for F_LNNO in a
 .     COFF header).  *}

-.#define HAS_LINENO    0x04
+.#define HAS_LINENO                  0x4

 .
 .  {* BFD has debugging information.  *}
 .
 .  {* BFD has debugging information.  *}

-.#define HAS_DEBUG     0x08
+.#define HAS_DEBUG                  0x08

 .
 .  {* BFD has symbols.  *}
 .
 .  {* BFD has symbols.  *}

-.#define HAS_SYMS      0x10
+.#define HAS_SYMS                   0x10

 .
 .  {* BFD has local symbols (basically used for F_LSYMS in a COFF
 .     header).  *}
 .
 .  {* BFD has local symbols (basically used for F_LSYMS in a COFF
 .     header).  *}

-.#define HAS_LOCALS    0x20
+.#define HAS_LOCALS                 0x20

 .
 .  {* BFD is a dynamic object.  *}
 .
 .  {* BFD is a dynamic object.  *}

-.#define DYNAMIC       0x40
+.#define DYNAMIC                    0x40

 .
 .  {* Text section is write protected (if D_PAGED is not set, this is
 .     like an a.out NMAGIC file) (the linker sets this by default, but
 .     clears it for -r or -N).  *}
 .
 .  {* Text section is write protected (if D_PAGED is not set, this is
 .     like an a.out NMAGIC file) (the linker sets this by default, but
 .     clears it for -r or -N).  *}

-.#define WP_TEXT       0x80
+.#define WP_TEXT                    0x80

 .
 .  {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 .     linker sets this by default, but clears it for -r or -n or -N).  *}
 .
 .  {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
 .     linker sets this by default, but clears it for -r or -n or -N).  *}

-.#define D_PAGED       0x100
+.#define D_PAGED                   0x100

 .
 .  {* BFD is relaxable (this means that bfd_relax_section may be able to
 .     do something) (sometimes bfd_relax_section can do something even if
 .     this is not set).  *}
 .
 .  {* BFD is relaxable (this means that bfd_relax_section may be able to
 .     do something) (sometimes bfd_relax_section can do something even if
 .     this is not set).  *}

-.#define BFD_IS_RELAXABLE 0x200
+.#define BFD_IS_RELAXABLE          0x200

 .
 .  {* This may be set before writing out a BFD to request using a
 .     traditional format.  For example, this is used to request that when
 .     writing out an a.out object the symbols not be hashed to eliminate
 .     duplicates.  *}
 .
 .  {* This may be set before writing out a BFD to request using a
 .     traditional format.  For example, this is used to request that when
 .     writing out an a.out object the symbols not be hashed to eliminate
 .     duplicates.  *}

-.#define BFD_TRADITIONAL_FORMAT 0x400
+.#define BFD_TRADITIONAL_FORMAT    0x400

 .
 .  {* This flag indicates that the BFD contents are actually cached
 .     in memory.  If this is set, iostream points to a bfd_in_memory
 .     struct.  *}
 .
 .  {* This flag indicates that the BFD contents are actually cached
 .     in memory.  If this is set, iostream points to a bfd_in_memory
 .     struct.  *}

-.#define BFD_IN_MEMORY 0x800
+.#define BFD_IN_MEMORY             0x800

 .
 .  {* This BFD has been created by the linker and doesn't correspond
 .     to any input file.  *}
 .
 .  {* This BFD has been created by the linker and doesn't correspond
 .     to any input file.  *}

-.#define BFD_LINKER_CREATED 0x1000
+.#define BFD_LINKER_CREATED       0x1000

 .
 .  {* This may be set before writing out a BFD to request that it
 .     be written using values for UIDs, GIDs, timestamps, etc. that
 .
 .  {* This may be set before writing out a BFD to request that it
 .     be written using values for UIDs, GIDs, timestamps, etc. that


@@ -160,27 +160,35 @@ CODE_FRAGMENT
 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
 .
 .  {* Compress sections in this BFD.  *}
 .#define BFD_DETERMINISTIC_OUTPUT 0x2000
 .
 .  {* Compress sections in this BFD.  *}

-.#define BFD_COMPRESS 0x4000
+.#define BFD_COMPRESS             0x4000

 .
 .  {* Decompress sections in this BFD.  *}
 .
 .  {* Decompress sections in this BFD.  *}

-.#define BFD_DECOMPRESS 0x8000
+.#define BFD_DECOMPRESS           0x8000

 .
 .  {* BFD is a dummy, for plugins.  *}
 .
 .  {* BFD is a dummy, for plugins.  *}

-.#define BFD_PLUGIN 0x10000
+.#define BFD_PLUGIN              0x10000

 .
 .  {* Compress sections in this BFD with SHF_COMPRESSED from gABI.  *}
 .
 .  {* Compress sections in this BFD with SHF_COMPRESSED from gABI.  *}

-.#define BFD_COMPRESS_GABI 0x20000
+.#define BFD_COMPRESS_GABI       0x20000
+.
+.  {* Convert ELF common symbol type to STT_COMMON or STT_OBJECT in this
+.     BFD.  *}
+.#define BFD_CONVERT_ELF_COMMON  0x40000
+.
+.  {* Use the ELF STT_COMMON type in this BFD.  *}
+.#define BFD_USE_ELF_STT_COMMON  0x80000

 .
 .  {* Flags bits to be saved in bfd_preserve_save.  *}
 .#define BFD_FLAGS_SAVED \
 .
 .  {* Flags bits to be saved in bfd_preserve_save.  *}
 .#define BFD_FLAGS_SAVED \

-.  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_PLUGIN \
-.   | BFD_COMPRESS_GABI)
+.  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
+.   | BFD_PLUGIN | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON \
+.   | BFD_USE_ELF_STT_COMMON)

 .
 .  {* Flags bits which are for BFD use only.  *}
 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
 .   | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \
 .
 .  {* Flags bits which are for BFD use only.  *}
 .#define BFD_FLAGS_FOR_BFD_USE_MASK \
 .  (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \
 .   | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \

-.   | BFD_COMPRESS_GABI)
+.   | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON)

 .
 .  {* Is the file descriptor being cached?  That is, can it be closed as
 .     needed, and re-opened when accessed later?  *}
 .
 .  {* Is the file descriptor being cached?  That is, can it be closed as
 .     needed, and re-opened when accessed later?  *}


@@ -282,7 +290,7 @@ CODE_FRAGMENT
 .  struct bfd *archive_next;    {* The next BFD in the archive.  *}
 .  struct bfd *archive_head;    {* The first BFD in the archive.  *}
 .  struct bfd *nested_archives; {* List of nested archive in a flattened
 .  struct bfd *archive_next;    {* The next BFD in the archive.  *}
 .  struct bfd *archive_head;    {* The first BFD in the archive.  *}
 .  struct bfd *nested_archives; {* List of nested archive in a flattened

-.                                  thin archive.  *}
+.                                 thin archive.  *}

 .
 .  union {
 .    {* For input BFDs, a chain of BFDs involved in a link.  *}
 .
 .  union {
 .    {* For input BFDs, a chain of BFDs involved in a link.  *}


@@ -394,7 +402,7 @@ SECTION
        individual documentation for precise semantics).  On an error,
        they call <<bfd_set_error>> to set an error condition that callers
        can check by calling <<bfd_get_error>>.
        individual documentation for precise semantics).  On an error,
        they call <<bfd_set_error>> to set an error condition that callers
        can check by calling <<bfd_get_error>>.

-        If that returns <<bfd_error_system_call>>, then check
+       If that returns <<bfd_error_system_call>>, then check

        <<errno>>.
 
        The easiest way to report a BFD error to the user is to
        <<errno>>.
 
        The easiest way to report a BFD error to the user is to


@@ -443,28 +451,28 @@ static bfd_error_type input_error = bfd_error_no_error;
 
 const char *const bfd_errmsgs[] =
 {
 
 const char *const bfd_errmsgs[] =
 {

-  N_("No error"),
-  N_("System call error"),
-  N_("Invalid bfd target"),
-  N_("File in wrong format"),
-  N_("Archive object file in wrong format"),
-  N_("Invalid operation"),
-  N_("Memory exhausted"),
-  N_("No symbols"),
-  N_("Archive has no index; run ranlib to add one"),
-  N_("No more archived files"),
-  N_("Malformed archive"),
+  N_("no error"),
+  N_("system call error"),
+  N_("invalid bfd target"),
+  N_("file in wrong format"),
+  N_("archive object file in wrong format"),
+  N_("invalid operation"),
+  N_("memory exhausted"),
+  N_("no symbols"),
+  N_("archive has no index; run ranlib to add one"),
+  N_("no more archived files"),
+  N_("malformed archive"),

   N_("DSO missing from command line"),
   N_("DSO missing from command line"),

-  N_("File format not recognized"),
-  N_("File format is ambiguous"),
-  N_("Section has no contents"),
-  N_("Nonrepresentable section on output"),
-  N_("Symbol needs debug section which does not exist"),
-  N_("Bad value"),
-  N_("File truncated"),
-  N_("File too big"),
-  N_("Error reading %s: %s"),
-  N_("#<Invalid error code>")
+  N_("file format not recognized"),
+  N_("file format is ambiguous"),
+  N_("section has no contents"),
+  N_("nonrepresentable section on output"),
+  N_("symbol needs debug section which does not exist"),
+  N_("bad value"),
+  N_("file truncated"),
+  N_("file too big"),
+  N_("error reading %s: %s"),
+  N_("#<invalid error code>")

 };
 
 /*
 };
 
 /*


@@ -489,32 +497,47 @@ FUNCTION
        bfd_set_error
 
 SYNOPSIS
        bfd_set_error
 
 SYNOPSIS

-       void bfd_set_error (bfd_error_type error_tag, ...);
+       void bfd_set_error (bfd_error_type error_tag);

 
 DESCRIPTION
        Set the BFD error condition to be @var{error_tag}.
 
 DESCRIPTION
        Set the BFD error condition to be @var{error_tag}.

-       If @var{error_tag} is bfd_error_on_input, then this function
-       takes two more parameters, the input bfd where the error
-       occurred, and the bfd_error_type error.
+
+       @var{error_tag} must not be bfd_error_on_input.  Use
+       bfd_set_input_error for input errors instead.

 */
 
 void
 */
 
 void

-bfd_set_error (bfd_error_type error_tag, ...)
+bfd_set_error (bfd_error_type error_tag)

 {
   bfd_error = error_tag;
 {
   bfd_error = error_tag;

-  if (error_tag == bfd_error_on_input)
-    {
-      /* This is an error that occurred during bfd_close when
-        writing an archive, but on one of the input files.  */
-      va_list ap;
-
-      va_start (ap, error_tag);
-      input_bfd = va_arg (ap, bfd *);
-      input_error = (bfd_error_type) va_arg (ap, int);
-      if (input_error >= bfd_error_on_input)
-       abort ();
-      va_end (ap);
-    }
+  if (bfd_error >= bfd_error_on_input)
+    abort ();
+}
+
+/*
+FUNCTION
+       bfd_set_input_error
+
+SYNOPSIS
+       void bfd_set_input_error (bfd *input, bfd_error_type error_tag);
+
+DESCRIPTION
+
+       Set the BFD error condition to be bfd_error_on_input.
+       @var{input} is the input bfd where the error occurred, and
+       @var{error_tag} the bfd_error_type error.
+*/
+
+void
+bfd_set_input_error (bfd *input, bfd_error_type error_tag)
+{
+  /* This is an error that occurred during bfd_close when writing an
+     archive, but on one of the input files.  */
+  bfd_error = bfd_error_on_input;
+  input_bfd = input;
+  input_error = error_tag;
+  if (input_error >= bfd_error_on_input)
+    abort ();

 }
 
 /*
 }
 
 /*


@@ -591,11 +614,11 @@ SUBSECTION
        problem.  They call a BFD error handler function.  This
        function may be overridden by the program.
 
        problem.  They call a BFD error handler function.  This
        function may be overridden by the program.
 

-       The BFD error handler acts like printf.
+       The BFD error handler acts like vprintf.

 
 CODE_FRAGMENT
 .
 
 CODE_FRAGMENT
 .

-.typedef void (*bfd_error_handler_type) (const char *, ...);
+.typedef void (*bfd_error_handler_type) (const char *, va_list);

 .
 */
 
 .
 */
 


@@ -603,114 +626,240 @@ CODE_FRAGMENT
 
 static const char *_bfd_error_program_name;
 
 
 static const char *_bfd_error_program_name;
 

-/* This is the default routine to handle BFD error messages.
-   Like fprintf (stderr, ...), but also handles some extra format specifiers.
-
-   %A section name from section.  For group components, print group name too.
-   %B file name from bfd.  For archive components, prints archive too.
-
-   Note - because these two extra format specifiers require special handling
-   they are scanned for and processed in this function, before calling
-   vfprintf.  This means that the *arguments* for these format specifiers
-   must be the first ones in the variable argument list, regardless of where
-   the specifiers appear in the format string.  Thus for example calling
-   this function with a format string of:
+/* Support for positional parameters.  */

 
 

-      "blah %s blah %A blah %d blah %B"
-
-   would involve passing the arguments as:
-
-      "blah %s blah %A blah %d blah %B",
-        asection_for_the_%A,
-       bfd_for_the_%B,
-       string_for_the_%s,
-       integer_for_the_%d);
- */
-
-void
-_bfd_default_error_handler (const char *fmt, ...)
+union _bfd_doprnt_args

 {
 {

-  va_list ap;
-  char *bufp;
-  const char *new_fmt, *p;
-  size_t avail = 1000;
-  char buf[1000];
-
-  /* PR 4992: Don't interrupt output being sent to stdout.  */
-  fflush (stdout);
+  int i;
+  long l;
+  long long ll;
+  double d;
+  long double ld;
+  void *p;
+  enum
+  {
+    Bad,
+    Int,
+    Long,
+    LongLong,
+    Double,
+    LongDouble,
+    Ptr
+  } type;
+};

 
 

-  if (_bfd_error_program_name != NULL)
-    fprintf (stderr, "%s: ", _bfd_error_program_name);
-  else
-    fprintf (stderr, "BFD: ");
+/* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a
+   little and extended to handle '%pA', '%pB' and positional parameters.  */

 
 

-  va_start (ap, fmt);
-  new_fmt = fmt;
-  bufp = buf;
+#define PRINT_TYPE(TYPE, FIELD) \
+  do                                                           \
+    {                                                          \
+      TYPE value = (TYPE) args[arg_no].FIELD;                  \
+      result = fprintf (stream, specifier, value);             \
+    } while (0)

 
 

-  /* Reserve enough space for the existing format string.  */
-  avail -= strlen (fmt) + 1;
-  if (avail > 1000)
-    _exit (EXIT_FAILURE);
+static int
+_bfd_doprnt (FILE *stream, const char *format, union _bfd_doprnt_args *args)
+{
+  const char *ptr = format;
+  char specifier[128];
+  int total_printed = 0;
+  unsigned int arg_count = 0;

 
 

-  p = fmt;
-  while (1)
+  while (*ptr != '\0')

     {
     {

-      char *q;
-      size_t len, extra, trim;
+      int result;

 
 

-      p = strchr (p, '%');
-      if (p == NULL || p[1] == '\0')
+      if (*ptr != '%')

        {
        {

-         if (new_fmt == buf)
+         /* While we have regular characters, print them.  */
+         char *end = strchr (ptr, '%');
+         if (end != NULL)
+           result = fprintf (stream, "%.*s", (int) (end - ptr), ptr);
+         else
+           result = fprintf (stream, "%s", ptr);
+         ptr += result;
+       }
+      else if (ptr[1] == '%')
+       {
+         fputc ('%', stream);
+         result = 1;
+         ptr += 2;
+       }
+      else
+       {
+         /* We have a format specifier!  */
+         char *sptr = specifier;
+         int wide_width = 0, short_width = 0;
+         unsigned int arg_no;
+
+         /* Copy the % and move forward.  */
+         *sptr++ = *ptr++;
+
+         /* Check for a positional parameter.  */
+         arg_no = -1u;
+         if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')

            {
            {

-             len = strlen (fmt);
-             memcpy (bufp, fmt, len + 1);
+             arg_no = *ptr - '1';
+             ptr += 2;

            }
            }

-         break;
-       }

 
 

-      if (p[1] == 'A' || p[1] == 'B')
-       {
-         len = p - fmt;
-         memcpy (bufp, fmt, len);
-         bufp += len;
-         fmt = p + 2;
-         new_fmt = buf;
-
-         /* If we run out of space, tough, you lose your ridiculously
-            long file or section name.  It's not safe to try to alloc
-            memory here;  We might be printing an out of memory message.  */
-         if (avail == 0)
+         /* Move past flags.  */
+         while (strchr ("-+ #0'I", *ptr))
+           *sptr++ = *ptr++;
+
+         if (*ptr == '*')

            {
            {

-             *bufp++ = '*';
-             *bufp++ = '*';
-             *bufp = '\0';
+             int value;
+             unsigned int arg_index;
+
+             ptr++;
+             arg_index = arg_count;
+             if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
+               {
+                 arg_index = *ptr - '1';
+                 ptr += 2;
+               }
+             value = abs (args[arg_index].i);
+             arg_count++;
+             sptr += sprintf (sptr, "%d", value);

            }
          else
            }
          else

+           /* Handle explicit numeric value.  */
+           while (ISDIGIT (*ptr))
+             *sptr++ = *ptr++;
+
+         /* Precision.  */
+         if (*ptr == '.')

            {
            {

-             if (p[1] == 'B')
+             /* Copy and go past the period.  */
+             *sptr++ = *ptr++;
+             if (*ptr == '*')

                {
                {

-                 bfd *abfd = va_arg (ap, bfd *);
+                 int value;
+                 unsigned int arg_index;

 
 

-                 if (abfd == NULL)
-                   /* Invoking %B with a null bfd pointer is an internal error.  */
-                   abort ();
-                 else if (abfd->my_archive)
-                   snprintf (bufp, avail, "%s(%s)",
-                             abfd->my_archive->filename, abfd->filename);
-                 else
-                   snprintf (bufp, avail, "%s", abfd->filename);
+                 ptr++;
+                 arg_index = arg_count;
+                 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
+                   {
+                     arg_index = *ptr - '1';
+                     ptr += 2;
+                   }
+                 value = abs (args[arg_index].i);
+                 arg_count++;
+                 sptr += sprintf (sptr, "%d", value);

                }
              else
                }
              else

+               /* Handle explicit numeric value.  */
+               while (ISDIGIT (*ptr))
+                 *sptr++ = *ptr++;
+           }
+         while (strchr ("hlL", *ptr))
+           {
+             switch (*ptr)

                {
                {

-                 asection *sec = va_arg (ap, asection *);
+               case 'h':
+                 short_width = 1;
+                 break;
+               case 'l':
+                 wide_width++;
+                 break;
+               case 'L':
+                 wide_width = 2;
+                 break;
+               default:
+                 abort();
+               }
+             *sptr++ = *ptr++;
+           }
+
+         /* Copy the type specifier, and NULL terminate.  */
+         *sptr++ = *ptr++;
+         *sptr = '\0';
+         if ((int) arg_no < 0)
+           arg_no = arg_count;
+
+         switch (ptr[-1])
+           {
+           case 'd':
+           case 'i':
+           case 'o':
+           case 'u':
+           case 'x':
+           case 'X':
+           case 'c':
+             {
+               /* Short values are promoted to int, so just copy it
+                  as an int and trust the C library printf to cast it
+                  to the right width.  */
+               if (short_width)
+                 PRINT_TYPE (int, i);
+               else
+                 {
+                   switch (wide_width)
+                     {
+                     case 0:
+                       PRINT_TYPE (int, i);
+                       break;
+                     case 1:
+                       PRINT_TYPE (long, l);
+                       break;
+                     case 2:
+                     default:
+#if defined (__MSVCRT__)
+                       sptr[-3] = 'I';
+                       sptr[-2] = '6';
+                       sptr[-1] = '4';
+                       *sptr++ = ptr[-1];
+                       *sptr = '\0';
+#endif
+#if defined (__GNUC__) || defined (HAVE_LONG_LONG)
+                       PRINT_TYPE (long long, ll);
+#else
+                       /* Fake it and hope for the best.  */
+                       PRINT_TYPE (long, l);
+#endif
+                       break;
+                     }
+                 }
+             }
+             break;
+           case 'f':
+           case 'e':
+           case 'E':
+           case 'g':
+           case 'G':
+             {
+               if (wide_width == 0)
+                 PRINT_TYPE (double, d);
+               else
+                 {
+#if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
+                   PRINT_TYPE (long double, ld);
+#else
+                   /* Fake it and hope for the best.  */
+                   PRINT_TYPE (double, d);
+#endif
+                 }
+             }
+             break;
+           case 's':
+             PRINT_TYPE (char *, p);
+             break;
+           case 'p':
+             if (*ptr == 'A')
+               {
+                 asection *sec;

                  bfd *abfd;
                  const char *group = NULL;
                  struct coff_comdat_info *ci;
 
                  bfd *abfd;
                  const char *group = NULL;
                  struct coff_comdat_info *ci;
 

+                 ptr++;
+                 sec = (asection *) args[arg_no].p;

                  if (sec == NULL)
                  if (sec == NULL)

-                   /* Invoking %A with a null section pointer is an internal error.  */
+                   /* Invoking %pA with a null section pointer is an
+                      internal error.  */

                    abort ();
                  abfd = sec->owner;
                  if (abfd != NULL
                    abort ();
                  abfd = sec->owner;
                  if (abfd != NULL


@@ -724,57 +873,280 @@ _bfd_default_error_handler (const char *fmt, ...)
                                                                 sec)) != NULL)
                    group = ci->name;
                  if (group != NULL)
                                                                 sec)) != NULL)
                    group = ci->name;
                  if (group != NULL)

-                   snprintf (bufp, avail, "%s[%s]", sec->name, group);
+                   result = fprintf (stream, "%s[%s]", sec->name, group);

                  else
                  else

-                   snprintf (bufp, avail, "%s", sec->name);
+                   result = fprintf (stream, "%s", sec->name);

                }
                }

-             len = strlen (bufp);
-             avail = avail - len + 2;
-
-             /* We need to replace any '%' we printed by "%%".
-                First count how many.  */
-             q = bufp;
-             bufp += len;
-             extra = 0;
-             while ((q = strchr (q, '%')) != NULL)
+             else if (*ptr == 'B')
+               {
+                 bfd *abfd;
+
+                 ptr++;
+                 abfd = (bfd *) args[arg_no].p;
+                 if (abfd == NULL)
+                   /* Invoking %pB with a null bfd pointer is an
+                      internal error.  */
+                   abort ();
+                 else if (abfd->my_archive
+                          && !bfd_is_thin_archive (abfd->my_archive))
+                   result = fprintf (stream, "%s(%s)",
+                                     abfd->my_archive->filename,
+                                     abfd->filename);
+                 else
+                   result = fprintf (stream, "%s", abfd->filename);
+               }
+             else
+               PRINT_TYPE (void *, p);
+             break;
+           default:
+             abort();
+           }
+         arg_count++;
+       }
+      if (result == -1)
+       return -1;
+      total_printed += result;
+    }
+
+  return total_printed;
+}
+
+/* First pass over FORMAT to gather ARGS.  Returns number of args.  */
+
+static unsigned int
+_bfd_doprnt_scan (const char *format, union _bfd_doprnt_args *args)
+{
+  const char *ptr = format;
+  unsigned int arg_count = 0;
+
+  while (*ptr != '\0')
+    {
+      if (*ptr != '%')
+       {
+         ptr = strchr (ptr, '%');
+         if (ptr == NULL)
+           break;
+       }
+      else if (ptr[1] == '%')
+       ptr += 2;
+      else
+       {
+         int wide_width = 0, short_width = 0;
+         unsigned int arg_no;
+         int arg_type;
+
+         ptr++;
+
+         /* Check for a positional parameter.  */
+         arg_no = -1u;
+         if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')
+           {
+             arg_no = *ptr - '1';
+             ptr += 2;
+           }
+
+         /* Move past flags.  */
+         while (strchr ("-+ #0'I", *ptr))
+           ptr++;
+
+         if (*ptr == '*')
+           {
+             unsigned int arg_index;
+
+             ptr++;
+             arg_index = arg_count;
+             if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')

                {
                {

-                 ++q;
-                 ++extra;
+                 arg_index = *ptr - '1';
+                 ptr += 2;

                }
                }

+             if (arg_index >= 9)
+               abort ();
+             args[arg_index].type = Int;
+             arg_count++;
+           }
+         else
+           /* Handle explicit numeric value.  */
+           while (ISDIGIT (*ptr))
+             ptr++;

 
 

-             /* If there isn't room, trim off the end of the string.  */
-             q = bufp;
-             bufp += extra;
-             if (extra > avail)
+         /* Precision.  */
+         if (*ptr == '.')
+           {
+             ptr++;
+             if (*ptr == '*')

                {
                {

-                 trim = extra - avail;
-                 bufp -= trim;
-                 do
+                 unsigned int arg_index;
+
+                 ptr++;
+                 arg_index = arg_count;
+                 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$')

                    {
                    {

-                     if (*--q == '%')
-                       --extra;
+                     arg_index = *ptr - '1';
+                     ptr += 2;

                    }
                    }

-                 while (--trim != 0);
-                 *q = '\0';
-                 avail = extra;
+                 if (arg_index >= 9)
+                   abort ();
+                 args[arg_index].type = Int;
+                 arg_count++;

                }
                }

-             avail -= extra;
-
-             /* Now double all '%' chars, shuffling the string as we go.  */
-             while (extra != 0)
+             else
+               /* Handle explicit numeric value.  */
+               while (ISDIGIT (*ptr))
+                 ptr++;
+           }
+         while (strchr ("hlL", *ptr))
+           {
+             switch (*ptr)

                {
                {

-                 while ((q[extra] = *q) != '%')
-                   --q;
-                 q[--extra] = '%';
-                 --q;
+               case 'h':
+                 short_width = 1;
+                 break;
+               case 'l':
+                 wide_width++;
+                 break;
+               case 'L':
+                 wide_width = 2;
+                 break;
+               default:
+                 abort();

                }
                }

+             ptr++;
+           }
+
+         ptr++;
+         if ((int) arg_no < 0)
+           arg_no = arg_count;
+
+         arg_type = Bad;
+         switch (ptr[-1])
+           {
+           case 'd':
+           case 'i':
+           case 'o':
+           case 'u':
+           case 'x':
+           case 'X':
+           case 'c':
+             {
+               if (short_width)
+                 arg_type = Int;
+               else
+                 {
+                   switch (wide_width)
+                     {
+                     case 0:
+                       arg_type = Int;
+                       break;
+                     case 1:
+                       arg_type = Long;
+                       break;
+                     case 2:
+                     default:
+#if defined (__GNUC__) || defined (HAVE_LONG_LONG)
+                       arg_type = LongLong;
+#else
+                       arg_type = Long;
+#endif
+                       break;
+                     }
+                 }
+             }
+             break;
+           case 'f':
+           case 'e':
+           case 'E':
+           case 'g':
+           case 'G':
+             {
+               if (wide_width == 0)
+                 arg_type = Double;
+               else
+                 {
+#if defined (__GNUC__) || defined (HAVE_LONG_DOUBLE)
+                   arg_type = LongDouble;
+#else
+                   arg_type = Double;
+#endif
+                 }
+             }
+             break;
+           case 's':
+             arg_type = Ptr;
+             break;
+           case 'p':
+             if (*ptr == 'A' || *ptr == 'B')
+               ptr++;
+             arg_type = Ptr;
+             break;
+           default:
+             abort();

            }
            }

+
+         if (arg_no >= 9)
+           abort ();
+         args[arg_no].type = arg_type;
+         arg_count++;

        }
        }

-      p = p + 2;

     }
 
     }
 

-  vfprintf (stderr, new_fmt, ap);
-  va_end (ap);
+  return arg_count;
+}
+
+/* This is the default routine to handle BFD error messages.
+   Like fprintf (stderr, ...), but also handles some extra format specifiers.
+
+   %pA section name from section.  For group components, prints group name too.
+   %pB file name from bfd.  For archive components, prints archive too.
+
+   Beware: Only supports a maximum of 9 format arguments.  */
+
+static void
+error_handler_internal (const char *fmt, va_list ap)
+{
+  unsigned int i, arg_count;
+  union _bfd_doprnt_args args[9];
+
+  for (i = 0; i < sizeof (args) / sizeof (args[0]); i++)
+    args[i].type = Bad;
+
+  arg_count = _bfd_doprnt_scan (fmt, args);
+  for (i = 0; i < arg_count; i++)
+    {
+      switch (args[i].type)
+       {
+       case Int:
+         args[i].i = va_arg (ap, int);
+         break;
+       case Long:
+         args[i].l = va_arg (ap, long);
+         break;
+       case LongLong:
+         args[i].ll = va_arg (ap, long long);
+         break;
+       case Double:
+         args[i].d = va_arg (ap, double);
+         break;
+       case LongDouble:
+         args[i].ld = va_arg (ap, long double);
+         break;
+       case Ptr:
+         args[i].p = va_arg (ap, void *);
+         break;
+       default:
+         abort ();
+       }
+    }
+
+  /* PR 4992: Don't interrupt output being sent to stdout.  */
+  fflush (stdout);
+
+  if (_bfd_error_program_name != NULL)
+    fprintf (stderr, "%s: ", _bfd_error_program_name);
+  else
+    fprintf (stderr, "BFD: ");
+
+  _bfd_doprnt (stderr, fmt, args);

 
   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
      warning, so use the fputc function to avoid it.  */
 
   /* On AIX, putc is implemented as a macro that triggers a -Wunused-value
      warning, so use the fputc function to avoid it.  */


@@ -788,7 +1160,17 @@ _bfd_default_error_handler (const char *fmt, ...)
    function pointer permits a program linked against BFD to intercept
    the messages and deal with them itself.  */
 
    function pointer permits a program linked against BFD to intercept
    the messages and deal with them itself.  */
 

-bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler;
+static bfd_error_handler_type _bfd_error_internal = error_handler_internal;
+
+void
+_bfd_error_handler (const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start (ap, fmt);
+  _bfd_error_internal (fmt, ap);
+  va_end (ap);
+}

 
 /*
 FUNCTION
 
 /*
 FUNCTION


@@ -807,8 +1189,8 @@ bfd_set_error_handler (bfd_error_handler_type pnew)
 {
   bfd_error_handler_type pold;
 
 {
   bfd_error_handler_type pold;
 

-  pold = _bfd_error_handler;
-  _bfd_error_handler = pnew;
+  pold = _bfd_error_internal;
+  _bfd_error_internal = pnew;

   return pold;
 }
 
   return pold;
 }
 


@@ -832,23 +1214,6 @@ bfd_set_error_program_name (const char *name)
   _bfd_error_program_name = name;
 }
 
   _bfd_error_program_name = name;
 }
 

-/*
-FUNCTION
-       bfd_get_error_handler
-
-SYNOPSIS
-       bfd_error_handler_type bfd_get_error_handler (void);
-
-DESCRIPTION
-       Return the BFD error handler function.
-*/
-
-bfd_error_handler_type
-bfd_get_error_handler (void)
-{
-  return _bfd_error_handler;
-}
-

 /*
 SUBSECTION
        BFD assert handler
 /*
 SUBSECTION
        BFD assert handler


@@ -864,9 +1229,9 @@ SUBSECTION
 CODE_FRAGMENT
 .
 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,
 CODE_FRAGMENT
 .
 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg,

-.                                         const char *bfd_version,
-.                                         const char *bfd_file,
-.                                         int bfd_line);
+.                                        const char *bfd_version,
+.                                        const char *bfd_file,
+.                                        int bfd_line);

 .
 */
 
 .
 */
 


@@ -883,14 +1248,14 @@ _bfd_default_assert_handler (const char *bfd_formatmsg,
                             int bfd_line)
 
 {
                             int bfd_line)
 
 {

-  (*_bfd_error_handler) (bfd_formatmsg, bfd_version, bfd_file, bfd_line);
+  _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line);

 }
 
 /* Similar to _bfd_error_handler, a program can decide to exit on an
    internal BFD error.  We use a non-variadic type to simplify passing
    on parameters to other functions, e.g. _bfd_error_handler.  */
 
 }
 
 /* Similar to _bfd_error_handler, a program can decide to exit on an
    internal BFD error.  We use a non-variadic type to simplify passing
    on parameters to other functions, e.g. _bfd_error_handler.  */
 

-bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;
+static bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler;

 
 /*
 FUNCTION
 
 /*
 FUNCTION


@@ -913,23 +1278,6 @@ bfd_set_assert_handler (bfd_assert_handler_type pnew)
   _bfd_assert_handler = pnew;
   return pold;
 }
   _bfd_assert_handler = pnew;
   return pold;
 }

-
-/*
-FUNCTION
-       bfd_get_assert_handler
-
-SYNOPSIS
-       bfd_assert_handler_type bfd_get_assert_handler (void);
-
-DESCRIPTION
-       Return the BFD assert handler function.
-*/
-
-bfd_assert_handler_type
-bfd_get_assert_handler (void)
-{
-  return _bfd_assert_handler;
-}

 \f
 /*
 INODE
 \f
 /*
 INODE


@@ -1018,18 +1366,10 @@ DESCRIPTION
        section @var{sec} to the values @var{rel} and @var{count}.
        The argument @var{abfd} is ignored.
 
        section @var{sec} to the values @var{rel} and @var{count}.
        The argument @var{abfd} is ignored.
 

+.#define bfd_set_reloc(abfd, asect, location, count) \
+.      BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))

 */
 
 */
 

-void
-bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED,
-              sec_ptr asect,
-              arelent **location,
-              unsigned int count)
-{
-  asect->orelocation = location;
-  asect->reloc_count = count;
-}
-

 /*
 FUNCTION
        bfd_set_file_flags
 /*
 FUNCTION
        bfd_set_file_flags


@@ -1078,6 +1418,7 @@ bfd_set_file_flags (bfd *abfd, flagword flags)
 void
 bfd_assert (const char *file, int line)
 {
 void
 bfd_assert (const char *file, int line)
 {

+  /* xgettext:c-format */

   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
                          BFD_VERSION_STRING, file, line);
 }
   (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"),
                          BFD_VERSION_STRING, file, line);
 }


@@ -1089,14 +1430,16 @@ void
 _bfd_abort (const char *file, int line, const char *fn)
 {
   if (fn != NULL)
 _bfd_abort (const char *file, int line, const char *fn)
 {
   if (fn != NULL)

-    (*_bfd_error_handler)
+    _bfd_error_handler
+      /* xgettext:c-format */

       (_("BFD %s internal error, aborting at %s:%d in %s\n"),
        BFD_VERSION_STRING, file, line, fn);
   else
       (_("BFD %s internal error, aborting at %s:%d in %s\n"),
        BFD_VERSION_STRING, file, line, fn);
   else

-    (*_bfd_error_handler)
+    _bfd_error_handler
+      /* xgettext:c-format */

       (_("BFD %s internal error, aborting at %s:%d\n"),
        BFD_VERSION_STRING, file, line);
       (_("BFD %s internal error, aborting at %s:%d\n"),
        BFD_VERSION_STRING, file, line);

-  (*_bfd_error_handler) (_("Please report this bug.\n"));
+  _bfd_error_handler (_("Please report this bug.\n"));

   _exit (EXIT_FAILURE);
 }
 
   _exit (EXIT_FAILURE);
 }
 


@@ -1105,7 +1448,7 @@ FUNCTION
        bfd_get_arch_size
 
 SYNOPSIS
        bfd_get_arch_size
 
 SYNOPSIS

-       int bfd_get_arch_size (bfd *abfd);
+       int bfd_get_arch_size (bfd *abfd);

 
 DESCRIPTION
        Returns the normalized architecture address size, in bits, as
 
 DESCRIPTION
        Returns the normalized architecture address size, in bits, as


@@ -1132,7 +1475,7 @@ FUNCTION
        bfd_get_sign_extend_vma
 
 SYNOPSIS
        bfd_get_sign_extend_vma
 
 SYNOPSIS

-       int bfd_get_sign_extend_vma (bfd *abfd);
+       int bfd_get_sign_extend_vma (bfd *abfd);

 
 DESCRIPTION
        Indicates if the target architecture "naturally" sign extends
 
 DESCRIPTION
        Indicates if the target architecture "naturally" sign extends


@@ -1170,7 +1513,8 @@ bfd_get_sign_extend_vma (bfd *abfd)
       || strcmp (name, "pei-x86-64") == 0
       || strcmp (name, "pe-arm-wince-little") == 0
       || strcmp (name, "pei-arm-wince-little") == 0
       || strcmp (name, "pei-x86-64") == 0
       || strcmp (name, "pe-arm-wince-little") == 0
       || strcmp (name, "pei-arm-wince-little") == 0

-      || strcmp (name, "aixcoff-rs6000") == 0)
+      || strcmp (name, "aixcoff-rs6000") == 0
+      || strcmp (name, "aix5coff64-rs6000") == 0)

     return 1;
 
   if (CONST_STRNEQ (name, "mach-o"))
     return 1;
 
   if (CONST_STRNEQ (name, "mach-o"))


@@ -1185,7 +1529,7 @@ FUNCTION
        bfd_set_start_address
 
 SYNOPSIS
        bfd_set_start_address
 
 SYNOPSIS

-       bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
+       bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);

 
 DESCRIPTION
        Make @var{vma} the entry point of output BFD @var{abfd}.
 
 DESCRIPTION
        Make @var{vma} the entry point of output BFD @var{abfd}.


@@ -1322,7 +1666,7 @@ bfd_scan_vma (const char *string, const char **end, int base)
   if (sizeof (bfd_vma) <= sizeof (unsigned long))
     return strtoul (string, (char **) end, base);
 
   if (sizeof (bfd_vma) <= sizeof (unsigned long))
     return strtoul (string, (char **) end, base);
 

-#ifdef HAVE_STRTOULL
+#if defined (HAVE_STRTOULL) && defined (HAVE_LONG_LONG)

   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
     return strtoull (string, (char **) end, base);
 #endif
   if (sizeof (bfd_vma) <= sizeof (unsigned long long))
     return strtoull (string, (char **) end, base);
 #endif


@@ -1399,8 +1743,8 @@ DESCRIPTION
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_copy_private_header_data(ibfd, obfd) \
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_copy_private_header_data(ibfd, obfd) \

-.     BFD_SEND (obfd, _bfd_copy_private_header_data, \
-.              (ibfd, obfd))
+.      BFD_SEND (obfd, _bfd_copy_private_header_data, \
+.                (ibfd, obfd))

 
 */
 
 
 */
 


@@ -1420,29 +1764,8 @@ DESCRIPTION
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_copy_private_bfd_data(ibfd, obfd) \
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_copy_private_bfd_data(ibfd, obfd) \

-.     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
-.              (ibfd, obfd))
-
-*/
-
-/*
-FUNCTION
-       bfd_merge_private_bfd_data
-
-SYNOPSIS
-       bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
-
-DESCRIPTION
-       Merge private BFD information from the BFD @var{ibfd} to the
-       the output file BFD @var{obfd} when linking.  Return <<TRUE>>
-       on success, <<FALSE>> on error.  Possible error returns are:
-
-       o <<bfd_error_no_memory>> -
-       Not enough memory exists to create private data for @var{obfd}.
-
-.#define bfd_merge_private_bfd_data(ibfd, obfd) \
-.     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
-.              (ibfd, obfd))
+.      BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
+.                (ibfd, obfd))

 
 */
 
 
 */
 


@@ -1462,7 +1785,7 @@ DESCRIPTION
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_set_private_flags(abfd, flags) \
        Not enough memory exists to create private data for @var{obfd}.
 
 .#define bfd_set_private_flags(abfd, flags) \

-.     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
+.      BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))

 
 */
 
 
 */
 


@@ -1474,45 +1797,45 @@ DESCRIPTION
        The following functions exist but have not yet been documented.
 
 .#define bfd_sizeof_headers(abfd, info) \
        The following functions exist but have not yet been documented.
 
 .#define bfd_sizeof_headers(abfd, info) \

-.       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
+.      BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))

 .
 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
 .
 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \

-.       BFD_SEND (abfd, _bfd_find_nearest_line, \
-.                 (abfd, syms, sec, off, file, func, line, NULL))
+.      BFD_SEND (abfd, _bfd_find_nearest_line, \
+.                (abfd, syms, sec, off, file, func, line, NULL))

 .
 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \
 .
 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \

-.                                            line, disc) \
-.       BFD_SEND (abfd, _bfd_find_nearest_line, \
-.                 (abfd, syms, sec, off, file, func, line, disc))
+.                                          line, disc) \
+.      BFD_SEND (abfd, _bfd_find_nearest_line, \
+.                (abfd, syms, sec, off, file, func, line, disc))

 .
 .#define bfd_find_line(abfd, syms, sym, file, line) \
 .
 .#define bfd_find_line(abfd, syms, sym, file, line) \

-.       BFD_SEND (abfd, _bfd_find_line, \
-.                 (abfd, syms, sym, file, line))
+.      BFD_SEND (abfd, _bfd_find_line, \
+.                (abfd, syms, sym, file, line))

 .
 .#define bfd_find_inliner_info(abfd, file, func, line) \
 .
 .#define bfd_find_inliner_info(abfd, file, func, line) \

-.       BFD_SEND (abfd, _bfd_find_inliner_info, \
-.                 (abfd, file, func, line))
+.      BFD_SEND (abfd, _bfd_find_inliner_info, \
+.                (abfd, file, func, line))

 .
 .#define bfd_debug_info_start(abfd) \
 .
 .#define bfd_debug_info_start(abfd) \

-.       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
+.      BFD_SEND (abfd, _bfd_debug_info_start, (abfd))

 .
 .#define bfd_debug_info_end(abfd) \
 .
 .#define bfd_debug_info_end(abfd) \

-.       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
+.      BFD_SEND (abfd, _bfd_debug_info_end, (abfd))

 .
 .#define bfd_debug_info_accumulate(abfd, section) \
 .
 .#define bfd_debug_info_accumulate(abfd, section) \

-.       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
+.      BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))

 .
 .#define bfd_stat_arch_elt(abfd, stat) \
 .
 .#define bfd_stat_arch_elt(abfd, stat) \

-.       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
+.      BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))

 .
 .#define bfd_update_armap_timestamp(abfd) \
 .
 .#define bfd_update_armap_timestamp(abfd) \

-.       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
+.      BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))

 .
 .#define bfd_set_arch_mach(abfd, arch, mach)\
 .
 .#define bfd_set_arch_mach(abfd, arch, mach)\

-.       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
+.      BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))

 .
 .#define bfd_relax_section(abfd, section, link_info, again) \
 .
 .#define bfd_relax_section(abfd, section, link_info, again) \

-.       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
+.      BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))

 .
 .#define bfd_gc_sections(abfd, link_info) \
 .      BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
 .
 .#define bfd_gc_sections(abfd, link_info) \
 .      BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))


@@ -1542,7 +1865,7 @@ DESCRIPTION
 .      BFD_SEND (abfd, _bfd_final_link, (abfd, info))
 .
 .#define bfd_free_cached_info(abfd) \
 .      BFD_SEND (abfd, _bfd_final_link, (abfd, info))
 .
 .#define bfd_free_cached_info(abfd) \

-.       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
+.      BFD_SEND (abfd, _bfd_free_cached_info, (abfd))

 .
 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
 .      BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
 .
 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \
 .      BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))


@@ -1744,7 +2067,7 @@ FUNCTION
        bfd_emul_get_maxpagesize
 
 SYNOPSIS
        bfd_emul_get_maxpagesize
 
 SYNOPSIS

-       bfd_vma bfd_emul_get_maxpagesize (const char *);
+       bfd_vma bfd_emul_get_maxpagesize (const char *);

 
 DESCRIPTION
        Returns the maximum page size, in bytes, as determined by
 
 DESCRIPTION
        Returns the maximum page size, in bytes, as determined by


@@ -1790,7 +2113,7 @@ FUNCTION
        bfd_emul_set_maxpagesize
 
 SYNOPSIS
        bfd_emul_set_maxpagesize
 
 SYNOPSIS

-       void bfd_emul_set_maxpagesize (const char *, bfd_vma);
+       void bfd_emul_set_maxpagesize (const char *, bfd_vma);

 
 DESCRIPTION
        For ELF, set the maximum page size for the emulation.  It is
 
 DESCRIPTION
        For ELF, set the maximum page size for the emulation.  It is


@@ -1815,7 +2138,7 @@ FUNCTION
        bfd_emul_get_commonpagesize
 
 SYNOPSIS
        bfd_emul_get_commonpagesize
 
 SYNOPSIS

-       bfd_vma bfd_emul_get_commonpagesize (const char *);
+       bfd_vma bfd_emul_get_commonpagesize (const char *);

 
 DESCRIPTION
        Returns the common page size, in bytes, as determined by
 
 DESCRIPTION
        Returns the common page size, in bytes, as determined by


@@ -1843,7 +2166,7 @@ FUNCTION
        bfd_emul_set_commonpagesize
 
 SYNOPSIS
        bfd_emul_set_commonpagesize
 
 SYNOPSIS

-       void bfd_emul_set_commonpagesize (const char *, bfd_vma);
+       void bfd_emul_set_commonpagesize (const char *, bfd_vma);

 
 DESCRIPTION
        For ELF, set the common page size for the emulation.  It is
 
 DESCRIPTION
        For ELF, set the common page size for the emulation.  It is


@@ -2000,7 +2323,8 @@ bfd_update_compression_header (bfd *abfd, bfd_byte *contents,
                {
                  Elf64_External_Chdr *echdr
                    = (Elf64_External_Chdr *) contents;
                {
                  Elf64_External_Chdr *echdr
                    = (Elf64_External_Chdr *) contents;

-                 bfd_put_64 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
+                 bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
+                 bfd_put_32 (abfd, 0, &echdr->ch_reserved);

                  bfd_put_64 (abfd, sec->size, &echdr->ch_size);
                  bfd_put_64 (abfd, 1 << sec->alignment_power,
                              &echdr->ch_addralign);
                  bfd_put_64 (abfd, sec->size, &echdr->ch_size);
                  bfd_put_64 (abfd, 1 << sec->alignment_power,
                              &echdr->ch_addralign);


@@ -2061,7 +2385,7 @@ bfd_check_compression_header (bfd *abfd, bfd_byte *contents,
       else
        {
          Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
       else
        {
          Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;

-         chdr.ch_type = bfd_get_64 (abfd, &echdr->ch_type);
+         chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type);

          chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
          chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
        }
          chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size);
          chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign);
        }


@@ -2165,19 +2489,20 @@ FUNCTION
 
 SYNOPSIS
        bfd_boolean bfd_convert_section_contents
 
 SYNOPSIS
        bfd_boolean bfd_convert_section_contents

-         (bfd *ibfd, asection *isec, bfd *obfd, bfd_byte **ptr);
+         (bfd *ibfd, asection *isec, bfd *obfd,
+          bfd_byte **ptr, bfd_size_type *ptr_size);

 
 DESCRIPTION
        Convert the contents, stored in @var{*ptr}, of the section
        @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd}
        if needed.  The original buffer pointed to by @var{*ptr} may
        be freed and @var{*ptr} is returned with memory malloc'd by this
 
 DESCRIPTION
        Convert the contents, stored in @var{*ptr}, of the section
        @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd}
        if needed.  The original buffer pointed to by @var{*ptr} may
        be freed and @var{*ptr} is returned with memory malloc'd by this

-       function.
+       function, and the new size written to @var{ptr_size}.

 */
 
 bfd_boolean
 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
 */
 
 bfd_boolean
 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,

-                             bfd_byte **ptr)
+                             bfd_byte **ptr, bfd_size_type *ptr_size)

 {
   bfd_byte *contents;
   bfd_size_type ihdr_size, ohdr_size, size;
 {
   bfd_byte *contents;
   bfd_size_type ihdr_size, ohdr_size, size;


@@ -2222,7 +2547,7 @@ bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
   else
     {
       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
   else
     {
       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;

-      chdr.ch_type = bfd_get_64 (ibfd, &echdr->ch_type);
+      chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type);

       chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size);
       chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign);
 
       chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size);
       chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign);
 


@@ -2249,7 +2574,8 @@ bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
   else
     {
       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;
   else
     {
       Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents;

-      bfd_put_64 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
+      bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type);
+      bfd_put_32 (obfd, 0, &echdr->ch_reserved);

       bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size);
       bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
     }
       bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size);
       bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign);
     }


@@ -2264,5 +2590,6 @@ bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd,
       *ptr = contents;
     }
 
       *ptr = contents;
     }
 

+  *ptr_size = size;

   return TRUE;
 }
   return TRUE;
 }