From 3bbc82ebfefb9a45b43b70668629aaa62b006f70 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Apr 07 2020 09:15:27 +0000 Subject: import binutils-2.30-58.el8_1.2 --- 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-special-sections-in-groups.patch b/SOURCES/binutils-special-sections-in-groups.patch deleted file mode 100644 index 7010332..0000000 --- a/SOURCES/binutils-special-sections-in-groups.patch +++ /dev/null @@ -1,27 +0,0 @@ ---- binutils.orig/bfd/elf.c 2018-10-19 11:42:10.107277490 +0100 -+++ binutils-2.31.1/bfd/elf.c 2018-10-19 11:44:33.607105801 +0100 -@@ -828,7 +828,13 @@ setup_group (bfd *abfd, Elf_Internal_Shd - } - } - -- if (elf_group_name (newsect) == NULL) -+ if (elf_group_name (newsect) == NULL -+ /* OS specific sections might be in a group (eg ARM's ARM_EXIDX section) -+ but they will not have been added to the group because they do not -+ have contents that the ELF code in the BFD library knows how to -+ process. This is OK though - we rely upon the target backends to -+ handle these sections for us. */ -+ && hdr->sh_type < SHT_LOOS) - { - /* xgettext:c-format */ - _bfd_error_handler (_("%B: no group info for section '%A'"), -@@ -934,7 +940,8 @@ _bfd_elf_setup_sections (bfd *abfd) - else if (idx->shdr->bfd_section) - elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section; - else if (idx->shdr->sh_type != SHT_RELA -- && idx->shdr->sh_type != SHT_REL) -+ && idx->shdr->sh_type != SHT_REL -+ && idx->shdr->sh_type < SHT_LOOS) - { - /* There are some unknown sections in the group. */ - _bfd_error_handler diff --git a/SPECS/binutils.spec b/SPECS/binutils.spec index ea6f1ed..e5bfd3e 100644 --- a/SPECS/binutils.spec +++ b/SPECS/binutils.spec @@ -63,7 +63,7 @@ Summary: A GNU collection of binary utilities Name: %{?cross}binutils%{?_with_debug:-debug} Version: 2.30 -Release: 58%{?dist}.1 +Release: 58%{?dist}.2 License: GPLv3+ URL: https://sourceware.org/binutils @@ -385,7 +385,10 @@ Patch57: binutils-multiple-relocs-for-same-section.patch # Lifetime: Fixed in 2.34 Patch58: binutils-x86_JCC_Erratum.patch -Patch9999: binutils-special-sections-in-groups.patch +# Purpose: Allow the BFD library to handle the copying of files which +# contain secondary reloc sections. +# Lifetime: Fixed in 2.35 +Patch59: binutils-copy-multiple-relocs.patch #---------------------------------------------------------------------------- @@ -569,10 +572,7 @@ using libelf instead of BFD. %patch56 -p1 %patch57 -p1 %patch58 -p1 - -%ifarch %{arm} -%patch9999 -p1 -%endif +%patch59 -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 ? @@ -1005,6 +1005,9 @@ exit 0 #---------------------------------------------------------------------------- %changelog +* Tue Feb 18 2020 Nick Clifton - 2.30-58.2 +- Allow the BFD library to handle the copying of files containing secondary reloc sections. (#1803825) + * Mon Dec 16 2019 Nick Clifton - 2.30-58.1 - Backport H.J.Lu's patch to add a workaround for the JCC Errata to the assembler. (#1783957)