diff --git a/SOURCES/binutils-CVE-2019-17450.patch b/SOURCES/binutils-CVE-2019-17450.patch
new file mode 100644
index 0000000..63affa9
--- /dev/null
+++ b/SOURCES/binutils-CVE-2019-17450.patch
@@ -0,0 +1,62 @@
+--- binutils.orig/bfd/dwarf2.c 2019-12-03 15:50:43.324118062 +0000
++++ binutils-2.30/bfd/dwarf2.c 2019-12-03 15:54:32.545489215 +0000
+@@ -2803,8 +2803,8 @@ lookup_symbol_in_variable_table (struct
+
+ static bfd_boolean
+ find_abstract_instance_name (struct comp_unit *unit,
+- bfd_byte *orig_info_ptr,
+ struct attribute *attr_ptr,
++ unsigned int recur_count,
+ const char **pname,
+ bfd_boolean *is_linkage)
+ {
+@@ -2817,6 +2817,14 @@ find_abstract_instance_name (struct comp
+ struct attribute attr;
+ const char *name = NULL;
+
++ if (recur_count == 100)
++ {
++ _bfd_error_handler
++ (_("DWARF error: abstract instance recursion detected"));
++ bfd_set_error (bfd_error_bad_value);
++ return FALSE;
++ }
++
+ /* DW_FORM_ref_addr can reference an entry in a different CU. It
+ is an offset from the .debug_info section, not the current CU. */
+ if (attr_ptr->form == DW_FORM_ref_addr)
+@@ -2934,15 +2942,7 @@ find_abstract_instance_name (struct comp
+ info_ptr, info_ptr_end);
+ if (info_ptr == NULL)
+ break;
+- /* It doesn't ever make sense for DW_AT_specification to
+- refer to the same DIE. Stop simple recursion. */
+- if (info_ptr == orig_info_ptr)
+- {
+- _bfd_error_handler
+- (_("Dwarf Error: Abstract instance recursion detected."));
+- bfd_set_error (bfd_error_bad_value);
+- return FALSE;
+- }
++
+ switch (attr.name)
+ {
+ case DW_AT_name:
+@@ -2956,7 +2956,7 @@ find_abstract_instance_name (struct comp
+ }
+ break;
+ case DW_AT_specification:
+- if (!find_abstract_instance_name (unit, info_ptr, &attr,
++ if (!find_abstract_instance_name (unit, &attr, recur_count + 1,
+ pname, is_linkage))
+ return FALSE;
+ break;
+@@ -3162,7 +3162,7 @@ scan_unit_for_symbols (struct comp_unit
+
+ case DW_AT_abstract_origin:
+ case DW_AT_specification:
+- if (!find_abstract_instance_name (unit, info_ptr, &attr,
++ if (!find_abstract_instance_name (unit, &attr, 0,
+ &func->name,
+ &func->is_linkage))
+ goto fail;
diff --git a/SOURCES/binutils-CVE-2019-17451.patch b/SOURCES/binutils-CVE-2019-17451.patch
new file mode 100644
index 0000000..0f503a3
--- /dev/null
+++ b/SOURCES/binutils-CVE-2019-17451.patch
@@ -0,0 +1,20 @@
+--- binutils.orig/bfd/dwarf2.c 2019-11-13 11:32:09.395430104 +0000
++++ binutils-2.33.1/bfd/dwarf2.c 2019-11-13 11:33:17.272899503 +0000
+@@ -4440,7 +4440,16 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd,
+ for (total_size = 0;
+ msec;
+ msec = find_debug_info (debug_bfd, debug_sections, msec))
+- total_size += msec->size;
++ {
++ /* Catch PR25070 testcase overflowing size calculation here. */
++ if (total_size + msec->size < total_size
++ || total_size + msec->size < msec->size)
++ {
++ bfd_set_error (bfd_error_no_memory);
++ return FALSE;
++ }
++ total_size += msec->size;
++ }
+
+ stash->info_ptr_memory = (bfd_byte *) bfd_malloc (total_size);
+ if (stash->info_ptr_memory == NULL)
diff --git a/SOURCES/binutils-copy-multiple-relocs.patch b/SOURCES/binutils-copy-multiple-relocs.patch
new file mode 100644
index 0000000..66f50e1
--- /dev/null
+++ b/SOURCES/binutils-copy-multiple-relocs.patch
@@ -0,0 +1,591 @@
+diff -rup binutils.orig/bfd/elf-bfd.h binutils-2.30/bfd/elf-bfd.h
+--- binutils.orig/bfd/elf-bfd.h 2020-02-12 13:31:20.348605538 +0000
++++ binutils-2.30/bfd/elf-bfd.h 2020-02-12 13:31:33.831507582 +0000
+@@ -1479,6 +1479,19 @@ struct elf_backend_data
+ /* Opcode representing no unwind. */
+ int (*cant_unwind_opcode) (struct bfd_link_info *);
+
++ /* Called when a section has extra reloc sections. */
++ bfd_boolean (*init_secondary_reloc_section) (bfd *, Elf_Internal_Shdr *, const char *, unsigned int);
++
++ /* Called when after loading the normal relocs for a section. */
++ bfd_boolean (*slurp_secondary_relocs) (bfd *, asection *, asymbol **);
++
++ /* Called after writing the normal relocs for a section. */
++ bfd_boolean (*write_secondary_relocs) (bfd *, asection *);
++
++ /* Called to return the value to set in the ST_SHNDX field of an ELF symbol
++ from an iternal symbol which does not map to any known section. */
++ unsigned int (*symbol_section_index) (bfd *, elf_symbol_type *);
++
+ /* This is non-zero if static TLS segments require a special alignment. */
+ unsigned static_tls_alignment;
+
+@@ -2696,6 +2709,19 @@ extern bfd_vma elf64_r_sym (bfd_vma);
+ extern bfd_vma elf32_r_info (bfd_vma, bfd_vma);
+ extern bfd_vma elf32_r_sym (bfd_vma);
+
++
++extern bfd_boolean _bfd_elf_init_secondary_reloc_section
++ (bfd *, Elf_Internal_Shdr *, const char *, unsigned int);
++extern bfd_boolean _bfd_elf_slurp_secondary_reloc_section
++ (bfd *, asection *, asymbol **);
++extern bfd_boolean _bfd_elf_copy_special_section_fields
++ (const bfd *, bfd *, const Elf_Internal_Shdr *, Elf_Internal_Shdr *);
++extern bfd_boolean _bfd_elf_write_secondary_reloc_section
++ (bfd *, asection *);
++extern unsigned int _bfd_elf_symbol_section_index
++ (bfd *, elf_symbol_type *);
++
++
+ /* Large common section. */
+ extern asection _bfd_elf_large_com_section;
+
+diff -rup binutils.orig/bfd/elf.c binutils-2.30/bfd/elf.c
+--- binutils.orig/bfd/elf.c 2020-02-12 13:31:20.347605546 +0000
++++ binutils-2.30/bfd/elf.c 2020-02-12 13:33:19.635738944 +0000
+@@ -1572,7 +1572,7 @@ _bfd_elf_copy_private_bfd_data (bfd *ibf
+ /* Final attempt. Call the backend copy function
+ with a NULL input section. */
+ if (bed->elf_backend_copy_special_section_fields != NULL)
+- bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
++ (void) bed->elf_backend_copy_special_section_fields (ibfd, obfd, NULL, oheader);
+ }
+ }
+
+@@ -2416,11 +2416,14 @@ bfd_section_from_shdr (bfd *abfd, unsign
+ sections. */
+ if (*p_hdr != NULL)
+ {
+- _bfd_error_handler
+- /* xgettext:c-format */
+- (_("%B: warning: multiple relocation sections for section %A \
+-found - ignoring all but the first"),
+- abfd, target_sect);
++ if (bed->init_secondary_reloc_section == NULL
++ || ! bed->init_secondary_reloc_section (abfd, hdr, name, shindex))
++ {
++ _bfd_error_handler
++ /* xgettext:c-format */
++ (_("%pB: warning: secondary relocation section '%s' for section %pA found - ignoring"),
++ abfd, name, target_sect);
++ }
+ goto success;
+ }
+ hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, sizeof (*hdr2));
+@@ -7948,9 +7951,20 @@ error_return:
+ if (elf_symtab_shndx_list (abfd))
+ shndx = elf_symtab_shndx_list (abfd)->ndx;
+ break;
+- default:
++ case SHN_COMMON:
++ case SHN_ABS:
+ shndx = SHN_ABS;
+ break;
++ default:
++ if (bed->symbol_section_index)
++ shndx = bed->symbol_section_index (abfd, type_ptr);
++ else
++ {
++ _bfd_error_handler (_("%pB: Unable to handle section index %x in ELF symbol. Using ABS instead. (%x)"),
++ abfd, shndx, SHN_COMMON);
++ shndx = SHN_ABS;
++ }
++ break;
+ }
+ }
+ else
+@@ -11556,3 +11570,354 @@ _bfd_elf_maybe_function_sym (const asymb
+ size = 1;
+ return size;
+ }
++
++/* Set to non-zero to enable some debug messages. */
++#define DEBUG_SECONDARY_RELOCS 0
++
++/* An internal-to-the-bfd-library only section type
++ used to indicate a cached secondary reloc section. */
++#define SHT_SECONDARY_RELOC (SHT_LOOS + SHT_RELA)
++
++/* Create a BFD section to hold a secondary reloc section. */
++
++bfd_boolean
++_bfd_elf_init_secondary_reloc_section (bfd * abfd,
++ Elf_Internal_Shdr *hdr,
++ const char * name,
++ unsigned int shindex)
++{
++ /* We only support RELA secondary relocs. */
++ if (hdr->sh_type != SHT_RELA)
++ return FALSE;
++
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "secondary reloc section %s encountered\n", name);
++#endif
++ hdr->sh_type = SHT_SECONDARY_RELOC;
++ return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
++}
++
++/* Read in any secondary relocs associated with SEC. */
++
++bfd_boolean
++_bfd_elf_slurp_secondary_reloc_section (bfd * abfd,
++ asection * sec,
++ asymbol ** symbols)
++{
++ const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
++ asection * relsec;
++ bfd_boolean result = TRUE;
++ bfd_vma (*r_sym) (bfd_vma);
++
++
++#ifdef BFD64
++ if (bfd_arch_bits_per_address (abfd) != 32)
++ r_sym = elf64_r_sym;
++ else
++#endif
++ r_sym = elf32_r_sym;
++
++ /* Discover if there are any secondary reloc sections
++ associated with SEC. */
++ for (relsec = abfd->sections; relsec != NULL; relsec = relsec->next)
++ {
++ Elf_Internal_Shdr * hdr = & elf_section_data (relsec)->this_hdr;
++
++ if (hdr->sh_type == SHT_SECONDARY_RELOC
++ && hdr->sh_info == (unsigned) elf_section_data (sec)->this_idx)
++ {
++ bfd_byte * native_relocs;
++ bfd_byte * native_reloc;
++ arelent * internal_relocs;
++ arelent * internal_reloc;
++ unsigned int i;
++ unsigned int entsize;
++ unsigned int symcount;
++ unsigned int reloc_count;
++
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "read secondary relocs for %s from %s\n", sec->name, relsec->name);
++#endif
++ entsize = hdr->sh_entsize;
++
++ native_relocs = bfd_malloc (hdr->sh_size);
++ if (native_relocs == NULL)
++ {
++ result = FALSE;
++ continue;
++ }
++
++ reloc_count = NUM_SHDR_ENTRIES (hdr);
++ internal_relocs = (arelent *) bfd_alloc2 (abfd, reloc_count, sizeof (arelent));
++ if (internal_relocs == NULL)
++ {
++ free (native_relocs);
++ result = FALSE;
++ continue;
++ }
++
++ if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
++ || (bfd_bread (native_relocs, hdr->sh_size, abfd) != hdr->sh_size))
++ {
++ free (native_relocs);
++ free (internal_relocs);
++ result = FALSE;
++ continue;
++ }
++
++ symcount = bfd_get_symcount (abfd);
++
++ for (i = 0, internal_reloc = internal_relocs, native_reloc = native_relocs;
++ i < reloc_count;
++ i++, internal_reloc++, native_reloc += entsize)
++ {
++ ;
++ Elf_Internal_Rela rela;
++
++ ebd->s->swap_reloca_in (abfd, native_reloc, & rela);
++
++ /* The address of an ELF reloc is section relative for an object
++ file, and absolute for an executable file or shared library.
++ The address of a normal BFD reloc is always section relative,
++ and the address of a dynamic reloc is absolute.. */
++ if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
++ internal_reloc->address = rela.r_offset;
++ else
++ internal_reloc->address = rela.r_offset - sec->vma;
++
++ if (r_sym (rela.r_info) == STN_UNDEF)
++ {
++ /* FIXME: This and the error case below mean that we
++ have a symbol on relocs that is not elf_symbol_type. */
++ internal_reloc->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
++ }
++ else if (r_sym (rela.r_info) > symcount)
++ {
++ _bfd_error_handler
++ /* xgettext:c-format */
++ (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
++ abfd, sec, i, (long) r_sym (rela.r_info));
++ bfd_set_error (bfd_error_bad_value);
++ internal_reloc->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
++ result = FALSE;
++ }
++ else
++ {
++ asymbol **ps;
++
++ ps = symbols + r_sym (rela.r_info) - 1;
++
++ internal_reloc->sym_ptr_ptr = ps;
++ /* Make sure that this symbol is not removed by strip. */
++ (*ps)->flags |= BSF_KEEP;
++ }
++
++ internal_reloc->addend = rela.r_addend;
++
++ ebd->elf_info_to_howto (abfd, internal_reloc, & rela);
++ if (internal_reloc->howto == NULL)
++ {
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "there is no howto associated with reloc %lx\n", rela.r_info);
++#endif
++ result = FALSE;
++ }
++ }
++
++ free (native_relocs);
++ /* Store the internal relocs. */
++ elf_section_data (relsec)->sec_info = internal_relocs;
++ }
++ }
++
++ return result;
++}
++
++/* Set the ELF section header fields of an output secondary reloc section. */
++
++bfd_boolean
++_bfd_elf_copy_special_section_fields (const bfd * ibfd ATTRIBUTE_UNUSED,
++ bfd * obfd ATTRIBUTE_UNUSED,
++ const Elf_Internal_Shdr * isection,
++ Elf_Internal_Shdr * osection)
++{
++ if (isection->sh_type != SHT_SECONDARY_RELOC)
++ return TRUE;
++
++ if (isection == NULL)
++ return FALSE;
++
++ asection * isec = isection->bfd_section;
++ if (isec == NULL)
++ return FALSE;
++
++ asection * osec = osection->bfd_section;
++ if (osec == NULL)
++ return FALSE;
++
++ BFD_ASSERT (elf_section_data (osec)->sec_info == NULL);
++ elf_section_data (osec)->sec_info = elf_section_data (isec)->sec_info;
++ osection->sh_type = SHT_RELA;
++ osection->sh_link = elf_onesymtab (obfd);
++ if (osection->sh_link == 0)
++ {
++ /* There is no symbol table - we are hosed... */
++ _bfd_error_handler
++ /* xgettext:c-format */
++ (_("%pB(%pA): link section cannot be set because the output file does not have a symbol table"),
++ obfd, osec);
++ bfd_set_error (bfd_error_bad_value);
++ return FALSE;
++ }
++
++ /* Find the output section that corresponds to the isection's sh_info link. */
++ BFD_ASSERT (isection->sh_info > 0 && isection->sh_info < elf_numsections (ibfd));
++ isection = elf_elfsections (ibfd)[isection->sh_info];
++
++ BFD_ASSERT (isection != NULL);
++ BFD_ASSERT (isection->bfd_section != NULL);
++ BFD_ASSERT (isection->bfd_section->output_section != NULL);
++ osection->sh_info = elf_section_data (isection->bfd_section->output_section)->this_idx;
++
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "update header of %s, sh_link = %u, sh_info = %u\n",
++ osec->name, osection->sh_link, osection->sh_info);
++#endif
++
++ return TRUE;
++}
++
++/* Write out a secondary reloc section. */
++
++bfd_boolean
++_bfd_elf_write_secondary_reloc_section (bfd *abfd, asection *sec)
++{
++ const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
++ bfd_vma addr_offset;
++ asection * relsec;
++ bfd_vma (*r_info) (bfd_vma, bfd_vma);
++
++#ifdef BFD64
++ if (bfd_arch_bits_per_address (abfd) != 32)
++ r_info = elf64_r_info;
++ else
++#endif
++ r_info = elf32_r_info;
++
++ if (sec == NULL)
++ return FALSE;
++
++ /* The address of an ELF reloc is section relative for an object
++ file, and absolute for an executable file or shared library.
++ The address of a BFD reloc is always section relative. */
++ addr_offset = 0;
++ if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
++ addr_offset = sec->vma;
++
++ /* Discover if there are any secondary reloc sections
++ associated with SEC. */
++ for (relsec = abfd->sections; relsec != NULL; relsec = relsec->next)
++ {
++ const struct bfd_elf_section_data * const esd = elf_section_data (relsec);
++ Elf_Internal_Shdr * const hdr = (Elf_Internal_Shdr *) & esd->this_hdr;
++
++ if (hdr->sh_type == SHT_RELA
++ && hdr->sh_info == (unsigned) elf_section_data (sec)->this_idx)
++ {
++ asymbol * last_sym;
++ int last_sym_idx;
++ unsigned int reloc_count;
++ unsigned int idx;
++ arelent * src_irel;
++ bfd_byte * dst_rela;
++
++ BFD_ASSERT (hdr->contents == NULL);
++
++ reloc_count = hdr->sh_size / hdr->sh_entsize;
++ BFD_ASSERT (reloc_count > 0);
++
++ hdr->contents = bfd_alloc (abfd, hdr->sh_size);
++ if (hdr->contents == NULL)
++ continue;
++
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "write %u secondary relocs for %s from %s\n", reloc_count, sec->name, relsec->name);
++#endif
++ last_sym = NULL;
++ last_sym_idx = 0;
++ dst_rela = hdr->contents;
++ src_irel = (arelent *) esd->sec_info;
++ BFD_ASSERT (src_irel != NULL);
++
++ for (idx = 0; idx < reloc_count; idx++, dst_rela += hdr->sh_entsize)
++ {
++ Elf_Internal_Rela src_rela;
++ arelent *ptr;
++ asymbol *sym;
++ int n;
++
++ ptr = src_irel + idx;
++ sym = *ptr->sym_ptr_ptr;
++
++ if (sym == last_sym)
++ n = last_sym_idx;
++ else
++ {
++ last_sym = sym;
++ n = _bfd_elf_symbol_from_bfd_symbol (abfd, & sym);
++ if (n < 0)
++ {
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "failed to find symbol %s whilst rewriting relocs\n",
++ sym->name);
++#endif
++ /* FIXME: Signal failure somehow. */
++ n = 0;
++ }
++ last_sym_idx = n;
++ }
++
++ if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
++ && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
++ && ! _bfd_elf_validate_reloc (abfd, ptr))
++ {
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "symbol %s is not in the output bfd\n",
++ sym->name);
++#endif
++ /* FIXME: Signal failure somehow. */
++ n = 0;
++ }
++
++ if (ptr->howto == NULL)
++ {
++#if DEBUG_SECONDARY_RELOCS
++ fprintf (stderr, "reloc for symbol %s does not have a howto associated with it\n",
++ sym->name);
++#endif
++ /* FIXME: Signal failure somehow. */
++ n = 0;
++ }
++
++ src_rela.r_offset = ptr->address + addr_offset;
++ src_rela.r_info = r_info (n, ptr->howto->type);
++ src_rela.r_addend = ptr->addend;
++ ebd->s->swap_reloca_out (abfd, &src_rela, dst_rela);
++ }
++ }
++ }
++
++ return TRUE;
++}
++
++/* Preserve any OS or PROCESSOR specific section indicies. */
++
++unsigned int
++_bfd_elf_symbol_section_index (bfd * abfd ATTRIBUTE_UNUSED,
++ elf_symbol_type * sym)
++{
++ unsigned int shndx = sym->internal_elf_sym.st_shndx;
++
++ /* Preserve special section indicies. */
++ return shndx >= SHN_LORESERVE ? shndx : SHN_ABS;
++}
+diff -rup binutils.orig/bfd/elfcode.h binutils-2.30/bfd/elfcode.h
+--- binutils.orig/bfd/elfcode.h 2020-02-12 13:31:20.334605640 +0000
++++ binutils-2.30/bfd/elfcode.h 2020-02-12 13:31:33.833507567 +0000
+@@ -855,6 +855,7 @@ elf_object_p (bfd *abfd)
+ void
+ elf_write_relocs (bfd *abfd, asection *sec, void *data)
+ {
++ const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+ bfd_boolean *failedp = (bfd_boolean *) data;
+ Elf_Internal_Shdr *rela_hdr;
+ bfd_vma addr_offset;
+@@ -969,6 +970,13 @@ elf_write_relocs (bfd *abfd, asection *s
+ src_rela.r_addend = ptr->addend;
+ (*swap_out) (abfd, &src_rela, dst_rela);
+ }
++
++ if (bed->write_secondary_relocs != NULL)
++ if (! bed->write_secondary_relocs (abfd, sec))
++ {
++ *failedp = TRUE;
++ return;
++ }
+ }
+
+ /* Write out the program headers. */
+@@ -1271,7 +1279,10 @@ elf_slurp_symbol_table (bfd *abfd, asymb
+ {
+ /* This symbol is in a section for which we did not
+ create a BFD section. Just use bfd_abs_section,
+- although it is wrong. FIXME. */
++ although it is wrong. FIXME. Note - there is
++ code in elf.c:swap_out_syms that calls
++ symbol_section_index() in the elf backend for
++ cases like this. */
+ sym->symbol.section = bfd_abs_section_ptr;
+ }
+ }
+@@ -1501,6 +1512,7 @@ elf_slurp_reloc_table (bfd *abfd,
+ asymbol **symbols,
+ bfd_boolean dynamic)
+ {
++ const struct elf_backend_data * const bed = get_elf_backend_data (abfd);
+ struct bfd_elf_section_data * const d = elf_section_data (asect);
+ Elf_Internal_Shdr *rel_hdr;
+ Elf_Internal_Shdr *rel_hdr2;
+@@ -1564,6 +1576,10 @@ elf_slurp_reloc_table (bfd *abfd,
+ symbols, dynamic))
+ return FALSE;
+
++ if (bed->slurp_secondary_relocs != NULL
++ && ! bed->slurp_secondary_relocs (abfd, asect, symbols))
++ return FALSE;
++
+ asect->relocation = relents;
+ return TRUE;
+ }
+diff -rup binutils.orig/bfd/elflink.c binutils-2.30/bfd/elflink.c
+--- binutils.orig/bfd/elflink.c 2020-02-12 13:31:20.338605611 +0000
++++ binutils-2.30/bfd/elflink.c 2020-02-12 13:31:33.834507560 +0000
+@@ -11514,6 +11514,10 @@ elf_final_link_free (bfd *obfd, struct e
+ }
+ }
+
++#define is_reloc_section(ESDO) \
++ ( (ESDO)->this_hdr.sh_type == SHT_REL \
++ || (ESDO)->this_hdr.sh_type == SHT_RELA)
++
+ /* Do the final step of an ELF link. */
+
+ bfd_boolean
+@@ -11685,8 +11689,7 @@ bfd_elf_final_link (bfd *abfd, struct bf
+ && elf_symtab_shndx_list (sec->owner) != NULL)
+ max_sym_shndx_count = sym_count;
+
+- if (esdo->this_hdr.sh_type == SHT_REL
+- || esdo->this_hdr.sh_type == SHT_RELA)
++ if (is_reloc_section (esdo))
+ /* Some backends use reloc_count in relocation sections
+ to count particular types of relocs. Of course,
+ reloc sections themselves can't have relocations. */
+@@ -12290,6 +12293,9 @@ bfd_elf_final_link (bfd *abfd, struct bf
+ struct bfd_elf_section_data *esdo = elf_section_data (o);
+ bfd_boolean sort;
+
++ if (esdo == NULL)
++ continue;
++
+ if ((o->flags & SEC_RELOC) == 0)
+ continue;
+
+diff -rup binutils.orig/bfd/elfxx-target.h binutils-2.30/bfd/elfxx-target.h
+--- binutils.orig/bfd/elfxx-target.h 2020-02-12 13:31:20.338605611 +0000
++++ binutils-2.30/bfd/elfxx-target.h 2020-02-12 13:31:33.834507560 +0000
+@@ -737,7 +737,7 @@
+ #endif
+
+ #ifndef elf_backend_copy_special_section_fields
+-#define elf_backend_copy_special_section_fields NULL
++#define elf_backend_copy_special_section_fields _bfd_elf_copy_special_section_fields
+ #endif
+
+ #ifndef elf_backend_compact_eh_encoding
+@@ -745,7 +745,23 @@
+ #endif
+
+ #ifndef elf_backend_cant_unwind_opcode
+-#define elf_backend_cant_unwind_opcode 0
++#define elf_backend_cant_unwind_opcode NULL
++#endif
++
++#ifndef elf_backend_init_secondary_reloc_section
++#define elf_backend_init_secondary_reloc_section _bfd_elf_init_secondary_reloc_section
++#endif
++
++#ifndef elf_backend_slurp_secondary_reloc_section
++#define elf_backend_slurp_secondary_reloc_section _bfd_elf_slurp_secondary_reloc_section
++#endif
++
++#ifndef elf_backend_write_secondary_reloc_section
++#define elf_backend_write_secondary_reloc_section _bfd_elf_write_secondary_reloc_section
++#endif
++
++#ifndef elf_backend_symbol_section_index
++#define elf_backend_symbol_section_index _bfd_elf_symbol_section_index
+ #endif
+
+ #ifndef elf_match_priority
+@@ -870,6 +886,10 @@ static struct elf_backend_data elfNN_bed
+ elf_backend_setup_gnu_properties,
+ elf_backend_compact_eh_encoding,
+ elf_backend_cant_unwind_opcode,
++ elf_backend_init_secondary_reloc_section,
++ elf_backend_slurp_secondary_reloc_section,
++ elf_backend_write_secondary_reloc_section,
++ elf_backend_symbol_section_index,
+ elf_backend_static_tls_alignment,
+ elf_backend_stack_align,
+ elf_backend_strtab_flags,
+Only in binutils-2.30/bfd: elfxx-target.h.orig
diff --git a/SOURCES/binutils-fix-testsuite-failures.patch b/SOURCES/binutils-fix-testsuite-failures.patch
index d441a6c..34c1f87 100644
--- a/SOURCES/binutils-fix-testsuite-failures.patch
+++ b/SOURCES/binutils-fix-testsuite-failures.patch
@@ -753,3 +753,16 @@ diff -rup binutils.orig/ld/testsuite/ld-x86-64/x86-64.exp binutils-2.30/ld/tests
run_cc_link_tests [list \
[list \
"Build plt-lib.so" \
+--- binutils.orig/ld/testsuite/ld-plugin/lto.exp 2019-12-02 10:22:47.019526080 +0000
++++ binutils-2.30/ld/testsuite/ld-plugin/lto.exp 2019-12-02 10:28:11.413354928 +0000
+@@ -33,8 +33,8 @@ global CFLAGS
+ global CXXFLAGS
+ set saved_CFLAGS "$CFLAGS"
+ set saved_CXXFLAGS "$CXXFLAGS"
+-regsub -all "(\\-Wp,)?-D_FORTIFY_SOURCE=\[0-9\]+" $CFLAGS "" CFLAGS
+-regsub -all "(\\-Wp,)?-D_FORTIFY_SOURCE=\[0-9\]+" $CXXFLAGS "" CXXFLAGS
++# regsub -all "(\\-Wp,)?-D_FORTIFY_SOURCE=\[0-9\]+" $CFLAGS "" CFLAGS
++# regsub -all "(\\-Wp,)?-D_FORTIFY_SOURCE=\[0-9\]+" $CXXFLAGS "" CXXFLAGS
+
+ proc restore_notify { } {
+ global saved_CFLAGS
diff --git a/SOURCES/binutils-improved-note-merging.patch b/SOURCES/binutils-improved-note-merging.patch
index ec3bee2..3715e73 100644
--- a/SOURCES/binutils-improved-note-merging.patch
+++ b/SOURCES/binutils-improved-note-merging.patch
@@ -1948,15 +1948,6 @@ diff -rupN binutils.orig/binutils/testsuite/binutils-all/objcopy.exp binutils-2.
free (merged);
continue;
}
-@@ -4519,7 +4519,7 @@ strip_main (int argc, char *argv[])
- int i;
- char *output_file = NULL;
-
-- merge_notes = TRUE;
-+ /* merge_notes = TRUE; */
-
- while ((c = getopt_long (argc, argv, "I:O:F:K:MN:R:o:sSpdgxXHhVvwDU",
- strip_options, (int *) 0)) != EOF)
--- binutils.orig/binutils/objcopy.c 2019-11-06 16:37:57.018843494 +0000
+++ binutils-2.30/binutils/objcopy.c 2019-11-06 16:40:52.669564222 +0000
@@ -2845,7 +2845,13 @@ copy_object (bfd *ibfd, bfd *obfd, const
diff --git a/SPECS/binutils.spec b/SPECS/binutils.spec
index b044eb0..fa871c9 100644
--- a/SPECS/binutils.spec
+++ b/SPECS/binutils.spec
@@ -69,7 +69,7 @@
Summary: A GNU collection of binary utilities
Name: %{?cross}binutils%{?_with_debug:-debug}
Version: 2.30
-Release: 68%{?dist}
+Release: 73%{?dist}
License: GPLv3+
URL: https://sourceware.org/binutils
@@ -416,6 +416,21 @@ Patch63: binutils-CVE-2019-1010204.patch
# Lifetime: Fixed in 2.34
Patch64: binutils-x86_JCC_Erratum.patch
+# Purpose: Fix a potential seg-fault in the BFD library when parsing
+# pathalogical debug_info sections.
+# Lifetime: Fixed in 2.34
+Patch65: binutils-CVE-2019-17451.patch
+
+# Purpose: Fix a memory exhaustion bug in the BFD library when parsing
+# corrupt DWARF debug information.
+# Lifetime: Fixed in 2.34
+Patch66: binutils-CVE-2019-17450.patch
+
+# Purpose: Allow the BFD library to handle the copying of files which
+# contain secondary reloc sections.
+# Lifetime: Fixed in 2.35
+Patch67: binutils-copy-multiple-relocs.patch
+
#----------------------------------------------------------------------------
Provides: bundled(libiberty)
@@ -604,6 +619,9 @@ using libelf instead of BFD.
%patch62 -p1
%patch63 -p1
%patch64 -p1
+%patch65 -p1
+%patch66 -p1
+%patch67 -p1
# We cannot run autotools as there is an exact requirement of autoconf-2.59.
# FIXME - this is no longer true. Maybe try reinstating autotool use ?
@@ -1041,7 +1059,23 @@ exit 0
#----------------------------------------------------------------------------
%changelog
-* Thu Nov 27 2019 Nick Clifton <nickc@redhat.com> - 2.30-68
+* Wed Feb 12 2020 Nick Clifton <nickc@redhat.com> - 2.30-73
+- Remove bogus assertion. (#1801879)
+
+* Wed Feb 12 2020 Nick Clifton <nickc@redhat.com> - 2.30-72
+- Allow the BFD library to handle the copying of files containing secondary reloc sections. (#1801879)
+
+* Tue Dec 03 2019 Nick Clifton <nickc@redhat.com> - 2.30-71
+- Fix a potential seg-fault in the BFD library when parsing pathalogical debug_info sections. (#1779245)
+- Fix a potential memory exhaustion in the BFD library when parsing corrupt DWARF debug information.
+
+* Mon Dec 02 2019 Nick Clifton <nickc@redhat.com> - 2.30-70
+- Re-enable strip merging build notes. (#1777760)
+
+* Mon Dec 02 2019 Nick Clifton <nickc@redhat.com> - 2.30-69
+- Fix linker testsuite failures triggered by annobin update.
+
+* Thu Nov 28 2019 Nick Clifton <nickc@redhat.com> - 2.30-68
- Backport H.J.Lu's patch to add a workaround for the JCC Errata to the assembler. (#1777002)
* Thu Nov 21 2019 Nick Clifton <nickc@redhat.com> - 2.30-67