diff -rup binutils.orig/binutils/doc/binutils.texi binutils-2.28/binutils/doc/binutils.texi

--- binutils.orig/binutils/doc/binutils.texi	2017-03-20 17:03:56.166605442 +0000

+++ binutils-2.28/binutils/doc/binutils.texi	2017-03-20 17:04:07.688408917 +0000

@@ -1140,6 +1140,7 @@ objcopy [@option{-F} @var{bfdname}|@opti

         [@option{--compress-debug-sections}]

         [@option{--decompress-debug-sections}]

         [@option{--elf-stt-common=@var{val}}]

+        [@option{--merge-notes}]

         [@option{-v}|@option{--verbose}]

         [@option{-V}|@option{--version}]

         [@option{--help}] [@option{--info}]

@@ -1956,6 +1957,10 @@ converted to the @code{STT_COMMON} or @c

 @code{STT_COMMON}. @option{--elf-stt-common=no} converts common symbol

 type to @code{STT_OBJECT}.

+@item --merge-notes

+For ELF files, attempt to reduce the size of any SHT_NOTE type

+sections by removing duplicate notes.

+

 @item -V

 @itemx --version

 Show the version number of @command{objcopy}.

diff -rup binutils.orig/binutils/NEWS binutils-2.28/binutils/NEWS

--- binutils.orig/binutils/NEWS	2017-03-20 17:03:56.167605425 +0000

+++ binutils-2.28/binutils/NEWS	2017-03-20 17:04:07.688408917 +0000

@@ -1,5 +1,8 @@

 -*- text -*-

+* Add --merge-notes options to objcopy to reduce the size of notes in

+  a binary file by merging and deleting redundant notes.

+

 Changes in 2.28:

 * Add support for locating separate debug info files using the build-id

diff -rup binutils.orig/binutils/objcopy.c binutils-2.28/binutils/objcopy.c

--- binutils.orig/binutils/objcopy.c	2017-03-20 17:03:56.167605425 +0000

+++ binutils-2.28/binutils/objcopy.c	2017-03-20 17:04:07.718408405 +0000

@@ -30,6 +30,7 @@

 #include "elf-bfd.h"

 #include "coff/internal.h"

 #include "libcoff.h"

+#include "safe-ctype.h"

 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific

    header in generic PE code.  */

@@ -96,6 +97,10 @@ static bfd_boolean preserve_dates;	/* Pr

 static int deterministic = -1;		/* Enable deterministic archives.  */

 static int status = 0;		/* Exit status.  */

+static bfd_boolean    merge_notes = FALSE;	/* Merge note sections.  */

+static bfd_byte *     merged_notes = NULL;	/* Contents on note section undergoing a merge.  */

+static bfd_size_type  merged_size = 0;		/* New, smaller size of the merged note section.  */

+

 enum strip_action

 {

   STRIP_UNDEF,

@@ -315,6 +320,7 @@ enum command_line_switch

   OPTION_LOCALIZE_HIDDEN,

   OPTION_LOCALIZE_SYMBOLS,

   OPTION_LONG_SECTION_NAMES,

+  OPTION_MERGE_NOTES,

   OPTION_NO_CHANGE_WARNINGS,

   OPTION_ONLY_KEEP_DEBUG,

   OPTION_PAD_TO,

@@ -436,6 +442,7 @@ static struct option copy_options[] =

   {"localize-symbol", required_argument, 0, 'L'},

   {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},

   {"long-section-names", required_argument, 0, OPTION_LONG_SECTION_NAMES},

+  {"merge-notes", no_argument, 0, 'M'},

   {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},

   {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},

   {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},

@@ -634,6 +641,7 @@ copy_usage (FILE *stream, int exit_statu

      --decompress-debug-sections   Decompress DWARF debug sections using zlib\n\

      --elf-stt-common=[yes|no]     Generate ELF common symbols with STT_COMMON\n\

                                      type\n\

+  -M  --merge-notes                Remove redundant entries in note sections\n\

   -v --verbose                     List all object files modified\n\

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

   -V --version                     Display this program's version number\n\

@@ -1201,6 +1209,24 @@ is_update_section (bfd *abfd ATTRIBUTE_U

   return FALSE;

 }

+static bfd_boolean

+is_merged_note_section (bfd * abfd, asection * sec)

+{

+  if (merge_notes

+      && bfd_get_flavour (abfd) == bfd_target_elf_flavour

+      && elf_section_data (sec)->this_hdr.sh_type == SHT_NOTE

+      /* FIXME: We currently only support merging GNU_BUILD_NOTEs.

+	 We should add support for more note types.  */

+      && ((elf_section_data (sec)->this_hdr.sh_flags & SHF_GNU_BUILD_NOTE) != 0

+	  /* Old versions of GAS (prior to 2.27) could not set the section

+	     flags to OS-specific values, so we also accept sections with the

+	     expected name.  */

+	  || (strcmp (sec->name, GNU_BUILD_ATTRS_SECTION_NAME) == 0)))

+    return TRUE;

+

+  return FALSE;

+}

+

 /* See if a non-group section is being removed.  */

 static bfd_boolean

@@ -1818,6 +1844,255 @@ copy_unknown_object (bfd *ibfd, bfd *obf

   return TRUE;

 }

+/* Merge the notes on SEC, removing redundant entries.

+   Returns the new, smaller size of the section upon success.  */

+

+static bfd_size_type

+merge_gnu_build_notes (bfd * abfd, asection * sec, bfd_size_type size, bfd_byte * contents)

+{

+  Elf_Internal_Note * pnotes_end;

+  Elf_Internal_Note * pnotes;

+  Elf_Internal_Note * pnote;

+  bfd_size_type       remain = size;

+  unsigned            version_notes_seen = 0;

+  bfd_boolean         duplicate_found = FALSE;

+  const char *        err = NULL;

+  bfd_byte *          in = contents;

+

+  /* Make a copy of the notes.

+     Minimum size of a note is 12 bytes.  */

+  pnote = pnotes = (Elf_Internal_Note *) xmalloc ((size / 12) * sizeof (Elf_Internal_Note));

+  while (remain >= 12)

+    {

+      pnote->namesz = (bfd_get_32 (abfd, in    ) + 3) & ~3;

+      pnote->descsz = (bfd_get_32 (abfd, in + 4) + 3) & ~3;

+      pnote->type   =  bfd_get_32 (abfd, in + 8);

+

+      if (pnote->type    != NT_GNU_BUILD_ATTRIBUTE_OPEN

+	  && pnote->type != NT_GNU_BUILD_ATTRIBUTE_FUNC)

+	{

+	  err = _("corrupt GNU build attribute note: wrong note type");

+	  goto done;

+	}

+

+      if (pnote->namesz + pnote->descsz + 12 > remain)

+	{

+	  err = _("corrupt GNU build attribute note: note too big");

+	  goto done;

+	}

+

+      if (pnote->namesz < 2)

+	{

+	  err = _("corrupt GNU build attribute note: name too small");

+	  goto done;

+	}

+

+      if (pnote->descsz != 0

+	  && pnote->descsz != 4

+	  && pnote->descsz != 8)

+	{

+	  err = _("corrupt GNU build attribute note: bad description size");

+	  goto done;

+	}

+

+      pnote->namedata = (char *)(in + 12);

+      pnote->descdata = (char *)(in + 12 + pnote->namesz);

+

+      remain -= 12 + pnote->namesz + pnote->descsz;

+      in     += 12 + pnote->namesz + pnote->descsz;

+

+      if (pnote->namesz > 1 && pnote->namedata[1] == GNU_BUILD_ATTRIBUTE_VERSION)

+	++ version_notes_seen;

+      pnote ++;

+    }

+

+  pnotes_end = pnote;

+

+  /* Check that the notes are valid.  */

+  if (remain != 0)

+    {

+      err = _("corrupt GNU build attribute notes: data at end");

+      goto done;

+    }

+

+  if (version_notes_seen == 0)

+    {

+      err = _("bad GNU build attribute notes: no version note");

+      goto done;

+    }

+

+  /* Merging is only needed if there is more than one version note...  */

+  if (version_notes_seen == 1)

+    goto done;

+

+  /* The first note should be the first version note.  */

+  if (pnotes[0].namedata[1] != GNU_BUILD_ATTRIBUTE_VERSION)

+    {

+      err = _("bad GNU build attribute notes: first note not version note");

+      goto done;

+    }

+

+  if (pnotes[0].namedata[0] != GNU_BUILD_ATTRIBUTE_TYPE_STRING

+      || pnotes[0].namedata[2] != '1')

+    {

+      err = _("bad GNU build attribute notes: version note not v1");

+      goto done;

+    }

+

+  /* Now merge the notes.  The rules are:

+     1. Preserve the ordering of the notes.

+     2. Preserve any NT_GNU_BUILD_ATTRIBUTE_FUNC notes.

+     3. Eliminate any NT_GNU_BUILD_ATTRIBUTE_OPEN notes that have the same

+        full name field as the immediately preceeding note with the same type

+	of name.

+     4. If an NT_GNU_BUILD_ATTRIBUTE_OPEN note is going to be preserved and

+        its description field is empty then the nearest preceeding OPEN note

+	with a non-empty description field must also be preserved *OR* the

+	description field of the note must be changed to contain the starting

+	address to which it refers.  */

+  for (pnote = pnotes + 1; pnote < pnotes_end; pnote ++)

+    {

+      Elf_Internal_Note * back;

+      Elf_Internal_Note * prev_open = NULL;

+

+      if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)

+	continue;

+

+      /* Scan for duplicates.  Clear the type field of any found - but do not

+	 delete them just yet.  */

+      for (back = pnote - 1; back >= pnotes; back --)

+	{

+	  if (back->descsz > 0

+	      && back->type != NT_GNU_BUILD_ATTRIBUTE_FUNC

+	      && prev_open == NULL)

+	    prev_open = back;

+

+	  if (back->type == pnote->type

+	      && back->namedata[1] == pnote->namedata[1])

+	    {

+	      if (back->namesz == pnote->namesz

+		  && memcmp (back->namedata, pnote->namedata, back->namesz) == 0)

+		{

+		  duplicate_found = TRUE;

+		  pnote->type = 0;

+		  break;

+		}

+

+	      /* If we have found an attribute match then stop searching backwards.  */

+	      if (! ISPRINT (back->namedata[1])

+		  || strcmp (back->namedata + 2, pnote->namedata + 2) == 0)

+		{

+		  /* Since we are keeping this note we must check to see if its

+		     description refers back to an earlier OPEN note.  If so

+		     then we must make sure that version note is also preserved.  */

+		  if (pnote->descsz == 0

+		      && prev_open != NULL

+		      && prev_open->type == 0)

+		    prev_open->type = NT_GNU_BUILD_ATTRIBUTE_FUNC;

+

+		  break;

+		}

+	    }

+	}

+    }

+

+  if (duplicate_found)

+    {

+      bfd_byte *     new_contents;

+      bfd_byte *     old;

+      bfd_byte *     new;

+      bfd_size_type  new_size;

+      arelent **     relpp = NULL;

+      long           relsize;

+      long           relcount = 0;

+

+      relsize = bfd_get_reloc_upper_bound (abfd, sec);

+      if (relsize > 0)

+	{

+	  /* If there are relocs associated with this section then we may

+	     have to adjust them as well, as we remove notes.  */

+	  relpp = (arelent **) xmalloc (relsize);

+	  relcount = bfd_canonicalize_reloc (abfd, sec, relpp, isympp);

+	  if (relcount < 0)

+	    /* Do not bother complaining here - copy_relocations_in_section

+	       will do that for us.  */

+	    relcount = 0;

+	}

+

+      /* Eliminate the duplicates.  */

+      new = new_contents = xmalloc (size);

+      for (pnote = pnotes, old = contents;

+	   pnote < pnotes_end;

+	   pnote ++)

+	{

+	  bfd_size_type note_size = 12 + pnote->namesz + pnote->descsz;

+

+	  if (pnote->type == 0)

+	    {

+	      if (relcount > 0)

+		{

+		  arelent ** rel;

+

+		  /* If there is a reloc at the current offset, delete it.

+		     Adjust the location of any relocs above the current

+		     location downwards by the size of the note being deleted.

+		     FIXME: We could optimize this loop by retaining a pointer to

+		     the last reloc below the current note.  */

+		  for (rel = relpp; rel < relpp + relcount; rel ++)

+		    {

+		      if ((* rel)->howto == NULL)

+			continue;

+		      if ((* rel)->address < (bfd_vma) (new - new_contents))

+			continue;

+		      if ((* rel)->address >= (bfd_vma) ((new + note_size) - new_contents))

+			  (* rel)->address -= note_size;

+		      else

+			(* rel)->howto = NULL;

+		    }

+		}

+	    }

+	  else

+	    {

+	      memcpy (new, old, note_size);

+	      new += note_size;

+	    }

+

+	  old += note_size;

+	}

+

+      new_size = new - new_contents;

+      memcpy (contents, new_contents, new_size);

+      size = new_size;

+      free (new_contents);

+

+      if (relcount > 0)

+	{

+	  arelent ** rel;

+

+	  for (rel = relpp; rel < relpp + relcount; rel ++)

+	    if ((* rel)->howto == NULL)

+	      {

+		/* Delete eliminated relocs.

+		   FIXME: There are better ways to do this.  */

+		memmove (rel, rel + 1, ((relcount - (rel - relpp)) - 1) * sizeof (* rel));

+		relcount --;

+	      }

+	  bfd_set_reloc (abfd, sec, relpp, relcount);

+	}

+    }

+

+ done:

+  if (err)

+    {

+      bfd_set_error (bfd_error_bad_value);

+      bfd_nonfatal_message (NULL, abfd, sec, err);

+      status = 1;

+    }

+

+  free (pnotes);

+  return size;

+}

+

 /* Copy object file IBFD onto OBFD.

    Returns TRUE upon success, FALSE otherwise.  */

@@ -2145,6 +2420,57 @@ copy_object (bfd *ibfd, bfd *obfd, const

 	}

     }

+  if (merge_notes)

+    {

+      asection *osec;

+

+      /* This palaver is necessary because we must set the output

+	 section size first, before its contents are ready.  */

+      osec = bfd_get_section_by_name (ibfd, GNU_BUILD_ATTRS_SECTION_NAME);

+      if (osec && is_merged_note_section (ibfd, osec))

+	{

+	  bfd_size_type size;

+	  

+	  size = bfd_get_section_size (osec);

+	  if (size == 0)

+	    {

+	      bfd_nonfatal_message (NULL, ibfd, osec, _("warning: note section is empty"));

+	      merge_notes = FALSE;

+	    }

+	  else if (! bfd_get_full_section_contents (ibfd, osec, & merged_notes))

+	    {

+	      bfd_nonfatal_message (NULL, ibfd, osec, _("warning: could not load note section"));

+	      free (merged_notes);

+	      merged_notes = NULL;

+	      merge_notes = FALSE;

+	    }

+	  else

+	    {

+	      merged_size = merge_gnu_build_notes (ibfd, osec, size, merged_notes);

+	      if (merged_size == size)

+		{

+		  /* Merging achieves nothing.  */

+		  free (merged_notes);

+		  merged_notes = NULL;

+		  merge_notes = FALSE;

+		  merged_size = 0;

+		}

+	      else

+		{

+		  if (osec->output_section == NULL

+		      || ! bfd_set_section_size (obfd, osec->output_section, merged_size))

+		    {

+		      bfd_nonfatal_message (NULL, obfd, osec, _("warning: failed to set merged notes size"));

+		      free (merged_notes);

+		      merged_notes = NULL;

+		      merge_notes = FALSE;

+		      merged_size = 0;

+		    }

+		}

+	    }

+	}

+    }

+

   if (dump_sections != NULL)

     {

       struct section_add * pdump;

@@ -2454,6 +2780,24 @@ copy_object (bfd *ibfd, bfd *obfd, const

 	}

     }

+  if (merge_notes)

+    {

+      asection * osec = bfd_get_section_by_name (obfd, GNU_BUILD_ATTRS_SECTION_NAME);

+      if (osec && is_merged_note_section (obfd, osec))

+	{

+	  if (! bfd_set_section_contents (obfd, osec, merged_notes, 0, merged_size))

+	    {

+	      bfd_nonfatal_message (NULL, obfd, osec, _("error: failed to copy merged notes into output"));

+	      return FALSE;

+	    }

+	}

+      else

+	bfd_nonfatal_message (NULL, obfd, osec, _("ICE: lost merged note section"));

+      free (merged_notes);

+      merged_notes = NULL;

+      merge_notes = FALSE;

+    }

+

   if (gnu_debuglink_filename != NULL)

     {

       if (! bfd_fill_in_gnu_debuglink_section

@@ -3179,7 +3523,7 @@ setup_section (bfd *ibfd, sec_ptr isecti

 /* Return TRUE if input section ISECTION should be skipped.  */

 static bfd_boolean

-skip_section (bfd *ibfd, sec_ptr isection)

+skip_section (bfd *ibfd, sec_ptr isection, bfd_boolean skip_copy)

 {

   sec_ptr osection;

   bfd_size_type size;

@@ -3199,6 +3543,11 @@ skip_section (bfd *ibfd, sec_ptr isectio

   if (is_update_section (ibfd, isection))

     return TRUE;

+  /* When merging a note section we skip the copying of the contents,

+     but not the copying of the relocs associated with the contents.  */

+  if (skip_copy && is_merged_note_section (ibfd, isection))

+    return TRUE;

+

   flags = bfd_get_section_flags (ibfd, isection);

   if ((flags & SEC_GROUP) != 0)

     return TRUE;

@@ -3265,7 +3614,7 @@ copy_relocations_in_section (bfd *ibfd,

   long relcount;

   sec_ptr osection;

-  if (skip_section (ibfd, isection))

+  if (skip_section (ibfd, isection, FALSE))

     return;

   osection = isection->output_section;

@@ -3354,7 +3703,7 @@ copy_section (bfd *ibfd, sec_ptr isectio

   sec_ptr osection;

   bfd_size_type size;

-  if (skip_section (ibfd, isection))

+  if (skip_section (ibfd, isection, TRUE))

     return;

   osection = isection->output_section;

@@ -4010,7 +4359,7 @@ copy_main (int argc, char *argv[])

   struct stat statbuf;

   const bfd_arch_info_type *input_arch = NULL;

-  while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:wDU",

+  while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:MN:s:O:d:F:L:G:R:SpgxXHhVvW:wDU",

 			   copy_options, (int *) 0)) != EOF)

     {

       switch (c)

@@ -4104,6 +4453,10 @@ copy_main (int argc, char *argv[])

 	  add_specific_symbol (optarg, keep_specific_htab);

 	  break;

+	case 'M':

+	  merge_notes = TRUE;

+	  break;

+

 	case 'N':

 	  add_specific_symbol (optarg, strip_specific_htab);

 	  break;

diff -rup binutils.orig/binutils/readelf.c binutils-2.28/binutils/readelf.c

--- binutils.orig/binutils/readelf.c	2017-03-20 17:03:56.164605476 +0000

+++ binutils-2.28/binutils/readelf.c	2017-03-20 17:06:13.368265213 +0000

@@ -15557,6 +15557,10 @@ get_note_type (unsigned e_type)

 	return _("NT_VERSION (version)");

       case NT_ARCH:

 	return _("NT_ARCH (architecture)");

+      case NT_GNU_BUILD_ATTRIBUTE_OPEN:

+	return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");

+      case NT_GNU_BUILD_ATTRIBUTE_FUNC:

+	return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");

       default:

 	break;

       }

@@ -15665,6 +15669,12 @@ get_gnu_elf_note_type (unsigned e_type)

       return _("NT_GNU_BUILD_ID (unique build ID bitstring)");

     case NT_GNU_GOLD_VERSION:

       return _("NT_GNU_GOLD_VERSION (gold version)");

+    case NT_GNU_PROPERTY_TYPE_0:

+      return _("NT_GNU_PROPERTY_TYPE_0");

+    case NT_GNU_BUILD_ATTRIBUTE_OPEN:

+      return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");

+    case NT_GNU_BUILD_ATTRIBUTE_FUNC:

+      return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");

     default:

       {

 	static char buff[64];

@@ -15675,6 +15685,155 @@ get_gnu_elf_note_type (unsigned e_type)

     }

 }

+static void

+decode_x86_isa (unsigned int bitmask)

+{

+  while (bitmask)

+    {

+      unsigned int bit = bitmask & (- bitmask);

+

+      bitmask &= ~ bit;

+      switch (bit)

+	{

+	case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;

+	case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;

+	case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;

+	case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;

+	case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;

+	default: printf (_("<unknown: %x>"), bit); break;

+	}

+      if (bitmask)

+	printf (", ");

+    }

+}

+

+static void

+print_gnu_property_note (Elf_Internal_Note * pnote)

+{

+  unsigned char * ptr = (unsigned char *) pnote->descdata;

+  unsigned char * ptr_end = ptr + pnote->descsz;

+  unsigned int    size = is_32bit_elf ? 4 : 8;

+

+  printf (_("      Properties: "));

+

+  if (pnote->descsz < 8 || (pnote->descsz % size) != 0)

+    {

+      printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);

+      return;

+    }

+

+  while (1)

+    {

+      unsigned int j;

+      unsigned int type = byte_get (ptr, 4);

+      unsigned int datasz = byte_get (ptr + 4, 4);

+

+      ptr += 8;

+

+      if ((ptr + datasz) > ptr_end)

+	{

+	  printf (_("<corrupt type (%#x) datasz: %#x>\n"),

+		  type, datasz);

+	  break;

+	}

+

+      if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)

+	{

+	  if (elf_header.e_machine == EM_X86_64

+	      || elf_header.e_machine == EM_IAMCU

+	      || elf_header.e_machine == EM_386)

+	    {

+	      switch (type)

+		{

+		case GNU_PROPERTY_X86_ISA_1_USED:

+		  printf ("x86 ISA used: ");

+		  if (datasz != 4)

+		    printf (_("<corrupt length: %#x> "), datasz);

+		  else

+		    decode_x86_isa (byte_get (ptr, 4));

+		  goto next;

+

+		case GNU_PROPERTY_X86_ISA_1_NEEDED:

+		  printf ("x86 ISA needed: ");

+		  if (datasz != 4)

+		    printf (_("<corrupt length: %#x> "), datasz);

+		  else

+		    decode_x86_isa (byte_get (ptr, 4));

+		  goto next;

+

+		default:

+		  break;

+		}

+	    }

+	}

+      else

+	{

+	  switch (type)

+	    {

+	    case GNU_PROPERTY_STACK_SIZE:

+	      printf (_("stack size: "));

+	      if (datasz != size)

+		printf (_("<corrupt length: %#x> "), datasz);

+	      else

+		printf ("%#lx", (unsigned long) byte_get (ptr, size));

+	      goto next;

+

+	    case GNU_PROPERTY_NO_COPY_ON_PROTECTED:

+	      printf ("no copy on protected ");

+	      if (datasz)

+		printf (_("<corrupt length: %#x> "), datasz);

+	      goto next;

+

+	    default:

+	      break;

+	    }

+	}

+

+      if (type < GNU_PROPERTY_LOPROC)

+	printf (_("

+      else if (type < GNU_PROPERTY_LOUSER)

+	printf (_("

+      else

+	printf (_("

+      for (j = 0; j < datasz; ++j)

+	printf ("%02x ", ptr[j] & 0xff);

+      printf (">");

+

+next:

+      ptr += ((datasz + (size - 1)) & ~ (size - 1));

+      if (ptr == ptr_end)

+	break;

+      else

+	{

+	  if (do_wide)

+	    printf (", ");

+	  else

+	    printf ("\n\t");

+	}

+

+      if (ptr > (ptr_end - 8))

+	{

+	  printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);

+	  break;

+	}

+    }

+

+  printf ("\n");

+}

+

 static int

 print_gnu_note (Elf_Internal_Note *pnote)

 {

@@ -15775,6 +15934,10 @@ print_gnu_note (Elf_Internal_Note *pnote

       }

       break;

+    case NT_GNU_PROPERTY_TYPE_0:

+      print_gnu_property_note (pnote);

+      break;

+      

     default:

       /* Handle unrecognised types.  An error message should have already been

 	 created by get_gnu_elf_note_type(), so all that we need to do is to

@@ -16164,15 +16327,370 @@ print_ia64_vms_note (Elf_Internal_Note *

   return 1;

 }

+/* Print the name of the symbol associated with a build attribute

+   that is attached to address OFFSET.  */

+

+static bfd_boolean

+print_symbol_for_build_attribute (FILE *         file,

+				  unsigned long  offset,

+				  bfd_boolean    is_open_attr)

+{

+  static FILE *             saved_file = NULL;

+  static char *             strtab;

+  static unsigned long      strtablen;

+  static Elf_Internal_Sym * symtab;

+  static unsigned long      nsyms;

+  Elf_Internal_Sym *  saved_sym = NULL;

+  Elf_Internal_Sym *  sym;

+

+  if (saved_file == NULL || file != saved_file)

+    {

+      Elf_Internal_Shdr * symsec;