Fix configure flags by redefining %_configure and using %configure again.

Add missing \ in configure line
Minor fixes due to building in subdir now

binutils-dwarf-type-sign-2.patch

@@ -0,0 +1,142 @@
+--- binutils.orig/binutils/dwarf.c	2020-11-03 17:10:15.182386267 +0000
++++ binutils-2.35.1/binutils/dwarf.c	2020-11-03 17:14:38.660411672 +0000
+@@ -876,6 +876,7 @@ typedef struct abbrev_list
+ {
+   abbrev_entry *        first_abbrev;
+   abbrev_entry *        last_abbrev;
++  dwarf_vma             abbrev_base;
+   dwarf_vma             abbrev_offset;
+   struct abbrev_list *  next;
+   unsigned char *       start_of_next_abbrevs;
+@@ -955,10 +956,11 @@ free_all_abbrevs (void)
+ }
+ 
+ static abbrev_list *
+-new_abbrev_list (dwarf_vma abbrev_offset)
++new_abbrev_list (dwarf_vma abbrev_base, dwarf_vma abbrev_offset)
+ {
+   abbrev_list * list = (abbrev_list *) xcalloc (sizeof * list, 1);
+ 
++  list->abbrev_base = abbrev_base;
+   list->abbrev_offset = abbrev_offset;
+ 
+   list->next = abbrev_lists;
+@@ -968,12 +970,14 @@ new_abbrev_list (dwarf_vma abbrev_offset
+ }
+ 
+ static abbrev_list *
+-find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_offset)
++find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_base,
++				   dwarf_vma abbrev_offset)
+ {
+   abbrev_list * list;
+ 
+   for (list = abbrev_lists; list != NULL; list = list->next)
+-    if (list->abbrev_offset == abbrev_offset)
++    if (list->abbrev_base == abbrev_base
++	&& list->abbrev_offset == abbrev_offset)
+       return list;
+ 
+   return NULL;
+@@ -2415,10 +2419,10 @@ read_and_display_attr_value (unsigned lo
+     case DW_FORM_ref_addr:
+       if (dwarf_version == 2)
+ 	SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
+-      else if (dwarf_version == 3 || dwarf_version == 4)
++      else if (dwarf_version > 2)
+ 	SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+       else
+-	error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
++	error (_("Internal error: DW_FORM_ref_addr is not supported in DWARF version 1.\n"));
+       break;
+ 
+     case DW_FORM_addr:
+@@ -3455,6 +3459,8 @@ process_debug_info (struct dwarf_section
+     {
+       DWARF2_Internal_CompUnit  compunit;
+       unsigned char *           hdrptr;
++      dwarf_vma                 abbrev_base;
++      size_t                    abbrev_size;
+       dwarf_vma                 cu_offset;
+       unsigned int              offset_size;
+       unsigned int              initial_length_size;
+@@ -3499,25 +3505,25 @@ process_debug_info (struct dwarf_section
+ 
+       SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
+ 
+-      list = find_abbrev_list_by_abbrev_offset (compunit.cu_abbrev_offset);
++      if (this_set == NULL)
++	{
++	  abbrev_base = 0;
++	  abbrev_size = debug_displays [abbrev_sec].section.size;
++	}
++      else
++	{
++	  abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
++	  abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
++	}
++
++      list = find_abbrev_list_by_abbrev_offset (abbrev_base,
++						compunit.cu_abbrev_offset);
+       if (list == NULL)
+ 	{
+-	  dwarf_vma        abbrev_base;
+-	  size_t           abbrev_size;
+ 	  unsigned char *  next;
+ 
+-	  if (this_set == NULL)
+-	    {
+-	      abbrev_base = 0;
+-	      abbrev_size = debug_displays [abbrev_sec].section.size;
+-	    }
+-	  else
+-	    {
+-	      abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
+-	      abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
+-	    }
+-
+-	  list = new_abbrev_list (compunit.cu_abbrev_offset);
++	  list = new_abbrev_list (abbrev_base,
++				  compunit.cu_abbrev_offset);
+ 	  next = process_abbrev_set
+ 	    (((unsigned char *) debug_displays [abbrev_sec].section.start
+ 	      + abbrev_base + compunit.cu_abbrev_offset),
+@@ -3734,12 +3740,14 @@ process_debug_info (struct dwarf_section
+ 	      (unsigned long) debug_displays [abbrev_sec].section.size);
+       else
+ 	{
+-	  list = find_abbrev_list_by_abbrev_offset (compunit.cu_abbrev_offset);
++	  list = find_abbrev_list_by_abbrev_offset (abbrev_base,
++						    compunit.cu_abbrev_offset);
+ 	  if (list == NULL)
+ 	    {
+ 	      unsigned char * next;
+ 
+-	      list = new_abbrev_list (compunit.cu_abbrev_offset);
++	      list = new_abbrev_list (abbrev_base,
++				      compunit.cu_abbrev_offset);
+ 	      next = process_abbrev_set
+ 		(((unsigned char *) debug_displays [abbrev_sec].section.start
+ 		  + abbrev_base + compunit.cu_abbrev_offset),
+@@ -5304,7 +5312,7 @@ display_debug_lines_decoded (struct dwar
+ 	      else
+ 		{
+ 		  newFileName = (char *) xmalloc (fileNameLength + 1);
+-		  strcpy (newFileName, fileName);
++		  strncpy (newFileName, fileName, fileNameLength + 1);
+ 		}
+ 
+ 	      if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH))
+@@ -6029,10 +6037,10 @@ display_debug_abbrev (struct dwarf_secti
+       dwarf_vma        offset;
+ 
+       offset = start - section->start;
+-      list = find_abbrev_list_by_abbrev_offset (offset);
++      list = find_abbrev_list_by_abbrev_offset (0, offset);
+       if (list == NULL)
+ 	{
+-	  list = new_abbrev_list (offset);
++	  list = new_abbrev_list (0, offset);
+ 	  start = process_abbrev_set (start, end, list);
+ 	  list->start_of_next_abbrevs = start;
+ 	}

binutils-dwarf-type-sign.patch

@@ -0,0 +1,931 @@
+--- binutils.orig/binutils/dwarf.c	2020-10-21 14:15:47.101351869 +0100
++++ binutils-2.35.1/binutils/dwarf.c	2020-10-21 14:17:44.608585923 +0100
+@@ -1868,7 +1868,7 @@ skip_attr_bytes (unsigned long
+     case DW_FORM_ref_addr:
+       if (dwarf_version == 2)
+ 	SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);
+-      else if (dwarf_version == 3 || dwarf_version == 4)
++      else if (dwarf_version > 2)
+ 	SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+       else
+ 	return NULL;
+@@ -1920,6 +1920,7 @@ skip_attr_bytes (unsigned long
+ 
+     case DW_FORM_ref8:
+     case DW_FORM_data8:
++    case DW_FORM_ref_sig8:
+       data += 8;
+       break;
+ 
+@@ -1934,6 +1935,7 @@ skip_attr_bytes (unsigned long
+     case DW_FORM_block:
+     case DW_FORM_exprloc:
+       READ_ULEB (uvalue, data, end);
++      data += uvalue;
+       break;
+ 
+     case DW_FORM_block1:
+@@ -1951,12 +1953,12 @@ skip_attr_bytes (unsigned long
+       data += 4 + uvalue;
+       break;
+ 
+-    case DW_FORM_ref_sig8:
+-      data += 8;
+-      break;
+-
+     case DW_FORM_indirect:
+-      /* FIXME: Handle this form.  */
++      READ_ULEB (form, data, end);
++      if (form == DW_FORM_implicit_const)
++	SKIP_ULEB (data, end);
++      return skip_attr_bytes (form, data, end, pointer_size, offset_size, dwarf_version, value_return);
++
+     default:
+       return NULL;
+     }
+@@ -1978,7 +1980,7 @@ get_type_signedness (unsigned char *
+ 		     dwarf_vma              offset_size,
+ 		     int                    dwarf_version,
+ 		     bfd_boolean *          is_signed,
+-		     bfd_boolean	    is_nested)
++		     unsigned int	    nesting)
+ {
+   unsigned long   abbrev_number;
+   abbrev_entry *  entry;
+@@ -1997,6 +1999,14 @@ get_type_signedness (unsigned char *
+     /* FIXME: Issue a warning ?  */
+     return;
+ 
++#define MAX_NESTING 20
++  if (nesting > MAX_NESTING)
++    {
++      /* FIXME: Warn - or is this expected ?
++	 NB/ We need to avoid infinite recursion.  */
++      return;
++    }
++
+   for (attr = entry->first_attr;
+        attr != NULL && attr->attribute;
+        attr = attr->next)
+@@ -2019,16 +2029,12 @@ get_type_signedness (unsigned char *
+ #endif
+ 	case DW_AT_type:
+ 	  /* Recurse.  */
+-	  if (is_nested)
+-	    {
+-	      /* FIXME: Warn - or is this expected ?
+-		 NB/ We need to avoid infinite recursion.  */
+-	      return;
+-	    }
+ 	  if (uvalue >= (size_t) (end - start))
+ 	    return;
+-	  get_type_signedness (start, start + uvalue, end, pointer_size,
+-			       offset_size, dwarf_version, is_signed, TRUE);
++	  /* We cannot correctly process DW_FORM_ref_addr at the moment.  */
++	  if (attr->form != DW_FORM_ref_addr)
++	    get_type_signedness (start, start + uvalue, end, pointer_size,
++				 offset_size, dwarf_version, is_signed, nesting + 1);
+ 	  break;
+ 
+ 	case DW_AT_encoding:
+@@ -2206,7 +2212,6 @@ read_and_display_attr_value (unsigned lo
+ 	SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end);
+       else
+ 	error (_("Internal error: DWARF version is not 2, 3 or 4.\n"));
+-
+       break;
+ 
+     case DW_FORM_addr:
+@@ -2246,8 +2251,8 @@ read_and_display_attr_value (unsigned lo
+       uvalue = svalue;
+       break;
+ 
+-    case DW_FORM_GNU_str_index:
+     case DW_FORM_ref_udata:
++    case DW_FORM_GNU_str_index:
+     case DW_FORM_udata:
+     case DW_FORM_GNU_addr_index:
+       READ_ULEB (uvalue, data, end);
+@@ -2663,8 +2668,10 @@ read_and_display_attr_value (unsigned lo
+ 	{
+ 	  bfd_boolean is_signed = FALSE;
+ 
+-	  get_type_signedness (start, start + uvalue, end, pointer_size,
+-			       offset_size, dwarf_version, & is_signed, FALSE);
++	  /* We cannot correctly process DW_FORM_ref_addr at the moment.  */
++	  if (form != DW_FORM_ref_addr)
++	    get_type_signedness (start, start + uvalue, end, pointer_size,
++				 offset_size, dwarf_version, & is_signed, 0);
+ 	  level_type_signed[level] = is_signed;
+ 	}
+       break;
+diff -rup binutils.orig/binutils/dwarf.c binutils-2.35.1/binutils/dwarf.c
+--- binutils.orig/binutils/dwarf.c	2020-10-27 16:24:29.489636820 +0000
++++ binutils-2.35.1/binutils/dwarf.c	2020-10-27 16:24:44.507568083 +0000
+@@ -849,101 +849,204 @@ fetch_indexed_value (dwarf_vma offset, d
+ /* FIXME:  There are better and more efficient ways to handle
+    these structures.  For now though, I just want something that
+    is simple to implement.  */
++/* Records a single attribute in an abbrev.  */
+ typedef struct abbrev_attr
+ {
+-  unsigned long attribute;
+-  unsigned long form;
+-  bfd_signed_vma implicit_const;
+-  struct abbrev_attr *next;
++  unsigned long          attribute;
++  unsigned long          form;
++  bfd_signed_vma         implicit_const;
++  struct abbrev_attr *   next;
+ }
+ abbrev_attr;
+ 
++/* Records a single abbrev.  */
+ typedef struct abbrev_entry
+ {
+-  unsigned long entry;
+-  unsigned long tag;
+-  int children;
+-  struct abbrev_attr *first_attr;
+-  struct abbrev_attr *last_attr;
+-  struct abbrev_entry *next;
++  unsigned long          number;
++  unsigned long          tag;
++  int                    children;
++  struct abbrev_attr *   first_attr;
++  struct abbrev_attr *   last_attr;
++  struct abbrev_entry *  next;
+ }
+ abbrev_entry;
+ 
+-static abbrev_entry *first_abbrev = NULL;
+-static abbrev_entry *last_abbrev = NULL;
++/* Records a set of abbreviations.  */
++typedef struct abbrev_list
++{
++  abbrev_entry *        first_abbrev;
++  abbrev_entry *        last_abbrev;
++  dwarf_vma             abbrev_offset;
++  struct abbrev_list *  next;
++  unsigned char *       start_of_next_abbrevs;
++}
++abbrev_list;
++
++/* Records all the abbrevs found so far.  */
++static struct abbrev_list * abbrev_lists = NULL;
++
++typedef struct abbrev_map
++{
++  dwarf_vma      start;
++  dwarf_vma      end;
++  abbrev_list *  list;
++} abbrev_map;
++
++/* Maps between CU offsets and abbrev sets.  */
++static abbrev_map *   cu_abbrev_map = NULL;
++static unsigned long  num_abbrev_map_entries = 0;
++static unsigned long  next_free_abbrev_map_entry = 0;
++
++#define INITIAL_NUM_ABBREV_MAP_ENTRIES 8
++#define ABBREV_MAP_ENTRIES_INCREMENT   8
++
++static void
++record_abbrev_list_for_cu (dwarf_vma start, dwarf_vma end, abbrev_list * list)
++{
++  if (cu_abbrev_map == NULL)
++    {
++      num_abbrev_map_entries = INITIAL_NUM_ABBREV_MAP_ENTRIES;
++      cu_abbrev_map = xmalloc (num_abbrev_map_entries * sizeof (* cu_abbrev_map));
++    }
++  else if (next_free_abbrev_map_entry == num_abbrev_map_entries)
++    {
++      num_abbrev_map_entries += ABBREV_MAP_ENTRIES_INCREMENT;
++      cu_abbrev_map = xrealloc (cu_abbrev_map, num_abbrev_map_entries * sizeof (* cu_abbrev_map));
++    }
++
++  cu_abbrev_map[next_free_abbrev_map_entry].start = start;
++  cu_abbrev_map[next_free_abbrev_map_entry].end = end;
++  cu_abbrev_map[next_free_abbrev_map_entry].list = list;
++  next_free_abbrev_map_entry ++;
++}
+ 
+ static void
+-free_abbrevs (void)
++free_all_abbrevs (void)
+ {
+-  abbrev_entry *abbrv;
++  abbrev_list *  list;
+ 
+-  for (abbrv = first_abbrev; abbrv;)
++  for (list = abbrev_lists; list != NULL;)
+     {
+-      abbrev_entry *next_abbrev = abbrv->next;
+-      abbrev_attr *attr;
++      abbrev_list *   next = list->next;
++      abbrev_entry *  abbrv;
+ 
+-      for (attr = abbrv->first_attr; attr;)
++      for (abbrv = list->first_abbrev; abbrv != NULL;)
+ 	{
+-	  abbrev_attr *next_attr = attr->next;
++	  abbrev_entry *  next_abbrev = abbrv->next;
++	  abbrev_attr *   attr;
+ 
+-	  free (attr);
+-	  attr = next_attr;
++	  for (attr = abbrv->first_attr; attr;)
++	    {
++	      abbrev_attr *next_attr = attr->next;
++
++	      free (attr);
++	      attr = next_attr;
++	    }
++
++	  free (abbrv);
++	  abbrv = next_abbrev;
+ 	}
+ 
+-      free (abbrv);
+-      abbrv = next_abbrev;
++      free (list);
++      list = next;
+     }
+ 
+-  last_abbrev = first_abbrev = NULL;
++  abbrev_lists = NULL;
++}
++
++static abbrev_list *
++new_abbrev_list (dwarf_vma abbrev_offset)
++{
++  abbrev_list * list = (abbrev_list *) xcalloc (sizeof * list, 1);
++
++  list->abbrev_offset = abbrev_offset;
++
++  list->next = abbrev_lists;
++  abbrev_lists = list;
++
++  return list;
++}
++
++static abbrev_list *
++find_abbrev_list_by_abbrev_offset (dwarf_vma abbrev_offset)
++{
++  abbrev_list * list;
++
++  for (list = abbrev_lists; list != NULL; list = list->next)
++    if (list->abbrev_offset == abbrev_offset)
++      return list;
++
++  return NULL;
++}
++
++/* Find the abbreviation map for the CU that includes OFFSET.
++   OFFSET is an absolute offset from the start of the .debug_info section.  */
++/* FIXME: This function is going to slow down readelf & objdump.
++   Consider using a better algorithm to mitigate this effect.  */
++
++static  abbrev_map *
++find_abbrev_map_by_offset (dwarf_vma offset)
++{
++  unsigned long i;
++
++  for (i = 0; i < next_free_abbrev_map_entry; i++)
++    if (cu_abbrev_map[i].start <= offset
++	&& cu_abbrev_map[i].end > offset)
++      return cu_abbrev_map + i;
++
++  return NULL;	
+ }
+ 
+ static void
+-add_abbrev (unsigned long number, unsigned long tag, int children)
++add_abbrev (unsigned long  number,
++	    unsigned long  tag,
++	    int            children,
++	    abbrev_list *  list)
+ {
+-  abbrev_entry *entry;
++  abbrev_entry *  entry;
+ 
+-  entry = (abbrev_entry *) malloc (sizeof (*entry));
+-  if (entry == NULL)
+-    /* ugg */
+-    return;
++  entry = (abbrev_entry *) xmalloc (sizeof (*entry));
+ 
+-  entry->entry      = number;
++  entry->number     = number;
+   entry->tag        = tag;
+   entry->children   = children;
+   entry->first_attr = NULL;
+   entry->last_attr  = NULL;
+   entry->next       = NULL;
+ 
+-  if (first_abbrev == NULL)
+-    first_abbrev = entry;
++  assert (list != NULL);
++
++  if (list->first_abbrev == NULL)
++    list->first_abbrev = entry;
+   else
+-    last_abbrev->next = entry;
++    list->last_abbrev->next = entry;
+ 
+-  last_abbrev = entry;
++  list->last_abbrev = entry;
+ }
+ 
+ static void
+-add_abbrev_attr (unsigned long attribute, unsigned long form,
+-		 bfd_signed_vma implicit_const)
++add_abbrev_attr (unsigned long   attribute,
++		 unsigned long   form,
++		 bfd_signed_vma  implicit_const,
++		 abbrev_list *   list)
+ {
+   abbrev_attr *attr;
+ 
+-  attr = (abbrev_attr *) malloc (sizeof (*attr));
+-  if (attr == NULL)
+-    /* ugg */
+-    return;
++  attr = (abbrev_attr *) xmalloc (sizeof (*attr));
+ 
+   attr->attribute = attribute;
+   attr->form      = form;
+   attr->implicit_const = implicit_const;
+   attr->next      = NULL;
+ 
+-  if (last_abbrev->first_attr == NULL)
+-    last_abbrev->first_attr = attr;
++  assert (list != NULL && list->last_abbrev != NULL);
++
++  if (list->last_abbrev->first_attr == NULL)
++    list->last_abbrev->first_attr = attr;
+   else
+-    last_abbrev->last_attr->next = attr;
++    list->last_abbrev->last_attr->next = attr;
+ 
+-  last_abbrev->last_attr = attr;
++  list->last_abbrev->last_attr = attr;
+ }
+ 
+ /* Processes the (partial) contents of a .debug_abbrev section.
+@@ -952,11 +1055,10 @@ add_abbrev_attr (unsigned long attribute
+    an abbreviation set was found.  */
+ 
+ static unsigned char *
+-process_abbrev_section (unsigned char *start, unsigned char *end)
++process_abbrev_set (unsigned char *        start,
++		    const unsigned char *  end,
++		    abbrev_list *          list)
+ {
+-  if (first_abbrev != NULL)
+-    return NULL;
+-
+   while (start < end)
+     {
+       unsigned long entry;
+@@ -966,7 +1068,7 @@ process_abbrev_section (unsigned char *s
+ 
+       READ_ULEB (entry, start, end);
+ 
+-      /* A single zero is supposed to end the section according
++      /* A single zero is supposed to end the set according
+ 	 to the standard.  If there's more, then signal that to
+ 	 the caller.  */
+       if (start == end)
+@@ -980,7 +1082,7 @@ process_abbrev_section (unsigned char *s
+ 
+       children = *start++;
+ 
+-      add_abbrev (entry, tag, children);
++      add_abbrev (entry, tag, children, list);
+ 
+       do
+ 	{
+@@ -1003,7 +1105,7 @@ process_abbrev_section (unsigned char *s
+ 		break;
+ 	    }
+ 
+-	  add_abbrev_attr (attribute, form, implicit_const);
++	  add_abbrev_attr (attribute, form, implicit_const, list);
+ 	}
+       while (attribute != 0);
+     }
+@@ -1969,36 +2071,123 @@ skip_attr_bytes (unsigned long
+   return data;
+ }
+ 
+-/* Return IS_SIGNED set to TRUE if the type at
+-   DATA can be determined to be a signed type.  */
++/* Given form FORM with value UVALUE, locate and return the abbreviation
++   associated with it.  */
++
++static abbrev_entry *
++get_type_abbrev_from_form (unsigned long                 form,
++			   unsigned long                 uvalue,
++			   dwarf_vma                     cu_offset,
++			   const struct dwarf_section *  section,
++			   unsigned long *               abbrev_num_return,
++			   unsigned char **              data_return,
++			   unsigned long *               cu_offset_return)
++{
++  unsigned long   abbrev_number;
++  abbrev_map *    map;
++  abbrev_entry *  entry;
++  unsigned char * data;
++
++  if (abbrev_num_return != NULL)
++    * abbrev_num_return = 0;
++  if (data_return != NULL)
++    * data_return = NULL;
++
++  switch (form)
++    {
++    case DW_FORM_GNU_ref_alt:
++      /* FIXME: We are unable to handle this form at the moment.  */
++      return NULL;
++
++    case DW_FORM_ref_addr:
++      if (uvalue >= section->size)
++	{
++	  warn (_("Unable to resolve ref_addr form: uvalue %lx > section size %lx (%s)\n"),
++		uvalue, (long) section->size, section->name);
++	  return NULL;
++	}
++      break;
++
++    case DW_FORM_ref1:
++    case DW_FORM_ref2:
++    case DW_FORM_ref4:
++    case DW_FORM_ref_udata:
++      if (uvalue + cu_offset > section->size)
++	{
++	  warn (_("Unable to resolve ref form: uvalue %lx + cu_offset %lx > section size %lx\n"),
++		uvalue, (long) cu_offset, (long) section->size);
++	  return NULL;
++	}
++      uvalue += cu_offset;
++      break;
++
++      /* FIXME: Are there other DW_FORMs that can be used by types ?  */
++
++    default:
++      warn (_("Unexpected form %lx encountered whilst finding abbreviation for type\n"), form);
++      return NULL;
++    }
++
++  data = (unsigned char *) section->start + uvalue;
++  map = find_abbrev_map_by_offset (uvalue);
++  
++  if (map == NULL)
++    {
++      warn (_("Unable to find abbreviations for CU offset %#lx\n"), uvalue);
++      return NULL;
++    }
++  if (map->list == NULL)
++    {
++      warn (_("Empty abbreviation list encountered for CU offset %lx\n"), uvalue);
++      return NULL;
++    }
++
++  if (cu_offset_return != NULL)
++    {
++      if (form == DW_FORM_ref_addr)
++	* cu_offset_return = map->start;
++      else
++	* cu_offset_return = cu_offset;
++    }
++	
++  READ_ULEB (abbrev_number, data, section->start + section->size);
++
++  for (entry = map->list->first_abbrev; entry != NULL; entry = entry->next)
++    if (entry->number == abbrev_number)
++      break;
++  
++  if (abbrev_num_return != NULL)
++    * abbrev_num_return = abbrev_number;
++
++  if (data_return != NULL)
++    * data_return = data;
++
++  if (entry == NULL)
++    warn (_("Unable to find entry for abbreviation %lu\n"), abbrev_number);
++
++  return entry;
++}
++
++/* Return IS_SIGNED set to TRUE if the type using abbreviation ENTRY
++   can be determined to be a signed type.  The data for ENTRY can be
++   found starting at DATA.  */
+ 
+ static void
+-get_type_signedness (unsigned char *        start,
++get_type_signedness (abbrev_entry *         entry,
++		     const struct dwarf_section * section,
+ 		     unsigned char *        data,
+ 		     unsigned const char *  end,
++		     dwarf_vma              cu_offset,
+ 		     dwarf_vma              pointer_size,
+ 		     dwarf_vma              offset_size,
+ 		     int                    dwarf_version,
+ 		     bfd_boolean *          is_signed,
+ 		     unsigned int	    nesting)
+ {
+-  unsigned long   abbrev_number;
+-  abbrev_entry *  entry;
+   abbrev_attr *   attr;
+ 
+   * is_signed = FALSE;
+ 
+-  READ_ULEB (abbrev_number, data, end);
+-
+-  for (entry = first_abbrev;
+-       entry != NULL && entry->entry != abbrev_number;
+-       entry = entry->next)
+-    continue;
+-
+-  if (entry == NULL)
+-    /* FIXME: Issue a warning ?  */
+-    return;
+-
+ #define MAX_NESTING 20
+   if (nesting > MAX_NESTING)
+     {
+@@ -2011,6 +2200,7 @@ get_type_signedness (unsigned char *
+        attr != NULL && attr->attribute;
+        attr = attr->next)
+     {
++      unsigned char * orig_data = data;
+       dwarf_vma uvalue = 0;
+ 
+       data = skip_attr_bytes (attr->form, data, end, pointer_size,
+@@ -2020,21 +2210,38 @@ get_type_signedness (unsigned char *
+ 
+       switch (attr->attribute)
+ 	{
+-#if 0 /* FIXME: It would be nice to print the name of the type,
+-	 but this would mean updating a lot of binutils tests.  */
++	case DW_AT_linkage_name:
+ 	case DW_AT_name:
+-	  if (attr->form == DW_FORM_strp)
+-	    printf ("%s", fetch_indirect_string (uvalue));
++	  if (do_wide)
++	    {
++	      if (attr->form == DW_FORM_strp)
++		printf (", %s", fetch_indirect_string (uvalue));
++	      else if (attr->form == DW_FORM_string)
++		printf (", %s", orig_data);
++	    }
+ 	  break;
+-#endif
++
+ 	case DW_AT_type:
+ 	  /* Recurse.  */
+-	  if (uvalue >= (size_t) (end - start))
+-	    return;
+-	  /* We cannot correctly process DW_FORM_ref_addr at the moment.  */
+-	  if (attr->form != DW_FORM_ref_addr)
+-	    get_type_signedness (start, start + uvalue, end, pointer_size,
+-				 offset_size, dwarf_version, is_signed, nesting + 1);
++	  {
++	    abbrev_entry *  type_abbrev;
++	    unsigned char * type_data;
++	    unsigned long   type_cu_offset;
++
++	    type_abbrev = get_type_abbrev_from_form (attr->form,
++						     uvalue,
++						     cu_offset,
++						     section,
++						     NULL /* abbrev num return */,
++						     & type_data,
++						     & type_cu_offset);
++	    if (type_abbrev == NULL)
++	      break;
++
++	    get_type_signedness (type_abbrev, section, type_data, end, type_cu_offset,
++				 pointer_size, offset_size, dwarf_version,
++				 is_signed, nesting + 1);
++	  }
+ 	  break;
+ 
+ 	case DW_AT_encoding:
+@@ -2276,12 +2483,12 @@ read_and_display_attr_value (unsigned lo
+     {
+     case DW_FORM_ref_addr:
+       if (!do_loc)
+-	printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
++	printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x", uvalue));
+       break;
+ 
+     case DW_FORM_GNU_ref_alt:
+       if (!do_loc)
+-	printf ("%c<alt 0x%s>", delimiter, dwarf_vmatoa ("x",uvalue));
++	printf ("%c<alt 0x%s>", delimiter, dwarf_vmatoa ("x", uvalue));
+       /* FIXME: Follow the reference...  */
+       break;
+ 
+@@ -2667,11 +2874,18 @@ read_and_display_attr_value (unsigned lo
+ 	  && uvalue < (size_t) (end - start))
+ 	{
+ 	  bfd_boolean is_signed = FALSE;
+-
+-	  /* We cannot correctly process DW_FORM_ref_addr at the moment.  */
+-	  if (form != DW_FORM_ref_addr)
+-	    get_type_signedness (start, start + uvalue, end, pointer_size,
+-				 offset_size, dwarf_version, & is_signed, 0);
++	  abbrev_entry *  type_abbrev;
++	  unsigned char * type_data;
++	  unsigned long   type_cu_offset;
++	  
++	  type_abbrev = get_type_abbrev_from_form (form, uvalue, cu_offset,
++						   section, NULL, & type_data, & type_cu_offset);
++	  if (type_abbrev != NULL)
++	    {
++	      get_type_signedness (type_abbrev, section, type_data, end, type_cu_offset,
++				   pointer_size, offset_size, dwarf_version,
++				   & is_signed, 0);
++	    }
+ 	  level_type_signed[level] = is_signed;
+ 	}
+       break;
+@@ -2993,40 +3207,22 @@ read_and_display_attr_value (unsigned lo
+ 
+     case DW_AT_import:
+       {
+-	if (form == DW_FORM_ref_sig8
+-	    || form == DW_FORM_GNU_ref_alt)
+-	  break;
+-
+-	if (form == DW_FORM_ref1
+-	    || form == DW_FORM_ref2
+-	    || form == DW_FORM_ref4
+-	    || form == DW_FORM_ref_udata)
+-	  uvalue += cu_offset;
++	unsigned long abbrev_number;
++	abbrev_entry *entry;
+ 
+-	if (uvalue >= section->size)
+-	  warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
+-		dwarf_vmatoa ("x", uvalue),
+-		(unsigned long) (orig_data - section->start));
++	entry = get_type_abbrev_from_form (form, uvalue, cu_offset,
++					   section, & abbrev_number, NULL, NULL);
++	if (entry == NULL)
++	  {
++	    if (form != DW_FORM_GNU_ref_alt)
++	      warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"),
++		    dwarf_vmatoa ("x", uvalue),
++		    (unsigned long) (orig_data - section->start));
++	  }
+ 	else
+ 	  {
+-	    unsigned long abbrev_number;
+-	    abbrev_entry *entry;
+-	    unsigned char *p = section->start + uvalue;
+-
+-	    READ_ULEB (abbrev_number, p, end);
+-
+ 	    printf (_("\t[Abbrev Number: %ld"), abbrev_number);
+-	    /* Don't look up abbrev for DW_FORM_ref_addr, as it very often will
+-	       use different abbrev table, and we don't track .debug_info chunks
+-	       yet.  */
+-	    if (form != DW_FORM_ref_addr)
+-	      {
+-		for (entry = first_abbrev; entry != NULL; entry = entry->next)
+-		  if (entry->entry == abbrev_number)
+-		    break;
+-		if (entry != NULL)
+-		  printf (" (%s)", get_TAG_name (entry->tag));
+-	      }
++	    printf (" (%s)", get_TAG_name (entry->tag));
+ 	    printf ("]");
+ 	  }
+       }
+@@ -3245,8 +3441,98 @@ process_debug_info (struct dwarf_section
+ 
+   if (!do_loc && dwarf_start_die == 0)
+     introduce (section, FALSE);
++
++  free_all_abbrevs ();
++  free (cu_abbrev_map);
++  cu_abbrev_map = NULL;
++  next_free_abbrev_map_entry = 0;
+   
+-  for (section_begin = start, unit = 0; start < end; unit++)
++  /* In order to be able to resolve DW_FORM_ref_attr forms we need
++     to load *all* of the abbrevs for all CUs in this .debug_info
++     section.  This does effectively mean that we (partially) read
++     every CU header twice.  */
++  for (section_begin = start; start < end;)
++    {
++      DWARF2_Internal_CompUnit  compunit;
++      unsigned char *           hdrptr;
++      dwarf_vma                 cu_offset;
++      unsigned int              offset_size;
++      unsigned int              initial_length_size;
++      struct cu_tu_set *        this_set;
++      abbrev_list *             list;
++
++      hdrptr = start;
++
++      SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 4, end);
++
++      if (compunit.cu_length == 0xffffffff)
++	{
++	  SAFE_BYTE_GET_AND_INC (compunit.cu_length, hdrptr, 8, end);
++	  offset_size = 8;
++	  initial_length_size = 12;
++	}
++      else
++	{
++	  offset_size = 4;
++	  initial_length_size = 4;
++	}
++
++      SAFE_BYTE_GET_AND_INC (compunit.cu_version, hdrptr, 2, end);
++
++      cu_offset = start - section_begin;
++
++      this_set = find_cu_tu_set_v2 (cu_offset, do_types);
++
++      if (compunit.cu_version < 5)
++	{
++	  compunit.cu_unit_type = DW_UT_compile;
++	  /* Initialize it due to a false compiler warning.  */
++	  compunit.cu_pointer_size = -1;
++	}
++      else
++	{
++	  SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end);
++	  do_types = (compunit.cu_unit_type == DW_UT_type);
++
++	  SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
++	}
++
++      SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end);
++
++      list = find_abbrev_list_by_abbrev_offset (compunit.cu_abbrev_offset);
++      if (list == NULL)
++	{
++	  dwarf_vma        abbrev_base;
++	  size_t           abbrev_size;
++	  unsigned char *  next;
++
++	  if (this_set == NULL)
++	    {
++	      abbrev_base = 0;
++	      abbrev_size = debug_displays [abbrev_sec].section.size;
++	    }
++	  else
++	    {
++	      abbrev_base = this_set->section_offsets [DW_SECT_ABBREV];
++	      abbrev_size = this_set->section_sizes [DW_SECT_ABBREV];
++	    }
++
++	  list = new_abbrev_list (compunit.cu_abbrev_offset);
++	  next = process_abbrev_set
++	    (((unsigned char *) debug_displays [abbrev_sec].section.start
++	      + abbrev_base + compunit.cu_abbrev_offset),
++	     ((unsigned char *) debug_displays [abbrev_sec].section.start
++	      + abbrev_base + abbrev_size),
++	     list);
++	  list->start_of_next_abbrevs = next;
++	}
++		       
++      start = section_begin + cu_offset + compunit.cu_length
++	+ initial_length_size;
++      record_abbrev_list_for_cu (cu_offset, start - section_begin, list);
++    }
++
++  for (start = section_begin, unit = 0; start < end; unit++)
+     {
+       DWARF2_Internal_CompUnit compunit;
+       unsigned char *hdrptr;
+@@ -3262,6 +3548,7 @@ process_debug_info (struct dwarf_section
+       struct cu_tu_set *this_set;
+       dwarf_vma abbrev_base;
+       size_t abbrev_size;
++      abbrev_list * list = NULL;
+ 
+       hdrptr = start;
+ 
+@@ -3434,8 +3721,6 @@ process_debug_info (struct dwarf_section
+ 	  continue;
+ 	}
+ 
+-      free_abbrevs ();
+-
+       /* Process the abbrevs used by this compilation unit.  */
+       if (compunit.cu_abbrev_offset >= abbrev_size)
+ 	warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"),
+@@ -3448,11 +3733,22 @@ process_debug_info (struct dwarf_section
+ 	      (unsigned long) abbrev_base + abbrev_size,
+ 	      (unsigned long) debug_displays [abbrev_sec].section.size);
+       else
+-	process_abbrev_section
+-	  (((unsigned char *) debug_displays [abbrev_sec].section.start
+-	    + abbrev_base + compunit.cu_abbrev_offset),
+-	   ((unsigned char *) debug_displays [abbrev_sec].section.start
+-	    + abbrev_base + abbrev_size));
++	{
++	  list = find_abbrev_list_by_abbrev_offset (compunit.cu_abbrev_offset);
++	  if (list == NULL)
++	    {
++	      unsigned char * next;
++
++	      list = new_abbrev_list (compunit.cu_abbrev_offset);
++	      next = process_abbrev_set
++		(((unsigned char *) debug_displays [abbrev_sec].section.start
++		  + abbrev_base + compunit.cu_abbrev_offset),
++		 ((unsigned char *) debug_displays [abbrev_sec].section.start
++		  + abbrev_base + abbrev_size),
++		 list);
++	      list->start_of_next_abbrevs = next;
++	    }
++	}
+ 
+       level = 0;
+       last_level = level;
+@@ -3532,11 +3828,13 @@ process_debug_info (struct dwarf_section
+ 
+ 	  /* Scan through the abbreviation list until we reach the
+ 	     correct entry.  */
+-	  for (entry = first_abbrev;
+-	       entry && entry->entry != abbrev_number;
+-	       entry = entry->next)
++	  if (list == NULL)
+ 	    continue;
+ 
++	  for (entry = list->first_abbrev; entry != NULL; entry = entry->next)
++	    if (entry->number == abbrev_number)
++	      break;
++
+ 	  if (entry == NULL)
+ 	    {
+ 	      if (!do_loc && do_printing)
+@@ -5721,30 +6019,37 @@ display_debug_abbrev (struct dwarf_secti
+ {
+   abbrev_entry *entry;
+   unsigned char *start = section->start;
+-  unsigned char *end = start + section->size;
++  const unsigned char *end = start + section->size;
+ 
+   introduce (section, FALSE);
+ 
+   do
+     {
+-      unsigned char *last;
+-
+-      free_abbrevs ();
++      abbrev_list *    list;
++      dwarf_vma        offset;
+ 
+-      last = start;
+-      start = process_abbrev_section (start, end);
++      offset = start - section->start;
++      list = find_abbrev_list_by_abbrev_offset (offset);
++      if (list == NULL)
++	{
++	  list = new_abbrev_list (offset);
++	  start = process_abbrev_set (start, end, list);
++	  list->start_of_next_abbrevs = start;
++	}
++      else
++	start = list->start_of_next_abbrevs;
+ 
+-      if (first_abbrev == NULL)
++      if (list->first_abbrev == NULL)
+ 	continue;
+ 
+-      printf (_("  Number TAG (0x%lx)\n"), (long) (last - section->start));
++      printf (_("  Number TAG (0x%lx)\n"), (long) offset);
+ 
+-      for (entry = first_abbrev; entry; entry = entry->next)
++      for (entry = list->first_abbrev; entry; entry = entry->next)
+ 	{
+ 	  abbrev_attr *attr;
+ 
+ 	  printf ("   %ld      %s    [%s]\n",
+-		  entry->entry,
++		  entry->number,
+ 		  get_TAG_name (entry->tag),
+ 		  entry->children ? _("has children") : _("no children"));
+ 
+@@ -10776,8 +11081,12 @@ free_debug_memory (void)
+ {
+   unsigned int i;
+ 
+-  free_abbrevs ();
++  free_all_abbrevs ();
+ 
++  free (cu_abbrev_map);
++  cu_abbrev_map = NULL;
++  next_free_abbrev_map_entry = 0;
++  
+   for (i = 0; i < max; i++)
+     free_debug_section ((enum dwarf_section_display_enum) i);
+ 
+Only in binutils-2.35.1/binutils: dwarf.c.orig

binutils-plugin-as-needed.patch

@@ -0,0 +1,182 @@
+--- binutils.orig/bfd/elflink.c	2020-11-03 11:59:59.966565009 +0000
++++ binutils-2.35.1/bfd/elflink.c	2020-11-03 12:07:34.691991602 +0000
+@@ -4477,7 +4477,12 @@ elf_link_add_object_symbols (bfd *abfd,
+ 	      h = (struct elf_link_hash_entry *) p;
+ 	      entsize += htab->root.table.entsize;
+ 	      if (h->root.type == bfd_link_hash_warning)
+-		entsize += htab->root.table.entsize;
++		{
++		  entsize += htab->root.table.entsize;
++		  h = (struct elf_link_hash_entry *) h->root.u.i.link;
++		}
++	      if (h->root.type == bfd_link_hash_common)
++		entsize += sizeof (*h->root.u.c.p);
+ 	    }
+ 	}
+ 
+@@ -4521,14 +4526,20 @@ elf_link_add_object_symbols (bfd *abfd,
+ 
+ 	  for (p = htab->root.table.table[i]; p != NULL; p = p->next)
+ 	    {
+-	      memcpy (old_ent, p, htab->root.table.entsize);
+-	      old_ent = (char *) old_ent + htab->root.table.entsize;
+ 	      h = (struct elf_link_hash_entry *) p;
++	      memcpy (old_ent, h, htab->root.table.entsize);
++	      old_ent = (char *) old_ent + htab->root.table.entsize;
+ 	      if (h->root.type == bfd_link_hash_warning)
+ 		{
+-		  memcpy (old_ent, h->root.u.i.link, htab->root.table.entsize);
++		  h = (struct elf_link_hash_entry *) h->root.u.i.link;
++		  memcpy (old_ent, h, htab->root.table.entsize);
+ 		  old_ent = (char *) old_ent + htab->root.table.entsize;
+ 		}
++	      if (h->root.type == bfd_link_hash_common)
++		{
++		  memcpy (old_ent, h->root.u.c.p, sizeof (*h->root.u.c.p));
++		  old_ent = (char *) old_ent + sizeof (*h->root.u.c.p);
++		}
+ 	    }
+ 	}
+     }
+@@ -4899,7 +4910,8 @@ elf_link_add_object_symbols (bfd *abfd,
+ 	}
+ 
+       if (! (_bfd_generic_link_add_one_symbol
+-	     (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
++	     (info, abfd, name, flags, sec, value,
++	      NULL, FALSE, bed->collect,
+ 	      (struct bfd_link_hash_entry **) sym_hash)))
+ 	goto error_free_vers;
+ 
+@@ -4970,11 +4982,10 @@ elf_link_add_object_symbols (bfd *abfd,
+ 	     object and a shared object.  */
+ 	  bfd_boolean dynsym = FALSE;
+ 
+-	  /* Plugin symbols aren't normal.  Don't set def_regular or
+-	     ref_regular for them, or make them dynamic.  */
++	  /* Plugin symbols aren't normal.  Don't set def/ref flags.  */
+ 	  if ((abfd->flags & BFD_PLUGIN) != 0)
+ 	    ;
+-	  else if (! dynamic)
++	  else if (!dynamic)
+ 	    {
+ 	      if (! definition)
+ 		{
+@@ -4991,14 +5002,6 @@ elf_link_add_object_symbols (bfd *abfd,
+ 		      h->ref_dynamic = 1;
+ 		    }
+ 		}
+-
+-	      /* If the indirect symbol has been forced local, don't
+-		 make the real symbol dynamic.  */
+-	      if ((h == hi || !hi->forced_local)
+-		  && (bfd_link_dll (info)
+-		      || h->def_dynamic
+-		      || h->ref_dynamic))
+-		dynsym = TRUE;
+ 	    }
+ 	  else
+ 	    {
+@@ -5012,14 +5015,25 @@ elf_link_add_object_symbols (bfd *abfd,
+ 		  h->def_dynamic = 1;
+ 		  hi->def_dynamic = 1;
+ 		}
++	    }
+ 
+-	      /* If the indirect symbol has been forced local, don't
+-		 make the real symbol dynamic.  */
+-	      if ((h == hi || !hi->forced_local)
+-		  && (h->def_regular
+-		      || h->ref_regular
+-		      || (h->is_weakalias
+-			  && weakdef (h)->dynindx != -1)))
++	  /* If an indirect symbol has been forced local, don't
++	     make the real symbol dynamic.  */
++	  if (h != hi && hi->forced_local)
++	    ;
++	  else if (!dynamic)
++	    {
++	      if (bfd_link_dll (info)
++		  || h->def_dynamic
++		  || h->ref_dynamic)
++		dynsym = TRUE;
++	    }
++	  else
++	    {
++	      if (h->def_regular
++		  || h->ref_regular
++		  || (h->is_weakalias
++		      && weakdef (h)->dynindx != -1))
+ 		dynsym = TRUE;
+ 	    }
+ 
+@@ -5214,6 +5228,9 @@ elf_link_add_object_symbols (bfd *abfd,
+ 	      && definition
+ 	      && ((dynsym
+ 		   && h->ref_regular_nonweak)
++		  || (old_bfd != NULL
++		      && (old_bfd->flags & BFD_PLUGIN) != 0
++		      && bind != STB_WEAK)
+ 		  || (h->ref_dynamic_nonweak
+ 		      && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0
+ 		      && !on_needed_list (elf_dt_name (abfd),
+@@ -5338,49 +5355,31 @@ elf_link_add_object_symbols (bfd *abfd,
+ 	{
+ 	  struct bfd_hash_entry *p;
+ 	  struct elf_link_hash_entry *h;
+-	  bfd_size_type size;
+-	  unsigned int alignment_power;
+ 	  unsigned int non_ir_ref_dynamic;
+ 
+ 	  for (p = htab->root.table.table[i]; p != NULL; p = p->next)
+ 	    {
+-	      h = (struct elf_link_hash_entry *) p;
+-	      if (h->root.type == bfd_link_hash_warning)
+-		h = (struct elf_link_hash_entry *) h->root.u.i.link;
+-
+-	      /* Preserve the maximum alignment and size for common
+-		 symbols even if this dynamic lib isn't on DT_NEEDED
+-		 since it can still be loaded at run time by another
+-		 dynamic lib.  */
+-	      if (h->root.type == bfd_link_hash_common)
+-		{
+-		  size = h->root.u.c.size;
+-		  alignment_power = h->root.u.c.p->alignment_power;
+-		}
+-	      else
+-		{
+-		  size = 0;
+-		  alignment_power = 0;
+-		}
+ 	      /* Preserve non_ir_ref_dynamic so that this symbol
+ 		 will be exported when the dynamic lib becomes needed
+ 		 in the second pass.  */
++	      h = (struct elf_link_hash_entry *) p;
++	      if (h->root.type == bfd_link_hash_warning)
++		h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ 	      non_ir_ref_dynamic = h->root.non_ir_ref_dynamic;
+-	      memcpy (p, old_ent, htab->root.table.entsize);
+-	      old_ent = (char *) old_ent + htab->root.table.entsize;
++
+ 	      h = (struct elf_link_hash_entry *) p;
++	      memcpy (h, old_ent, htab->root.table.entsize);
++	      old_ent = (char *) old_ent + htab->root.table.entsize;
+ 	      if (h->root.type == bfd_link_hash_warning)
+ 		{
+-		  memcpy (h->root.u.i.link, old_ent, htab->root.table.entsize);
+-		  old_ent = (char *) old_ent + htab->root.table.entsize;
+ 		  h = (struct elf_link_hash_entry *) h->root.u.i.link;
++		  memcpy (h, old_ent, htab->root.table.entsize);
++		  old_ent = (char *) old_ent + htab->root.table.entsize;
+ 		}
+ 	      if (h->root.type == bfd_link_hash_common)
+ 		{
+-		  if (size > h->root.u.c.size)
+-		    h->root.u.c.size = size;
+-		  if (alignment_power > h->root.u.c.p->alignment_power)
+-		    h->root.u.c.p->alignment_power = alignment_power;
++		  memcpy (h->root.u.c.p, old_ent, sizeof (*h->root.u.c.p));
++		  old_ent = (char *) old_ent + sizeof (*h->root.u.c.p);
+ 		}
+ 	      h->root.non_ir_ref_dynamic = non_ir_ref_dynamic;
+ 	    }

binutils-recursive-debuglink-following.patch

@@ -0,0 +1,109 @@
+--- binutils.orig/binutils/dwarf.c	2020-10-15 12:13:21.960799738 +0100
++++ binutils-2.35.1/binutils/dwarf.c	2020-10-15 13:02:39.454692627 +0100
+@@ -10427,7 +10427,7 @@ load_separate_debug_info (const char *
+     {
+       warn (_("Corrupt debuglink section: %s\n"),
+ 	    xlink->name ? xlink->name : xlink->uncompressed_name);
+-      return FALSE;
++      return NULL;
+     }
+     
+   /* Attempt to locate the separate file.
+@@ -10587,7 +10587,7 @@ load_separate_debug_info (const char *
+     {
+       warn (_("failed to open separate debug file: %s\n"), debug_filename);
+       free (debug_filename);
+-      return FALSE;
++      return NULL;
+     }
+ 
+   /* FIXME: We do not check to see if there are any other separate debug info
+@@ -10632,6 +10632,52 @@ load_dwo_file (const char * main_filenam
+   return separate_handle;
+ }
+ 
++/* Load a debuglink section and/or a debugaltlink section, if either are present.
++   Recursively check the loaded files for more of these sections.
++   FIXME: Should also check for DWO_* entries in the newlu loaded files.  */
++
++static void
++check_for_and_load_links (void * file, const char * filename)
++{
++  void * handle = NULL;
++
++  if (load_debug_section (gnu_debugaltlink, file))
++    {
++      Build_id_data build_id_data;
++
++      handle = load_separate_debug_info (filename,
++					 & debug_displays[gnu_debugaltlink].section,
++					 parse_gnu_debugaltlink,
++					 check_gnu_debugaltlink,
++					 & build_id_data,
++					 file);
++      if (handle)
++	{
++	  assert (handle == first_separate_info->handle);
++	  check_for_and_load_links (first_separate_info->handle,
++				    first_separate_info->filename);
++	}
++    }
++
++  if (load_debug_section (gnu_debuglink, file))
++    {
++      unsigned long crc32;
++
++      handle = load_separate_debug_info (filename,
++					 & debug_displays[gnu_debuglink].section,
++					 parse_gnu_debuglink,
++					 check_gnu_debuglink,
++					 & crc32,
++					 file);
++      if (handle)
++	{
++	  assert (handle == first_separate_info->handle);
++	  check_for_and_load_links (first_separate_info->handle,
++				    first_separate_info->filename);
++	}
++    }
++}
++
+ /* Load the separate debug info file(s) attached to FILE, if any exist.
+    Returns TRUE if any were found, FALSE otherwise.
+    If TRUE is returned then the linked list starting at first_separate_info
+@@ -10707,34 +10753,10 @@ load_separate_debug_files (void * file,
+     return FALSE;
+ 
+   /* FIXME: We do not check for the presence of both link sections in the same file.  */
+-  /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks.  */
+   /* FIXME: We do not check for the presence of multiple, same-name debuglink sections.  */
+   /* FIXME: We do not check for the presence of a dwo link as well as a debuglink.  */
+ 
+-  if (load_debug_section (gnu_debugaltlink, file))
+-    {
+-      Build_id_data * build_id_data;
+-
+-      load_separate_debug_info (filename,
+-				& debug_displays[gnu_debugaltlink].section,
+-				parse_gnu_debugaltlink,
+-				check_gnu_debugaltlink,
+-				& build_id_data,
+-				file);
+-    }
+-
+-  if (load_debug_section (gnu_debuglink, file))
+-    {
+-      unsigned long crc32;
+-
+-      load_separate_debug_info (filename,
+-				& debug_displays[gnu_debuglink].section,
+-				parse_gnu_debuglink,
+-				check_gnu_debuglink,
+-				& crc32,
+-				file);
+-    }
+-
++  check_for_and_load_links (file, filename);
+   if (first_separate_info != NULL)
+     return TRUE;
+ 

binutils.spec

@@ -2,7 +2,7 @@
 Summary: A GNU collection of binary utilities
 Name: %{?cross}binutils%{?_with_debug:-debug}
 Version: 2.35.1
-Release: 4%{?dist}
+Release: 13%{?dist}
 License: GPLv3+
 URL: https://sourceware.org/binutils
 
@@ -77,6 +77,9 @@ URL: https://sourceware.org/binutils
 # Default: support debuginfod.
 %bcond_without debuginfod
 
+# Use the system supplied version of the zlib compress library.
+# Change this to use the binutils builtin version instead.
+%bcond_without systemzlib
 
 %if %{with bootstrap}
 %undefine with_docs
@@ -186,65 +189,79 @@ Patch10: binutils-attach-to-group.patch
 
 # Purpose:  Allow OS specific sections in section groups.
 # Lifetime: Fixed in 2.36 (maybe)
-Patch12: binutils-special-sections-in-groups.patch
+Patch11: binutils-special-sections-in-groups.patch
 
 # Purpose:  Fix linker testsuite failures.
 # Lifetime: Fixed in 2.36 (maybe)
-Patch13: binutils-fix-testsuite-failures.patch
+Patch12: binutils-fix-testsuite-failures.patch
 
 # Purpose:  Stop gold from aborting when input sections with the same name
 #            have different flags.
 # Lifetime: Fixed in 2.36 (maybe)
-Patch14: binutils-gold-mismatched-section-flags.patch
+Patch13: binutils-gold-mismatched-section-flags.patch
 
 # Purpose:  Add a check to the GOLD linker for a corrupt input file
 #            with a fuzzed section offset.
 # Lifetime: Fixed in 2.36 (maybe)
-Patch15: binutils-CVE-2019-1010204.patch
+Patch14: binutils-CVE-2019-1010204.patch
 
 # Purpose:  Change the gold configuration script to only warn about
 #            unsupported targets.  This allows the binutils to be built with
 #            BPF support enabled.
 # Lifetime: Permanent.
-Patch17: binutils-gold-warn-unsupported.patch
+Patch15: binutils-gold-warn-unsupported.patch
 
 # Purpose:  Fix compile time warning messages building s390 target with gcc-10.
 # Lifetime: Should be fixed in 2.36.
-Patch19: binutils-s390-build.patch
+Patch16: binutils-s390-build.patch
 
 # Purpose:  Fix LTO problems running config mini-builds.
 # Lifetime: Should be fixed in 2.36.
-Patch20: binutils-config.patch
+Patch17: binutils-config.patch
 
 # Purpose:  Fix compile time warning messages building with gcc-10.
 # Lifetime: Should be fixed in 2.36.
-Patch21: binutils-warnings.patch
+Patch18: binutils-warnings.patch
 
 # Purpose:  Fix compile time warning messages building with gcc-10. (part 2).
 # Lifetime: Should be fixed in 2.36.
-Patch22: binutils-gcc-10-fixes.patch
+Patch19: binutils-gcc-10-fixes.patch
 
 # Purpose:  Fixes for linking LTO objects.
 # Lifetime: Fixed in 2.36
-Patch23: binutils-add-sym-cache-to-elf-link-hash.patch
-Patch24: binutils-elf-add-objects.patch
+Patch20: binutils-add-sym-cache-to-elf-link-hash.patch
+Patch21: binutils-elf-add-objects.patch
 
 # Purpose:  Fix handling of relocations for AArch64 conditional branches.
 # Lifetime: Fixed in 2.36
-Patch25: binutils-aarch64-condbranch-relocs.patch
+Patch22: binutils-aarch64-condbranch-relocs.patch
 
 # Purpose:  Fix the PowerPC disassembler so that it ignores annobin symbols.
 # Lifetime: Fixed in 2.36
-Patch26: binutils-ppc-annobin-disassembly.patch
+Patch23: binutils-ppc-annobin-disassembly.patch
 
 # Purpose:  Fix the strip program to cope when merging multiple same-named
 #            sections.
 # Lifetime: Fixed in 2.36
-Patch27: binutils-strip-merge.patch
+Patch24: binutils-strip-merge.patch
 
 # Purpose:  Fix various problems with the PowerPC arch10 extensions.
 # Lifetime: Fixed in 2.36
-Patch28: binutils-Power10-fixes.patch
+Patch25: binutils-Power10-fixes.patch
+
+# Purpose:  Allow plugin syms to mark as-needed shared libs needed.
+# Lifetime: Fixed in 2.36
+Patch26: binutils-plugin-as-needed.patch
+
+# Purpose:  Recursively follow .gnu_debuglink and .gnu_debugaltlink sections.
+# Lifetime: Fixed in 2.36
+Patch27: binutils-recursive-debuglink-following.patch
+
+# Purpose:  Fix the DWARF parser to skip DW_FORM_ref_addr types
+#            when attempting to determine a type's signedness.
+# Lifetime: Fixed in 2.36
+Patch28: binutils-dwarf-type-sign.patch
+Patch29: binutils-dwarf-type-sign-2.patch
 
 #----------------------------------------------------------------------------
 
@@ -424,83 +441,6 @@ touch */configure
 %define _target_platform %{_arch}-%{_vendor}-%{_host_os}
 %endif
 
-#----------------------------------------------------------------------------
-
-%build
-echo target is %{binutils_target}
-
-%ifarch %{power64}
-export CFLAGS="$RPM_OPT_FLAGS -Wno-error"
-%else
-export CFLAGS="$RPM_OPT_FLAGS"
-%endif
-
-CARGS=
-
-%if %{with debuginfod}
-CARGS="$CARGS --with-debuginfod"
-%endif
-
-case %{binutils_target} in i?86*|sparc*|ppc*|s390*|sh*|arm*|aarch64*|riscv*)
-  CARGS="$CARGS --enable-64-bit-bfd"
-  ;;
-esac
-
-# Extra targets to build along with the default one.
-# We add the BPF target so that strip will work on bpf files.
-
-case %{binutils_target} in ia64*)
-  CARGS="$CARGS --enable-targets=ia64-linux,bpf-unknown-none"
-  ;;
-esac
-
-case %{binutils_target} in ppc*|ppc64*)
-  CARGS="$CARGS --enable-targets=spu,bpf-unknown-none"
-  ;;
-esac
-
-case %{binutils_target} in ppc64-*)
-  CARGS="$CARGS --enable-targets=powerpc64le-linux,bpf-unknown-none"
-  ;;
-esac
-
-case %{binutils_target} in ppc64le*)
-    CARGS="$CARGS --enable-targets=powerpc-linux,bpf-unknown-none"
-    ;;
-esac
-
-case %{binutils_target} in s390*)
-    # FIXME: For some unknown reason settting --enable-targets=bpf-unknown-none
-    # here breaks the building of GOLD.  I have no idea why, and not enough
-    # knowledge of how gold is configured to fix quickly.  So instead I have
-    # found that supporting "all" targets works.
-    CARGS="$CARGS --enable-targets=all"
-    ;;
-esac
-
-case %{binutils_target} in x86_64*|i?86*|arm*|aarch64*|riscv*)
-  CARGS="$CARGS --enable-targets=x86_64-pep,bpf-unknown-none"
-  ;;
-esac
-
-%if %{default_relro}
-  CARGS="$CARGS --enable-relro=yes"
-%else
-  CARGS="$CARGS --enable-relro=no"
-%endif
-
-%if %{with debug}
-export CFLAGS="$CFLAGS -O0 -ggdb2 -Wno-error -D_FORTIFY_SOURCE=0"
-%define enable_shared 0
-%endif
-
-# BZ 1541027 - include the linker flags from redhat-rpm-config as well.
-export LDFLAGS=$RPM_LD_FLAGS
-
-%if %{with clang}
-%define _with_cc_clang 1
-%endif
-
 # Dependencies are not set up to rebuild the configure files
 # in the subdirectories.  So we just rebuild the ones we care
 # about after applying the configure patches
@@ -511,173 +451,274 @@ pushd intl
 autoconf
 popd
 
+#----------------------------------------------------------------------------
 
-# We could optimize the cross builds size by --enable-shared but the produced
-# binaries may be less convenient in the embedded environment.
-%configure \
-  --quiet \
-  --build=%{_target_platform} --host=%{_target_platform} \
-  --target=%{binutils_target} \
-%if %{with gold}
-  --enable-gold=default \
-%endif
-  --enable-ld \
-%if %{isnative}
-  --with-sysroot=/ \
-%else
-  --enable-targets=%{_host} \
-  --with-sysroot=%{_prefix}/%{binutils_target}/sys-root \
-  --program-prefix=%{cross} \
-%endif
-%if %{enable_shared}
-  --enable-shared \
-%else
-  --disable-shared \
-%endif
-%if %{enable_deterministic_archives}
-  --enable-deterministic-archives \
-%else
-  --enable-deterministic-archives=no \
-%endif
-%if %{enable_lto}
-  --enable-lto \
-%endif
-%if %{default_compress_debug}
-  --enable-compressed-debug-sections=all \
-%else
-  --enable-compressed-debug-sections=none \
-%endif
-%if %{default_generate_notes}
-  --enable-generate-build-notes=yes \
-%else
-  --enable-generate-build-notes=no \
-%endif
-%if %{enable_threading}
-  --enable-threads=yes \
-%else
-  --enable-threads=no \
-%endif
-  $CARGS \
-  --enable-plugins \
-  --with-bugurl=http://bugzilla.redhat.com/bugzilla/ \
-  || cat config.log
+# We build in a subdirectory, so redefine _configure so that we find it
+%global _configure ../configure
 
-%if %{with docs}
-%make_build %{_smp_mflags} tooldir=%{_prefix} all
-%make_build %{_smp_mflags} tooldir=%{_prefix} info
-%else
-%make_build %{_smp_mflags} tooldir=%{_prefix} MAKEINFO=true all
-%endif
+%build
+function configure_binutils () {
+    binutils_target=$1
 
-# Do not use %%check as it is run after %%install where libbfd.so is rebuilt
-# with -fvisibility=hidden no longer being usable in its shared form.
-%if %{without testsuite}
-echo ====================TESTSUITE DISABLED=========================
-%else
-make -k check < /dev/null || :
-echo ====================TESTING=========================
-cat {gas/testsuite/gas,ld/ld,binutils/binutils}.sum
-%if %{with gold}
-if [ -f gold/test-suite.log ]; then
-    cat gold/test-suite.log
-fi
-if [ -f gold/testsuite/test-suite.log ]; then
-    cat gold/testsuite/*.log
-fi
-%endif
-echo ====================TESTING END=====================
-for file in {gas/testsuite/gas,ld/ld,binutils/binutils}.{sum,log}
-do
-  ln $file binutils-%{_target_platform}-$(basename $file) || :
-done
-tar cjf binutils-%{_target_platform}.tar.xz  binutils-%{_target_platform}-*.{sum,log}
-uuencode binutils-%{_target_platform}.tar.xz binutils-%{_target_platform}.tar.xz
-rm -f binutils-%{_target_platform}.tar.xz    binutils-%{_target_platform}-*.{sum,log}
-%if %{with gold}
-if [ -f gold/testsuite/test-suite.log ]; then
-  tar cjf  binutils-%{_target_platform}-gold.log.tar.xz gold/testsuite/*.log
-  uuencode binutils-%{_target_platform}-gold.log.tar.xz binutils-%{_target_platform}-gold.log.tar.xz
-  rm -f    binutils-%{_target_platform}-gold.log.tar.xz
-fi
-%endif
-%endif
+    echo target is $binutils_target
+
+    %ifarch %{power64}
+    export CFLAGS="$RPM_OPT_FLAGS -Wno-error"
+    %else
+    export CFLAGS="$RPM_OPT_FLAGS"
+    %endif
+
+    CARGS=
+
+    %if %{with debuginfod}
+    CARGS="$CARGS --with-debuginfod"
+    %endif
+
+    case $binutils_target in i?86*|sparc*|ppc*|s390*|sh*|arm*|aarch64*|riscv*)
+      CARGS="$CARGS --enable-64-bit-bfd"
+      ;;
+    esac
+
+    # Extra targets to build along with the default one.
+    # We add the BPF target so that strip will work on bpf files.
+
+    case $binutils_target in ia64*)
+      CARGS="$CARGS --enable-targets=ia64-linux,bpf-unknown-none"
+      ;;
+    esac
+
+    case $binutils_target in ppc*|ppc64*)
+      CARGS="$CARGS --enable-targets=spu,bpf-unknown-none"
+      ;;
+    esac
+
+    case $binutils_target in ppc64-*)
+      CARGS="$CARGS --enable-targets=powerpc64le-linux,bpf-unknown-none"
+      ;;
+    esac
+
+    case $binutils_target in ppc64le*)
+        CARGS="$CARGS --enable-targets=powerpc-linux,bpf-unknown-none"
+        ;;
+    esac
+
+    case $binutils_target in s390*)
+        # FIXME: For some unknown reason settting --enable-targets=bpf-unknown-none
+        # here breaks the building of GOLD.  I have no idea why, and not enough
+        # knowledge of how gold is configured to fix quickly.  So instead I have
+        # found that supporting "all" targets works.
+        CARGS="$CARGS --enable-targets=all"
+        ;;
+    esac
+
+    case $binutils_target in x86_64*|i?86*|arm*|aarch64*|riscv*)
+      CARGS="$CARGS --enable-targets=x86_64-pep,bpf-unknown-none"
+      ;;
+    esac
+
+    %if %{default_relro}
+      CARGS="$CARGS --enable-relro=yes"
+    %else
+      CARGS="$CARGS --enable-relro=no"
+    %endif
+
+    %if %{with debug}
+    export CFLAGS="$CFLAGS -O0 -ggdb2 -Wno-error -D_FORTIFY_SOURCE=0"
+    %define enable_shared 0
+    %endif
+
+    # BZ 1541027 - include the linker flags from redhat-rpm-config as well.
+    export LDFLAGS=$RPM_LD_FLAGS
+
+    %if %{with clang}
+    %define _with_cc_clang 1
+    %endif
+
+    %_fix_broken_configure_for_lto
+
+    echo %{_target_platform}
+    echo $binutils_target
+    # We could optimize the cross builds size by --enable-shared but the produced
+    # binaries may be less convenient in the embedded environment.
+    mkdir $binutils_target
+    pushd $binutils_target
+    %configure \
+      --quiet \
+      --build=%{_target_platform} --host=%{_target_platform} \
+      --target=%{_target_platform} \
+    %if %{with gold}
+      --enable-gold=default \
+    %endif
+      --enable-ld \
+    %if %{isnative}
+      --with-sysroot=/ \
+    %else
+      --enable-targets=%{_host} \
+      --with-sysroot=%{_prefix}/$binutils_target/sys-root \
+      --program-prefix=%{cross} \
+    %endif
+    %if %{with systemzlib}
+      --with-system-zlib \
+    %endif
+    %if %{enable_shared}
+      --enable-shared \
+    %else
+      --disable-shared \
+    %endif
+    %if %{enable_deterministic_archives}
+      --enable-deterministic-archives \
+    %else
+      --enable-deterministic-archives=no \
+    %endif
+    %if %{enable_lto}
+      --enable-lto \
+    %endif
+    %if %{default_compress_debug}
+      --enable-compressed-debug-sections=all \
+    %else
+      --enable-compressed-debug-sections=none \
+    %endif
+    %if %{default_generate_notes}
+      --enable-generate-build-notes=yes \
+    %else
+      --enable-generate-build-notes=no \
+    %endif
+    %if %{enable_threading}
+      --enable-threads=yes \
+    %else
+      --enable-threads=no \
+    %endif
+      $CARGS \
+      --enable-plugins \
+      --with-bugurl=http://bugzilla.redhat.com/bugzilla/ \
+      || cat config.log
+
+    popd
+}
+
+function build_binutils () {
+    binutils_target=$1
+
+    pushd $binutils_target
+    %if %{with docs}
+    %make_build %{_smp_mflags} tooldir=%{_prefix} all
+    %make_build %{_smp_mflags} tooldir=%{_prefix} info
+    %else
+    %make_build %{_smp_mflags} tooldir=%{_prefix} MAKEINFO=true all
+    %endif
+    popd
+}
+
+function test_binutils () {
+    binutils_target=$1
+    pushd $binutils_target
+    # Do not use %%check as it is run after %%install where libbfd.so is rebuilt
+    # with -fvisibility=hidden no longer being usable in its shared form.
+    %if %{without testsuite}
+    echo ====================TESTSUITE DISABLED=========================
+    %else
+    make -k check < /dev/null || :
+    echo ====================TESTING=========================
+    cat {gas/testsuite/gas,ld/ld,binutils/binutils}.sum
+    %if %{with gold}
+    if [ -f gold/test-suite.log ]; then
+        cat gold/test-suite.log
+    fi
+    if [ -f gold/testsuite/test-suite.log ]; then
+        cat gold/testsuite/*.log
+    fi
+    %endif
+    echo ====================TESTING END=====================
+    for file in {gas/testsuite/gas,ld/ld,binutils/binutils}.{sum,log}
+    do
+      ln $file binutils-%{_target_platform}-$(basename $file) || :
+    done
+    tar cjf binutils-%{_target_platform}.tar.xz  binutils-%{_target_platform}-*.{sum,log}
+    uuencode binutils-%{_target_platform}.tar.xz binutils-%{_target_platform}.tar.xz
+    rm -f binutils-%{_target_platform}.tar.xz    binutils-%{_target_platform}-*.{sum,log}
+    %if %{with gold}
+    if [ -f gold/testsuite/test-suite.log ]; then
+      tar cjf  binutils-%{_target_platform}-gold.log.tar.xz gold/testsuite/*.log
+      uuencode binutils-%{_target_platform}-gold.log.tar.xz binutils-%{_target_platform}-gold.log.tar.xz
+      rm -f    binutils-%{_target_platform}-gold.log.tar.xz
+    fi
+    %endif
+    %endif
+    popd
+}
+
+configure_binutils %{binutils_target}
+build_binutils %{binutils_target}
+test_binutils %{binutils_target}
+
+#configure_binutils aarch64-linux-gnu
+#build_binutils aarch64-linux-gnu
+#test_binutils aarch64-linux-gnu
 
 #----------------------------------------------------------------------------
 
 %install
-%if %{with docs}
-%make_install DESTDIR=%{buildroot}
-%else
-%make_install DESTDIR=%{buildroot} MAKEINFO=true
-%endif
 
-%if %{isnative}
-%if %{with docs}
-make prefix=%{buildroot}%{_prefix} infodir=%{buildroot}%{_infodir} install-info
-%endif
+function binutils_initial_install () {
+    binutils_target=$1
+    pushd $binutils_target
+    %if %{with docs}
+    %make_install DESTDIR=%{buildroot}
+    %else
+    %make_install DESTDIR=%{buildroot} MAKEINFO=true
+    %endif
 
-# Rebuild libiberty.a with -fPIC.
-# Future: Remove it together with its header file, projects should bundle it.
-%make_build -C libiberty clean
-%set_build_flags
-%make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS" -C libiberty
+    %if %{isnative}
+    %if %{with docs}
+    make prefix=%{buildroot}%{_prefix} infodir=%{buildroot}%{_infodir} install-info
+    %endif
+    %endif
+    popd
 
-# Rebuild libbfd.a with -fPIC.
-# Without the hidden visibility the 3rd party shared libraries would export
-# the bfd non-stable ABI.
-%make_build -C bfd clean
-%set_build_flags
-%make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS -fvisibility=hidden" -C bfd
+}
 
-# Rebuild libopcodes.a with -fPIC.
-%make_build -C opcodes clean
-%set_build_flags
-%make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS" -C opcodes
+function rebuild_and_reinstall_libraries () {
+    binutils_target=$1
+    pushd $binutils_target
+    # Rebuild libiberty.a with -fPIC.
+    # Future: Remove it together with its header file, projects should bundle it.
+    %make_build -C libiberty clean
+    %set_build_flags
+    %make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS" -C libiberty
 
-install -m 644 bfd/libbfd.a %{buildroot}%{_libdir}
-install -m 644 libiberty/libiberty.a %{buildroot}%{_libdir}
-install -m 644 include/libiberty.h %{buildroot}%{_prefix}/include
-install -m 644 opcodes/libopcodes.a %{buildroot}%{_libdir}
-# Remove Windows/Novell only man pages
-rm -f %{buildroot}%{_mandir}/man1/{dlltool,nlmconv,windres,windmc}*
-%if %{without docs}
-rm -f %{buildroot}%{_mandir}/man1/{addr2line,ar,as,c++filt,elfedit,gprof,ld,nm,objcopy,objdump,ranlib,readelf,size,strings,strip}*
-rm -f %{buildroot}%{_infodir}/{as,bfd,binutils,gprof,ld}*
-%endif
+    # Rebuild libbfd.a with -fPIC.
+    # Without the hidden visibility the 3rd party shared libraries would export
+    # the bfd non-stable ABI.
+    %make_build -C bfd clean
+    %set_build_flags
+    %make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS -fvisibility=hidden" -C bfd
 
-%if %{enable_shared}
-chmod +x %{buildroot}%{_libdir}/lib*.so*
-%endif
+    # Rebuild libopcodes.a with -fPIC.
+    %make_build -C opcodes clean
+    %set_build_flags
+    %make_build CFLAGS="-g -fPIC $RPM_OPT_FLAGS" -C opcodes
 
-# Prevent programs from linking against libbfd and libopcodes
-# dynamically, as they are changed far too often.
-rm -f %{buildroot}%{_libdir}/lib{bfd,opcodes}.so
+    install -m 644 bfd/libbfd.a %{buildroot}%{_libdir}
+    install -m 644 libiberty/libiberty.a %{buildroot}%{_libdir}
+    install -m 644 ../include/libiberty.h %{buildroot}%{_prefix}/include
+    install -m 644 opcodes/libopcodes.a %{buildroot}%{_libdir}
 
-# Remove libtool files, which reference the .so libs
-rm -f %{buildroot}%{_libdir}/lib{bfd,opcodes}.la
+    %if %{enable_shared}
+    chmod +x %{buildroot}%{_libdir}/lib*.so*
+    %endif
 
-# Sanity check --enable-64-bit-bfd really works.
-grep '^#define BFD_ARCH_SIZE 64$' %{buildroot}%{_prefix}/include/bfd.h
-# Fix multilib conflicts of generated values by __WORDSIZE-based expressions.
-%ifarch %{ix86} x86_64 ppc %{power64} s390 s390x sh3 sh4 sparc sparc64 arm
-sed -i -e '/^#include "ansidecl.h"/{p;s~^.*$~#include <bits/wordsize.h>~;}' \
-    -e 's/^#define BFD_DEFAULT_TARGET_SIZE \(32\|64\) *$/#define BFD_DEFAULT_TARGET_SIZE __WORDSIZE/' \
-    -e 's/^#define BFD_HOST_64BIT_LONG [01] *$/#define BFD_HOST_64BIT_LONG (__WORDSIZE == 64)/' \
-    -e 's/^#define BFD_HOST_64_BIT \(long \)\?long *$/#if __WORDSIZE == 32\
-#define BFD_HOST_64_BIT long long\
-#else\
-#define BFD_HOST_64_BIT long\
-#endif/' \
-    -e 's/^#define BFD_HOST_U_64_BIT unsigned \(long \)\?long *$/#define BFD_HOST_U_64_BIT unsigned BFD_HOST_64_BIT/' \
-    %{buildroot}%{_prefix}/include/bfd.h
-%endif
-touch -r bfd/bfd-in2.h %{buildroot}%{_prefix}/include/bfd.h
+    # Prevent programs from linking against libbfd and libopcodes
+    # dynamically, as they are changed far too often.
+    rm -f %{buildroot}%{_libdir}/lib{bfd,opcodes}.so
 
-# Generate .so linker scripts for dependencies; imported from glibc/Makerules:
+    # Remove libtool files, which reference the .so libs
+    rm -f %{buildroot}%{_libdir}/lib{bfd,opcodes}.la
 
-# This fragment of linker script gives the OUTPUT_FORMAT statement
-# for the configuration we are building.
-OUTPUT_FORMAT="\
+    # Generate .so linker scripts for dependencies; imported from glibc/Makerules:
+
+    # This fragment of linker script gives the OUTPUT_FORMAT statement
+    # for the configuration we are building.
+    OUTPUT_FORMAT="\
 /* Ensure this .so library will not be used by a link for a different format
    on a multi-architecture system.  */
 $(gcc $CFLAGS $LDFLAGS -shared -x c /dev/null -o /dev/null -Wl,--verbose -v 2>&1 | sed -n -f "%{SOURCE2}")"
@@ -700,37 +741,89 @@ $OUTPUT_FORMAT
 INPUT ( %{_libdir}/libopcodes.a -lbfd )
 EOH
 
-%else
-# For cross-binutils we drop the documentation.
-rm -rf %{buildroot}%{_infodir}
-# We keep these as one can have native + cross binutils of different versions.
-#rm -rf {buildroot}{_prefix}/share/locale
-#rm -rf {buildroot}{_mandir}
-rm -rf %{buildroot}%{_libdir}/libiberty.a
+    popd
+}
+
+
+function cleanup_documentation () {
+    binutils_target=$1
+    pushd $binutils_target
+    # Remove Windows/Novell only man pages
+    rm -f %{buildroot}%{_mandir}/man1/{dlltool,nlmconv,windres,windmc}*
+    %if %{without docs}
+    rm -f %{buildroot}%{_mandir}/man1/{addr2line,ar,as,c++filt,elfedit,gprof,ld,nm,objcopy,objdump,ranlib,readelf,size,strings,strip}*
+    rm -f %{buildroot}%{_infodir}/{as,bfd,binutils,gprof,ld}*
+    %endif
+
+    %if ! %{isnative}
+    # For cross-binutils we drop the documentation.
+    rm -rf %{buildroot}%{_infodir}
+    # We keep these as one can have native + cross binutils of different versions.
+    #rm -rf {buildroot}{_prefix}/share/locale
+    #rm -rf {buildroot}{_mandir}
+    rm -rf %{buildroot}%{_libdir}/libiberty.a
+    %endif
+
+    # This one comes from gcc
+    rm -f %{buildroot}%{_infodir}/dir
+    rm -rf %{buildroot}%{_prefix}/%{binutils_target}
+    popd
+}
+
+
+function fix_headers () {
+    binutils_target=$1
+    pushd $binutils_target
+    # Sanity check --enable-64-bit-bfd really works.
+    grep '^#define BFD_ARCH_SIZE 64$' %{buildroot}%{_prefix}/include/bfd.h
+    # Fix multilib conflicts of generated values by __WORDSIZE-based expressions.
+    %ifarch %{ix86} x86_64 ppc %{power64} s390 s390x sh3 sh4 sparc sparc64 arm
+    sed -i -e '/^#include "ansidecl.h"/{p;s~^.*$~#include <bits/wordsize.h>~;}' \
+        -e 's/^#define BFD_DEFAULT_TARGET_SIZE \(32\|64\) *$/#define BFD_DEFAULT_TARGET_SIZE __WORDSIZE/' \
+        -e 's/^#define BFD_HOST_64BIT_LONG [01] *$/#define BFD_HOST_64BIT_LONG (__WORDSIZE == 64)/' \
+        -e 's/^#define BFD_HOST_64_BIT \(long \)\?long *$/#if __WORDSIZE == 32\
+    #define BFD_HOST_64_BIT long long\
+    #else\
+    #define BFD_HOST_64_BIT long\
+    #endif/' \
+        -e 's/^#define BFD_HOST_U_64_BIT unsigned \(long \)\?long *$/#define BFD_HOST_U_64_BIT unsigned BFD_HOST_64_BIT/' \
+        %{buildroot}%{_prefix}/include/bfd.h
+    %endif
+    touch -r ../bfd/bfd-in2.h %{buildroot}%{_prefix}/include/bfd.h
+    popd
+}
+
+function find_lang_files () {
+    binutils_target=$1
+    pushd $binutils_target
+    %find_lang %{?cross}binutils
+    %find_lang %{?cross}opcodes
+    %find_lang %{?cross}bfd
+    %find_lang %{?cross}gas
+    %find_lang %{?cross}gprof
+    cat %{?cross}opcodes.lang >> %{?cross}binutils.lang
+    cat %{?cross}bfd.lang >> %{?cross}binutils.lang
+    cat %{?cross}gas.lang >> %{?cross}binutils.lang
+    cat %{?cross}gprof.lang >> %{?cross}binutils.lang
+    
+    if [ -x ld/ld-new ]; then
+      %find_lang %{?cross}ld
+      cat %{?cross}ld.lang >> %{?cross}binutils.lang
+    fi
+    if [ -x gold/ld-new ]; then
+      %find_lang %{?cross}gold
+      cat %{?cross}gold.lang >> %{?cross}binutils.lang
+    fi
+    popd
+}
+
+binutils_initial_install %{binutils_target}
+%if %{isnative}
+  rebuild_and_reinstall_libraries %{binutils_target}
+  fix_headers %{binutils_target}
 %endif
-
-# This one comes from gcc
-rm -f %{buildroot}%{_infodir}/dir
-rm -rf %{buildroot}%{_prefix}/%{binutils_target}
-
-%find_lang %{?cross}binutils
-%find_lang %{?cross}opcodes
-%find_lang %{?cross}bfd
-%find_lang %{?cross}gas
-%find_lang %{?cross}gprof
-cat %{?cross}opcodes.lang >> %{?cross}binutils.lang
-cat %{?cross}bfd.lang >> %{?cross}binutils.lang
-cat %{?cross}gas.lang >> %{?cross}binutils.lang
-cat %{?cross}gprof.lang >> %{?cross}binutils.lang
-
-if [ -x ld/ld-new ]; then
-  %find_lang %{?cross}ld
-  cat %{?cross}ld.lang >> %{?cross}binutils.lang
-fi
-if [ -x gold/ld-new ]; then
-  %find_lang %{?cross}gold
-  cat %{?cross}gold.lang >> %{?cross}binutils.lang
-fi
+cleanup_documentation %{binutils_target}
+find_lang_files %{binutils_target}
 
 #----------------------------------------------------------------------------
 
@@ -776,7 +869,7 @@ exit 0
 
 #----------------------------------------------------------------------------
 
-%files -f %{?cross}binutils.lang
+%files -f %{binutils_target}/%{?cross}binutils.lang
 %license COPYING COPYING3 COPYING3.LIB COPYING.LIB
 %doc README
 %{_bindir}/%{?cross}[!l]*
@@ -819,6 +912,27 @@ exit 0
 
 #----------------------------------------------------------------------------
 %changelog
+* Tue Nov 03 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-13
+- Extend  fix erroneous decoding of LEB128 values.  (#1893921)
+
+* Tue Nov 03 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-12
+- Another correction for plugin as-needed patch.  (#1889763)
+
+* Wed Oct 28 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-11
+- Correction for plugin as-needed patch.  (#1889763)
+
+* Tue Oct 27 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-8
+- Really fix erroneous decoding of LEB128 values.  (#1891171)
+
+* Wed Oct 21 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-7
+- Fix erroneous decoding of LEB128 values.  (#188716)
+
+* Thu Oct 15 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-6
+- Make readelf and objdump recursively follow debug links.  (PR 26595)
+
+* Fri Oct 09 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-5
+- Allow plugin syms to mark as-needed shared libs needed
+
 * Thu Oct 08 2020 Nick Clifton  <nickc@redhat.com> - 2.35.1-4
 - Fix various problems with Power10 support.