X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felf.c;h=1592183fae7f0990589dcf0bd2489ceb5a04cc0a;hb=315350be6598235df12a0190a5a4c21447eead36;hp=4258c6ee6a6b942c7d64d9e922fe2dcc8b448e33;hpb=e06efbf1c8198e25ef36a9787862f9720a94ba7b;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf.c b/bfd/elf.c index 4258c6ee6a..1592183fae 100644 --- a/bfd/elf.c +++ b/bfd/elf.c @@ -1,6 +1,6 @@ /* ELF executable support for BFD. - Copyright (C) 1993-2015 Free Software Foundation, Inc. + Copyright (C) 1993-2016 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -42,7 +42,7 @@ SECTION #include "elf-bfd.h" #include "libiberty.h" #include "safe-ctype.h" -#include "elf-linux-psinfo.h" +#include "elf-linux-core.h" #ifdef CORE_HEADER #include CORE_HEADER @@ -51,7 +51,7 @@ SECTION static int elf_sort_sections (const void *, const void *); static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *); static bfd_boolean prep_headers (bfd *); -static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ; +static bfd_boolean swap_out_syms (bfd *, struct elf_strtab_hash **, int) ; static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ; static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset); @@ -342,7 +342,7 @@ bfd_elf_string_from_elf_section (bfd *abfd, abfd, shindex); return NULL; } - + if (bfd_elf_get_str_section (abfd, shindex) == NULL) return NULL; } @@ -400,8 +400,34 @@ bfd_elf_get_elf_syms (bfd *ibfd, /* Normal syms might have section extension entries. */ shndx_hdr = NULL; - if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr) - shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr; + if (elf_symtab_shndx_list (ibfd) != NULL) + { + elf_section_list * entry; + Elf_Internal_Shdr **sections = elf_elfsections (ibfd); + + /* Find an index section that is linked to this symtab section. */ + for (entry = elf_symtab_shndx_list (ibfd); entry != NULL; entry = entry->next) + { + /* PR 20063. */ + if (entry->hdr.sh_link >= elf_numsections (ibfd)) + continue; + + if (sections[entry->hdr.sh_link] == symtab_hdr) + { + shndx_hdr = & entry->hdr; + break; + }; + } + + if (shndx_hdr == NULL) + { + if (symtab_hdr == & elf_symtab_hdr (ibfd)) + /* Not really accurate, but this was how the old code used to work. */ + shndx_hdr = & elf_symtab_shndx_list (ibfd)->hdr; + /* Otherwise we do nothing. The assumption is that + the index table will not be needed. */ + } + } /* Read the symbols. */ alloc_ext = NULL; @@ -817,8 +843,21 @@ _bfd_elf_setup_sections (bfd *abfd) for (i = 0; i < num_group; i++) { Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i]; - Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents; - unsigned int n_elt = shdr->sh_size / 4; + Elf_Internal_Group *idx; + unsigned int n_elt; + + /* PR binutils/18758: Beware of corrupt binaries with invalid group data. */ + if (shdr == NULL || shdr->bfd_section == NULL || shdr->contents == NULL) + { + (*_bfd_error_handler) + (_("%B: section group entry number %u is corrupt"), + abfd, i); + result = FALSE; + continue; + } + + idx = (Elf_Internal_Group *) shdr->contents; + n_elt = shdr->sh_size / 4; while (--n_elt != 0) if ((++idx)->shdr->bfd_section) @@ -855,6 +894,31 @@ bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec) return elf_next_in_group (sec) != NULL; } +static char * +convert_debug_to_zdebug (bfd *abfd, const char *name) +{ + unsigned int len = strlen (name); + char *new_name = bfd_alloc (abfd, len + 2); + if (new_name == NULL) + return NULL; + new_name[0] = '.'; + new_name[1] = 'z'; + memcpy (new_name + 2, name + 1, len); + return new_name; +} + +static char * +convert_zdebug_to_debug (bfd *abfd, const char *name) +{ + unsigned int len = strlen (name); + char *new_name = bfd_alloc (abfd, len); + if (new_name == NULL) + return NULL; + new_name[0] = '.'; + memcpy (new_name + 1, name + 2, len - 1); + return new_name; +} + /* Make a BFD section from an ELF section. We store a pointer to the BFD section in the bfd_section field of the header. */ @@ -912,9 +976,9 @@ _bfd_elf_make_section_from_shdr (bfd *abfd, { flags |= SEC_MERGE; newsect->entsize = hdr->sh_entsize; - if ((hdr->sh_flags & SHF_STRINGS) != 0) - flags |= SEC_STRINGS; } + if ((hdr->sh_flags & SHF_STRINGS) != 0) + flags |= SEC_STRINGS; if (hdr->sh_flags & SHF_GROUP) if (!setup_group (abfd, hdr, newsect)) return FALSE; @@ -1041,11 +1105,12 @@ _bfd_elf_make_section_from_shdr (bfd *abfd, || (name[1] == 'z' && name[7] == '_'))) { enum { nothing, compress, decompress } action = nothing; - char *new_name; int compression_header_size; + bfd_size_type uncompressed_size; bfd_boolean compressed = bfd_is_section_compressed_with_header (abfd, newsect, - &compression_header_size); + &compression_header_size, + &uncompressed_size); if (compressed) { @@ -1061,6 +1126,7 @@ _bfd_elf_make_section_from_shdr (bfd *abfd, if (newsect->size != 0 && (abfd->flags & BFD_COMPRESS) && compression_header_size >= 0 + && uncompressed_size > 0 && (!compressed || ((compression_header_size > 0) != ((abfd->flags & BFD_COMPRESS_GABI) != 0)))) @@ -1090,48 +1156,33 @@ _bfd_elf_make_section_from_shdr (bfd *abfd, } } - new_name = NULL; - if (action == decompress - || (action == compress - && (abfd->flags & BFD_COMPRESS_GABI) != 0)) - { - if (name[1] == 'z') - { - unsigned int len = strlen (name); - - new_name = bfd_alloc (abfd, len); - if (new_name == NULL) - return FALSE; - new_name[0] = '.'; - memcpy (new_name + 1, name + 2, len - 1); - } - } - else if (action == compress - && newsect->compress_status == COMPRESS_SECTION_DONE) + if (abfd->is_linker_input) { - /* PR binutils/18087: Compression does not always make a section - smaller. So only rename the section when compression has - actually taken place. */ - if (name[1] != 'z') + if (name[1] == 'z' + && (action == decompress + || (action == compress + && (abfd->flags & BFD_COMPRESS_GABI) != 0))) { - unsigned int len = strlen (name); - - new_name = bfd_alloc (abfd, len + 2); + /* Convert section name from .zdebug_* to .debug_* so + that linker will consider this section as a debug + section. */ + char *new_name = convert_zdebug_to_debug (abfd, name); if (new_name == NULL) return FALSE; - new_name[0] = '.'; - new_name[1] = 'z'; - memcpy (new_name + 2, name + 1, len); + bfd_rename_section (abfd, newsect, new_name); } } - if (new_name != NULL) - bfd_rename_section (abfd, newsect, new_name); + else + /* For objdump, don't rename the section. For objcopy, delay + section rename to elf_fake_sections. */ + newsect->flags |= SEC_ELF_RENAME; } return TRUE; } -const char *const bfd_elf_section_type_names[] = { +const char *const bfd_elf_section_type_names[] = +{ "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB", "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE", "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM", @@ -1168,14 +1219,160 @@ bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED, return bfd_reloc_continue; } +/* Returns TRUE if section A matches section B. + Names, addresses and links may be different, but everything else + should be the same. */ + +static bfd_boolean +section_match (const Elf_Internal_Shdr * a, + const Elf_Internal_Shdr * b) +{ + return + a->sh_type == b->sh_type + && (a->sh_flags & ~ SHF_INFO_LINK) + == (b->sh_flags & ~ SHF_INFO_LINK) + && a->sh_addralign == b->sh_addralign + && a->sh_size == b->sh_size + && a->sh_entsize == b->sh_entsize + /* FIXME: Check sh_addr ? */ + ; +} + +/* Find a section in OBFD that has the same characteristics + as IHEADER. Return the index of this section or SHN_UNDEF if + none can be found. Check's section HINT first, as this is likely + to be the correct section. */ + +static unsigned int +find_link (const bfd * obfd, const Elf_Internal_Shdr * iheader, const unsigned int hint) +{ + Elf_Internal_Shdr ** oheaders = elf_elfsections (obfd); + unsigned int i; + + if (section_match (oheaders[hint], iheader)) + return hint; + + for (i = 1; i < elf_numsections (obfd); i++) + { + Elf_Internal_Shdr * oheader = oheaders[i]; + + if (section_match (oheader, iheader)) + /* FIXME: Do we care if there is a potential for + multiple matches ? */ + return i; + } + + return SHN_UNDEF; +} + +/* PR 19938: Attempt to set the ELF section header fields of an OS or + Processor specific section, based upon a matching input section. + Returns TRUE upon success, FALSE otherwise. */ + +static bfd_boolean +copy_special_section_fields (const bfd *ibfd, + bfd *obfd, + const Elf_Internal_Shdr *iheader, + Elf_Internal_Shdr *oheader, + const unsigned int secnum) +{ + const struct elf_backend_data *bed = get_elf_backend_data (obfd); + const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd); + bfd_boolean changed = FALSE; + unsigned int sh_link; + + if (oheader->sh_type == SHT_NOBITS) + { + /* This is a feature for objcopy --only-keep-debug: + When a section's type is changed to NOBITS, we preserve + the sh_link and sh_info fields so that they can be + matched up with the original. + + Note: Strictly speaking these assignments are wrong. + The sh_link and sh_info fields should point to the + relevent sections in the output BFD, which may not be in + the same location as they were in the input BFD. But + the whole point of this action is to preserve the + original values of the sh_link and sh_info fields, so + that they can be matched up with the section headers in + the original file. So strictly speaking we may be + creating an invalid ELF file, but it is only for a file + that just contains debug info and only for sections + without any contents. */ + if (oheader->sh_link == 0) + oheader->sh_link = iheader->sh_link; + if (oheader->sh_info == 0) + oheader->sh_info = iheader->sh_info; + return TRUE; + } + + /* Allow the target a chance to decide how these fields should be set. */ + if (bed->elf_backend_copy_special_section_fields != NULL + && bed->elf_backend_copy_special_section_fields + (ibfd, obfd, iheader, oheader)) + return TRUE; + + /* We have an iheader which might match oheader, and which has non-zero + sh_info and/or sh_link fields. Attempt to follow those links and find + the section in the output bfd which corresponds to the linked section + in the input bfd. */ + if (iheader->sh_link != SHN_UNDEF) + { + sh_link = find_link (obfd, iheaders[iheader->sh_link], iheader->sh_link); + if (sh_link != SHN_UNDEF) + { + oheader->sh_link = sh_link; + changed = TRUE; + } + else + /* FIXME: Should we install iheader->sh_link + if we could not find a match ? */ + (* _bfd_error_handler) + (_("%B: Failed to find link section for section %d"), obfd, secnum); + } + + if (iheader->sh_info) + { + /* The sh_info field can hold arbitrary information, but if the + SHF_LINK_INFO flag is set then it should be interpreted as a + section index. */ + if (iheader->sh_flags & SHF_INFO_LINK) + { + sh_link = find_link (obfd, iheaders[iheader->sh_info], + iheader->sh_info); + if (sh_link != SHN_UNDEF) + oheader->sh_flags |= SHF_INFO_LINK; + } + else + /* No idea what it means - just copy it. */ + sh_link = iheader->sh_info; + + if (sh_link != SHN_UNDEF) + { + oheader->sh_info = sh_link; + changed = TRUE; + } + else + (* _bfd_error_handler) + (_("%B: Failed to find info section for section %d"), obfd, secnum); + } + + return changed; +} + /* Copy the program header and other data from one object module to another. */ bfd_boolean _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { + const Elf_Internal_Shdr **iheaders = (const Elf_Internal_Shdr **) elf_elfsections (ibfd); + Elf_Internal_Shdr **oheaders = elf_elfsections (obfd); + const struct elf_backend_data *bed; + unsigned int i; + if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour - || bfd_get_flavour (obfd) != bfd_target_elf_flavour) + || bfd_get_flavour (obfd) != bfd_target_elf_flavour) return TRUE; if (!elf_flags_init (obfd)) @@ -1190,8 +1387,105 @@ _bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) elf_elfheader (obfd)->e_ident[EI_OSABI] = elf_elfheader (ibfd)->e_ident[EI_OSABI]; + /* If set, copy the EI_ABIVERSION field. */ + if (elf_elfheader (ibfd)->e_ident[EI_ABIVERSION]) + elf_elfheader (obfd)->e_ident[EI_ABIVERSION] + = elf_elfheader (ibfd)->e_ident[EI_ABIVERSION]; + /* Copy object attributes. */ _bfd_elf_copy_obj_attributes (ibfd, obfd); + + if (iheaders == NULL || oheaders == NULL) + return TRUE; + + bed = get_elf_backend_data (obfd); + + /* Possibly copy other fields in the section header. */ + for (i = 1; i < elf_numsections (obfd); i++) + { + unsigned int j; + Elf_Internal_Shdr * oheader = oheaders[i]; + + /* Ignore ordinary sections. SHT_NOBITS sections are considered however + because of a special case need for generating separate debug info + files. See below for more details. */ + if (oheader == NULL + || (oheader->sh_type != SHT_NOBITS + && oheader->sh_type < SHT_LOOS)) + continue; + + /* Ignore empty sections, and sections whose + fields have already been initialised. */ + if (oheader->sh_size == 0 + || (oheader->sh_info != 0 && oheader->sh_link != 0)) + continue; + + /* Scan for the matching section in the input bfd. + First we try for a direct mapping between the input and output sections. */ + for (j = 1; j < elf_numsections (ibfd); j++) + { + const Elf_Internal_Shdr * iheader = iheaders[j]; + + if (iheader == NULL) + continue; + + if (oheader->bfd_section != NULL + && iheader->bfd_section != NULL + && iheader->bfd_section->output_section != NULL + && iheader->bfd_section->output_section == oheader->bfd_section) + { + /* We have found a connection from the input section to the + output section. Attempt to copy the header fields. If + this fails then do not try any further sections - there + should only be a one-to-one mapping between input and output. */ + if (! copy_special_section_fields (ibfd, obfd, iheader, oheader, i)) + j = elf_numsections (ibfd); + break; + } + } + + if (j < elf_numsections (ibfd)) + continue; + + /* That failed. So try to deduce the corresponding input section. + Unfortunately we cannot compare names as the output string table + is empty, so instead we check size, address and type. */ + for (j = 1; j < elf_numsections (ibfd); j++) + { + const Elf_Internal_Shdr * iheader = iheaders[j]; + + if (iheader == NULL) + continue; + + /* Try matching fields in the input section's header. + Since --only-keep-debug turns all non-debug sections into + SHT_NOBITS sections, the output SHT_NOBITS type matches any + input type. */ + if ((oheader->sh_type == SHT_NOBITS + || iheader->sh_type == oheader->sh_type) + && (iheader->sh_flags & ~ SHF_INFO_LINK) + == (oheader->sh_flags & ~ SHF_INFO_LINK) + && iheader->sh_addralign == oheader->sh_addralign + && iheader->sh_entsize == oheader->sh_entsize + && iheader->sh_size == oheader->sh_size + && iheader->sh_addr == oheader->sh_addr + && (iheader->sh_info != oheader->sh_info + || iheader->sh_link != oheader->sh_link)) + { + if (copy_special_section_fields (ibfd, obfd, iheader, oheader, i)) + break; + } + } + + if (j == elf_numsections (ibfd) && oheader->sh_type >= SHT_LOOS) + { + /* 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); + } + } + return TRUE; } @@ -1599,29 +1893,6 @@ bfd_elf_print_symbol (bfd *abfd, break; } } - -/* Allocate an ELF string table--force the first byte to be zero. */ - -struct bfd_strtab_hash * -_bfd_elf_stringtab_init (void) -{ - struct bfd_strtab_hash *ret; - - ret = _bfd_stringtab_init (); - if (ret != NULL) - { - bfd_size_type loc; - - loc = _bfd_stringtab_add (ret, "", TRUE, FALSE); - BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1); - if (loc == (bfd_size_type) -1) - { - _bfd_stringtab_free (ret); - ret = NULL; - } - } - return ret; -} /* ELF .o/exec file reading */ @@ -1768,10 +2039,18 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex) goto success; } - BFD_ASSERT (elf_onesymtab (abfd) == 0); + /* PR 18854: A binary might contain more than one symbol table. + Unusual, but possible. Warn, but continue. */ + if (elf_onesymtab (abfd) != 0) + { + (*_bfd_error_handler) + (_("%B: warning: multiple symbol tables detected - ignoring the table in section %u"), + abfd, shindex); + goto success; + } elf_onesymtab (abfd) = shindex; - elf_tdata (abfd)->symtab_hdr = *hdr; - elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr; + elf_symtab_hdr (abfd) = *hdr; + elf_elfsections (abfd)[shindex] = hdr = & elf_symtab_hdr (abfd); abfd->flags |= HAS_SYMS; /* Sometimes a shared object will map in the symbol table. If @@ -1789,30 +2068,39 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex) /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we can't read symbols without that section loaded as well. It is most likely specified by the next section header. */ - if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex) - { - unsigned int i, num_sec; + { + elf_section_list * entry; + unsigned int i, num_sec; - num_sec = elf_numsections (abfd); - for (i = shindex + 1; i < num_sec; i++) + for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next) + if (entry->hdr.sh_link == shindex) + goto success; + + num_sec = elf_numsections (abfd); + for (i = shindex + 1; i < num_sec; i++) + { + Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; + + if (hdr2->sh_type == SHT_SYMTAB_SHNDX + && hdr2->sh_link == shindex) + break; + } + + if (i == num_sec) + for (i = 1; i < shindex; i++) { Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; + if (hdr2->sh_type == SHT_SYMTAB_SHNDX && hdr2->sh_link == shindex) break; } - if (i == num_sec) - for (i = 1; i < shindex; i++) - { - Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i]; - if (hdr2->sh_type == SHT_SYMTAB_SHNDX - && hdr2->sh_link == shindex) - break; - } - if (i != shindex) - ret = bfd_section_from_shdr (abfd, i); - } - goto success; + + if (i != shindex) + ret = bfd_section_from_shdr (abfd, i); + /* else FIXME: we have failed to find the symbol table - should we issue an error ? */ + goto success; + } case SHT_DYNSYM: /* A dynamic symbol table. */ if (elf_dynsymtab (abfd) == shindex) @@ -1833,7 +2121,15 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex) goto success; } - BFD_ASSERT (elf_dynsymtab (abfd) == 0); + /* PR 18854: A binary might contain more than one dynamic symbol table. + Unusual, but possible. Warn, but continue. */ + if (elf_dynsymtab (abfd) != 0) + { + (*_bfd_error_handler) + (_("%B: warning: multiple dynamic symbol tables detected - ignoring the table in section %u"), + abfd, shindex); + goto success; + } elf_dynsymtab (abfd) = shindex; elf_tdata (abfd)->dynsymtab_hdr = *hdr; elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr; @@ -1845,14 +2141,23 @@ bfd_section_from_shdr (bfd *abfd, unsigned int shindex) goto success; case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections. */ - if (elf_symtab_shndx (abfd) == shindex) - goto success; + { + elf_section_list * entry; - BFD_ASSERT (elf_symtab_shndx (abfd) == 0); - elf_symtab_shndx (abfd) = shindex; - elf_tdata (abfd)->symtab_shndx_hdr = *hdr; - elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr; - goto success; + for (entry = elf_symtab_shndx_list (abfd); entry != NULL; entry = entry->next) + if (entry->ndx == shindex) + goto success; + + entry = bfd_alloc (abfd, sizeof * entry); + if (entry == NULL) + goto fail; + entry->ndx = shindex; + entry->hdr = * hdr; + entry->next = elf_symtab_shndx_list (abfd); + elf_symtab_shndx_list (abfd) = entry; + elf_elfsections (abfd)[shindex] = & entry->hdr; + goto success; + } case SHT_STRTAB: /* A string table. */ if (hdr->bfd_section != NULL) @@ -2681,6 +2986,27 @@ _bfd_elf_single_rel_hdr (asection *sec) return elf_section_data (sec)->rela.hdr; } +static bfd_boolean +_bfd_elf_set_reloc_sh_name (bfd *abfd, + Elf_Internal_Shdr *rel_hdr, + const char *sec_name, + bfd_boolean use_rela_p) +{ + char *name = (char *) bfd_alloc (abfd, + sizeof ".rela" + strlen (sec_name)); + if (name == NULL) + return FALSE; + + sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", sec_name); + rel_hdr->sh_name = + (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name, + FALSE); + if (rel_hdr->sh_name == (unsigned int) -1) + return FALSE; + + return TRUE; +} + /* Allocate and initialize a section-header for a new reloc section, containing relocations against ASECT. It is stored in RELDATA. If USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL @@ -2689,11 +3015,11 @@ _bfd_elf_single_rel_hdr (asection *sec) static bfd_boolean _bfd_elf_init_reloc_shdr (bfd *abfd, struct bfd_elf_section_reloc_data *reldata, - asection *asect, - bfd_boolean use_rela_p) + const char *sec_name, + bfd_boolean use_rela_p, + bfd_boolean delay_st_name_p) { Elf_Internal_Shdr *rel_hdr; - char *name; const struct elf_backend_data *bed = get_elf_backend_data (abfd); bfd_size_type amt; @@ -2702,15 +3028,10 @@ _bfd_elf_init_reloc_shdr (bfd *abfd, rel_hdr = bfd_zalloc (abfd, amt); reldata->hdr = rel_hdr; - amt = sizeof ".rela" + strlen (asect->name); - name = (char *) bfd_alloc (abfd, amt); - if (name == NULL) - return FALSE; - sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name); - rel_hdr->sh_name = - (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name, - FALSE); - if (rel_hdr->sh_name == (unsigned int) -1) + if (delay_st_name_p) + rel_hdr->sh_name = (unsigned int) -1; + else if (!_bfd_elf_set_reloc_sh_name (abfd, rel_hdr, sec_name, + use_rela_p)) return FALSE; rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL; rel_hdr->sh_entsize = (use_rela_p @@ -2753,6 +3074,7 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) Elf_Internal_Shdr *this_hdr; unsigned int sh_type; const char *name = asect->name; + bfd_boolean delay_st_name_p = FALSE; if (arg->failed) { @@ -2763,42 +3085,72 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) this_hdr = &esd->this_hdr; - /* For linking, compress DWARF debug sections with names: .debug_*. */ - if (arg->link_info - && (arg->link_info->compress_debug & COMPRESS_DEBUG) - && (asect->flags & SEC_DEBUGGING) - && name[1] == 'd' - && name[6] == '_') + if (arg->link_info) { - /* Set SEC_ELF_COMPRESS to indicate this section should be - compressed. */ - asect->flags |= SEC_ELF_COMPRESS; + /* ld: compress DWARF debug sections with names: .debug_*. */ + if ((arg->link_info->compress_debug & COMPRESS_DEBUG) + && (asect->flags & SEC_DEBUGGING) + && name[1] == 'd' + && name[6] == '_') + { + /* Set SEC_ELF_COMPRESS to indicate this section should be + compressed. */ + asect->flags |= SEC_ELF_COMPRESS; - if (arg->link_info->compress_debug != COMPRESS_DEBUG_GABI_ZLIB) + /* If this section will be compressed, delay adding setion + name to section name section after it is compressed in + _bfd_elf_assign_file_positions_for_non_load. */ + delay_st_name_p = TRUE; + } + } + else if ((asect->flags & SEC_ELF_RENAME)) + { + /* objcopy: rename output DWARF debug section. */ + if ((abfd->flags & (BFD_DECOMPRESS | BFD_COMPRESS_GABI))) + { + /* When we decompress or compress with SHF_COMPRESSED, + convert section name from .zdebug_* to .debug_* if + needed. */ + if (name[1] == 'z') + { + char *new_name = convert_zdebug_to_debug (abfd, name); + if (new_name == NULL) + { + arg->failed = TRUE; + return; + } + name = new_name; + } + } + else if (asect->compress_status == COMPRESS_SECTION_DONE) { - /* If SHF_COMPRESSED isn't used, rename compressed DWARF - debug section to .zdebug_*. */ - unsigned int len = strlen (name); - char *new_name = bfd_alloc (abfd, len + 2); + /* PR binutils/18087: Compression does not always make a + section smaller. So only rename the section when + compression has actually taken place. If input section + name is .zdebug_*, we should never compress it again. */ + char *new_name = convert_debug_to_zdebug (abfd, name); if (new_name == NULL) { arg->failed = TRUE; return; } - new_name[0] = '.'; - new_name[1] = 'z'; - memcpy (new_name + 2, name + 1, len); - bfd_rename_section (abfd, asect, new_name); - name = asect->name; + BFD_ASSERT (name[1] != 'z'); + name = new_name; } } - this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), - name, FALSE); - if (this_hdr->sh_name == (unsigned int) -1) + if (delay_st_name_p) + this_hdr->sh_name = (unsigned int) -1; + else { - arg->failed = TRUE; - return; + this_hdr->sh_name + = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), + name, FALSE); + if (this_hdr->sh_name == (unsigned int) -1) + { + arg->failed = TRUE; + return; + } } /* Don't clear sh_flags. Assembler may set additional bits. */ @@ -2933,9 +3285,9 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) { this_hdr->sh_flags |= SHF_MERGE; this_hdr->sh_entsize = asect->entsize; - if ((asect->flags & SEC_STRINGS) != 0) - this_hdr->sh_flags |= SHF_STRINGS; } + if ((asect->flags & SEC_STRINGS) != 0) + this_hdr->sh_flags |= SHF_STRINGS; if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL) this_hdr->sh_flags |= SHF_GROUP; if ((asect->flags & SEC_THREAD_LOCAL) != 0) @@ -2969,16 +3321,19 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) if (arg->link_info /* Do the normal setup if we wouldn't create any sections here. */ && esd->rel.count + esd->rela.count > 0 - && (arg->link_info->relocatable || arg->link_info->emitrelocations)) + && (bfd_link_relocatable (arg->link_info) + || arg->link_info->emitrelocations)) { if (esd->rel.count && esd->rel.hdr == NULL - && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE)) + && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, name, FALSE, + delay_st_name_p)) { arg->failed = TRUE; return; } if (esd->rela.count && esd->rela.hdr == NULL - && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE)) + && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, name, TRUE, + delay_st_name_p)) { arg->failed = TRUE; return; @@ -2987,8 +3342,9 @@ elf_fake_sections (bfd *abfd, asection *asect, void *fsarg) else if (!_bfd_elf_init_reloc_shdr (abfd, (asect->use_rela_p ? &esd->rela : &esd->rel), - asect, - asect->use_rela_p)) + name, + asect->use_rela_p, + delay_st_name_p)) arg->failed = TRUE; } @@ -3173,7 +3529,7 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) { struct elf_obj_tdata *t = elf_tdata (abfd); asection *sec; - unsigned int section_number, secn; + unsigned int section_number; Elf_Internal_Shdr **i_shdrp; struct bfd_elf_section_data *d; bfd_boolean need_symtab; @@ -3183,8 +3539,10 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd)); /* SHT_GROUP sections are in relocatable files only. */ - if (link_info == NULL || link_info->relocatable) + if (link_info == NULL || bfd_link_relocatable (link_info)) { + bfd_size_type reloc_count = 0; + /* Put SHT_GROUP sections first. */ for (sec = abfd->sections; sec != NULL; sec = sec->next) { @@ -3201,7 +3559,14 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) else d->this_idx = section_number++; } + + /* Count relocations. */ + reloc_count += sec->reloc_count; } + + /* Clear HAS_RELOC if there are no relocations. */ + if (reloc_count == 0) + abfd->flags &= ~HAS_RELOC; } for (sec = abfd->sections; sec; sec = sec->next) @@ -3210,11 +3575,13 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) if (d->this_hdr.sh_type != SHT_GROUP) d->this_idx = section_number++; - _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name); + if (d->this_hdr.sh_name != (unsigned int) -1) + _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name); if (d->rel.hdr) { d->rel.idx = section_number++; - _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name); + if (d->rel.hdr->sh_name != (unsigned int) -1) + _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name); } else d->rel.idx = 0; @@ -3222,7 +3589,8 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) if (d->rela.hdr) { d->rela.idx = section_number++; - _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name); + if (d->rela.hdr->sh_name != (unsigned int) -1) + _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name); } else d->rela.idx = 0; @@ -3242,11 +3610,17 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name); if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF)) { - elf_symtab_shndx (abfd) = section_number++; - t->symtab_shndx_hdr.sh_name + elf_section_list * entry; + + BFD_ASSERT (elf_symtab_shndx_list (abfd) == NULL); + + entry = bfd_zalloc (abfd, sizeof * entry); + entry->ndx = section_number++; + elf_symtab_shndx_list (abfd) = entry; + entry->hdr.sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), ".symtab_shndx", FALSE); - if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1) + if (entry->hdr.sh_name == (unsigned int) -1) return FALSE; } elf_strtab_sec (abfd) = section_number++; @@ -3260,9 +3634,6 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) return FALSE; } - _bfd_elf_strtab_finalize (elf_shstrtab (abfd)); - t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); - elf_numsections (abfd) = section_number; elf_elfheader (abfd)->e_shnum = section_number; @@ -3289,8 +3660,10 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr; if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF)) { - i_shdrp[elf_symtab_shndx (abfd)] = &t->symtab_shndx_hdr; - t->symtab_shndx_hdr.sh_link = elf_onesymtab (abfd); + elf_section_list * entry = elf_symtab_shndx_list (abfd); + BFD_ASSERT (entry != NULL); + i_shdrp[entry->ndx] = & entry->hdr; + entry->hdr.sh_link = elf_onesymtab (abfd); } i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr; t->symtab_hdr.sh_link = elf_strtab_sec (abfd); @@ -3478,12 +3851,10 @@ assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info) } } - for (secn = 1; secn < section_number; ++secn) - if (i_shdrp[secn] == NULL) - i_shdrp[secn] = i_shdrp[0]; - else - i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd), - i_shdrp[secn]->sh_name); + /* Delay setting sh_name to _bfd_elf_write_object_contents so that + _bfd_elf_assign_file_positions_for_non_load can convert DWARF + debug section name from .debug_* to .zdebug_* if needed. */ + return TRUE; } @@ -3534,7 +3905,7 @@ elf_map_symbols (bfd *abfd, unsigned int *pnum_locals) unsigned int num_globals = 0; unsigned int num_locals2 = 0; unsigned int num_globals2 = 0; - int max_index = 0; + unsigned int max_index = 0; unsigned int idx; asection *asect; asymbol **new_syms; @@ -3683,7 +4054,7 @@ _bfd_elf_compute_section_file_positions (bfd *abfd, const struct elf_backend_data *bed = get_elf_backend_data (abfd); struct fake_section_arg fsargs; bfd_boolean failed; - struct bfd_strtab_hash *strtab = NULL; + struct elf_strtab_hash *strtab = NULL; Elf_Internal_Shdr *shstrtab_hdr; bfd_boolean need_symtab; @@ -3734,13 +4105,13 @@ _bfd_elf_compute_section_file_positions (bfd *abfd, shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr; /* sh_name was set in prep_headers. */ shstrtab_hdr->sh_type = SHT_STRTAB; - shstrtab_hdr->sh_flags = 0; + shstrtab_hdr->sh_flags = bed->elf_strtab_flags; shstrtab_hdr->sh_addr = 0; - shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); + /* sh_size is set in _bfd_elf_assign_file_positions_for_non_load. */ shstrtab_hdr->sh_entsize = 0; shstrtab_hdr->sh_link = 0; shstrtab_hdr->sh_info = 0; - /* sh_offset is set in assign_file_positions_except_relocs. */ + /* sh_offset is set in _bfd_elf_assign_file_positions_for_non_load. */ shstrtab_hdr->sh_addralign = 1; if (!assign_file_positions_except_relocs (abfd, link_info)) @@ -3753,12 +4124,16 @@ _bfd_elf_compute_section_file_positions (bfd *abfd, off = elf_next_file_pos (abfd); - hdr = &elf_tdata (abfd)->symtab_hdr; + hdr = & elf_symtab_hdr (abfd); off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); - hdr = &elf_tdata (abfd)->symtab_shndx_hdr; - if (hdr->sh_size != 0) - off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); + if (elf_symtab_shndx_list (abfd) != NULL) + { + hdr = & elf_symtab_shndx_list (abfd)->hdr; + if (hdr->sh_size != 0) + off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); + /* FIXME: What about other symtab_shndx sections in the list ? */ + } hdr = &elf_tdata (abfd)->strtab_hdr; off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); @@ -3768,9 +4143,9 @@ _bfd_elf_compute_section_file_positions (bfd *abfd, /* Now that we know where the .strtab section goes, write it out. */ if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0 - || ! _bfd_stringtab_emit (abfd, strtab)) + || ! _bfd_elf_strtab_emit (abfd, strtab)) return FALSE; - _bfd_stringtab_free (strtab); + _bfd_elf_strtab_free (strtab); } abfd->output_has_begun = TRUE; @@ -4184,11 +4559,18 @@ _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info) new_segment = TRUE; } else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0 - && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0) + && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0 + && ((abfd->flags & D_PAGED) == 0 + || (((last_hdr->lma + last_size - 1) & -maxpagesize) + != (hdr->lma & -maxpagesize)))) { - /* We don't want to put a loadable section after a - nonloadable section in the same segment. - Consider .tbss sections as loadable for this purpose. */ + /* We don't want to put a loaded section after a + nonloaded (ie. bss style) section in the same segment + as that will force the non-loaded section to be loaded. + Consider .tbss sections as loaded for this purpose. + However, like the writable/non-writable case below, + if they are on the same page then they must be put + in the same segment. */ new_segment = TRUE; } else if ((abfd->flags & D_PAGED) == 0) @@ -4459,9 +4841,6 @@ _bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info) goto error_return; m->next = NULL; m->p_type = PT_GNU_RELRO; - m->p_flags = PF_R; - m->p_flags_valid = 1; - *pm = m; pm = &m->next; } @@ -5149,8 +5528,10 @@ assign_file_positions_for_non_load_sections (bfd *abfd, && (hdr->bfd_section->flags & SEC_ELF_COMPRESS)) /* Compress DWARF debug sections. */ || hdr == i_shdrpp[elf_onesymtab (abfd)] - || hdr == i_shdrpp[elf_symtab_shndx (abfd)] - || hdr == i_shdrpp[elf_strtab_sec (abfd)]) + || (elf_symtab_shndx_list (abfd) != NULL + && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx]) + || hdr == i_shdrpp[elf_strtab_sec (abfd)] + || hdr == i_shdrpp[elf_shstrtab_sec (abfd)]) hdr->sh_offset = -1; else off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE); @@ -5291,7 +5672,7 @@ assign_file_positions_for_non_load_sections (bfd *abfd, if (!m->p_align_valid) p->p_align = 1; if (!m->p_flags_valid) - p->p_flags = (lp->p_flags & ~PF_W); + p->p_flags = PF_R; } else { @@ -5313,7 +5694,7 @@ assign_file_positions_for_non_load_sections (bfd *abfd, { if (m->includes_filehdr || m->includes_phdrs) { - /* PR 17512: file: 2195325e. */ + /* PR 17512: file: 2195325e. */ (*_bfd_error_handler) (_("%B: warning: non-load segment includes file header and/or program header"), abfd); @@ -5354,6 +5735,15 @@ assign_file_positions_for_non_load_sections (bfd *abfd, return TRUE; } +static elf_section_list * +find_section_in_list (unsigned int i, elf_section_list * list) +{ + for (;list != NULL; list = list->next) + if (list->ndx == i) + break; + return list; +} + /* Work out the file positions of all the sections. This is called by _bfd_elf_compute_section_file_positions. All the section sizes and VMAs must be known before this is called. @@ -5402,8 +5792,10 @@ assign_file_positions_except_relocs (bfd *abfd, && (hdr->bfd_section->flags & SEC_ELF_COMPRESS)) /* Compress DWARF debug sections. */ || i == elf_onesymtab (abfd) - || i == elf_symtab_shndx (abfd) - || i == elf_strtab_sec (abfd)) + || (elf_symtab_shndx_list (abfd) != NULL + && hdr == i_shdrpp[elf_symtab_shndx_list (abfd)->ndx]) + || i == elf_strtab_sec (abfd) + || i == elf_shstrtab_sec (abfd)) { hdr->sh_offset = -1; } @@ -5433,9 +5825,7 @@ assign_file_positions_except_relocs (bfd *abfd, } /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */ - if (link_info != NULL - && link_info->executable - && link_info->shared) + if (link_info != NULL && bfd_link_pie (link_info)) { unsigned int num_segments = elf_elfheader (abfd)->e_phnum; Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr; @@ -5559,6 +5949,7 @@ _bfd_elf_assign_file_positions_for_non_load (bfd *abfd) { file_ptr off; Elf_Internal_Shdr **shdrpp, **end_shdrpp; + Elf_Internal_Shdr *shdrp; Elf_Internal_Ehdr *i_ehdrp; const struct elf_backend_data *bed; @@ -5568,26 +5959,59 @@ _bfd_elf_assign_file_positions_for_non_load (bfd *abfd) end_shdrpp = shdrpp + elf_numsections (abfd); for (shdrpp++; shdrpp < end_shdrpp; shdrpp++) { - Elf_Internal_Shdr *shdrp; - shdrp = *shdrpp; if (shdrp->sh_offset == -1) { + asection *sec = shdrp->bfd_section; bfd_boolean is_rel = (shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA); if (is_rel - || (shdrp->bfd_section != NULL - && (shdrp->bfd_section->flags & SEC_ELF_COMPRESS))) + || (sec != NULL && (sec->flags & SEC_ELF_COMPRESS))) { if (!is_rel) { + const char *name = sec->name; + struct bfd_elf_section_data *d; + /* Compress DWARF debug sections. */ - if (!bfd_compress_section (abfd, shdrp->bfd_section, + if (!bfd_compress_section (abfd, sec, shdrp->contents)) return FALSE; + + if (sec->compress_status == COMPRESS_SECTION_DONE + && (abfd->flags & BFD_COMPRESS_GABI) == 0) + { + /* If section is compressed with zlib-gnu, convert + section name from .debug_* to .zdebug_*. */ + char *new_name + = convert_debug_to_zdebug (abfd, name); + if (new_name == NULL) + return FALSE; + name = new_name; + } + /* Add setion name to section name section. */ + if (shdrp->sh_name != (unsigned int) -1) + abort (); + shdrp->sh_name + = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), + name, FALSE); + d = elf_section_data (sec); + + /* Add reloc setion name to section name section. */ + if (d->rel.hdr + && !_bfd_elf_set_reloc_sh_name (abfd, + d->rel.hdr, + name, FALSE)) + return FALSE; + if (d->rela.hdr + && !_bfd_elf_set_reloc_sh_name (abfd, + d->rela.hdr, + name, TRUE)) + return FALSE; + /* Update section size and contents. */ - shdrp->sh_size = shdrp->bfd_section->size; - shdrp->contents = shdrp->bfd_section->contents; + shdrp->sh_size = sec->size; + shdrp->contents = sec->contents; shdrp->bfd_section->contents = NULL; } off = _bfd_elf_assign_file_position_for_section (shdrp, @@ -5597,7 +6021,14 @@ _bfd_elf_assign_file_positions_for_non_load (bfd *abfd) } } -/* Place the section headers. */ + /* Place section name section after DWARF debug sections have been + compressed. */ + _bfd_elf_strtab_finalize (elf_shstrtab (abfd)); + shdrp = &elf_tdata (abfd)->shstrtab_hdr; + shdrp->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd)); + off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE); + + /* Place the section headers. */ i_ehdrp = elf_elfheader (abfd); bed = get_elf_backend_data (abfd); off = align_file_position (off, 1 << bed->s->log_file_align); @@ -5635,6 +6066,9 @@ _bfd_elf_write_object_contents (bfd *abfd) num_sec = elf_numsections (abfd); for (count = 1; count < num_sec; count++) { + i_shdrp[count]->sh_name + = _bfd_elf_strtab_offset (elf_shstrtab (abfd), + i_shdrp[count]->sh_name); if (bed->elf_backend_section_processing) (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]); if (i_shdrp[count]->contents) @@ -6141,13 +6575,9 @@ rewrite_elf_program_header (bfd *ibfd, bfd *obfd) first_matching_lma = TRUE; first_suggested_lma = TRUE; - for (section = ibfd->sections; + for (section = first_section, j = 0; section != NULL; section = section->next) - if (section == first_section) - break; - - for (j = 0; section != NULL; section = section->next) { if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed)) { @@ -6728,7 +7158,8 @@ _bfd_elf_init_private_section_data (bfd *ibfd, { Elf_Internal_Shdr *ihdr, *ohdr; - bfd_boolean final_link = link_info != NULL && !link_info->relocatable; + bfd_boolean final_link = (link_info != NULL + && !bfd_link_relocatable (link_info)); if (ibfd->xvec->flavour != bfd_target_elf_flavour || obfd->xvec->flavour != bfd_target_elf_flavour) @@ -6948,7 +7379,7 @@ _bfd_elf_copy_private_symbol_data (bfd *ibfd, shndx = MAP_STRTAB; else if (shndx == elf_shstrtab_sec (ibfd)) shndx = MAP_SHSTRTAB; - else if (shndx == elf_symtab_shndx (ibfd)) + else if (find_section_in_list (shndx, elf_symtab_shndx_list (ibfd))) shndx = MAP_SYM_SHNDX; osym->internal_elf_sym.st_shndx = shndx; } @@ -6960,18 +7391,21 @@ _bfd_elf_copy_private_symbol_data (bfd *ibfd, static bfd_boolean swap_out_syms (bfd *abfd, - struct bfd_strtab_hash **sttp, + struct elf_strtab_hash **sttp, int relocatable_p) { const struct elf_backend_data *bed; int symcount; asymbol **syms; - struct bfd_strtab_hash *stt; + struct elf_strtab_hash *stt; Elf_Internal_Shdr *symtab_hdr; Elf_Internal_Shdr *symtab_shndx_hdr; Elf_Internal_Shdr *symstrtab_hdr; + struct elf_sym_strtab *symstrtab; bfd_byte *outbound_syms; bfd_byte *outbound_shndx; + unsigned long outbound_syms_index; + unsigned long outbound_shndx_index; int idx; unsigned int num_locals; bfd_size_type amt; @@ -6981,7 +7415,7 @@ swap_out_syms (bfd *abfd, return FALSE; /* Dump out the symtabs. */ - stt = _bfd_elf_stringtab_init (); + stt = _bfd_elf_strtab_init (); if (stt == NULL) return FALSE; @@ -6997,33 +7431,48 @@ swap_out_syms (bfd *abfd, symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr; symstrtab_hdr->sh_type = SHT_STRTAB; + /* Allocate buffer to swap out the .strtab section. */ + symstrtab = (struct elf_sym_strtab *) bfd_malloc ((symcount + 1) + * sizeof (*symstrtab)); + if (symstrtab == NULL) + { + _bfd_elf_strtab_free (stt); + return FALSE; + } + outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym); if (outbound_syms == NULL) { - _bfd_stringtab_free (stt); +error_return: + _bfd_elf_strtab_free (stt); + free (symstrtab); return FALSE; } symtab_hdr->contents = outbound_syms; + outbound_syms_index = 0; outbound_shndx = NULL; - symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr; - if (symtab_shndx_hdr->sh_name != 0) + outbound_shndx_index = 0; + + if (elf_symtab_shndx_list (abfd)) { - amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx); - outbound_shndx = (bfd_byte *) - bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx)); - if (outbound_shndx == NULL) + symtab_shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr; + if (symtab_shndx_hdr->sh_name != 0) { - _bfd_stringtab_free (stt); - return FALSE; - } + amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx); + outbound_shndx = (bfd_byte *) + bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx)); + if (outbound_shndx == NULL) + goto error_return; - symtab_shndx_hdr->contents = outbound_shndx; - symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; - symtab_shndx_hdr->sh_size = amt; - symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); - symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); + symtab_shndx_hdr->contents = outbound_shndx; + symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX; + symtab_shndx_hdr->sh_size = amt; + symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx); + symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx); + } + /* FIXME: What about any other headers in the list ? */ } /* Now generate the data (for "contents"). */ @@ -7037,10 +7486,12 @@ swap_out_syms (bfd *abfd, sym.st_other = 0; sym.st_shndx = SHN_UNDEF; sym.st_target_internal = 0; - bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); - outbound_syms += bed->s->sizeof_sym; + symstrtab[0].sym = sym; + symstrtab[0].dest_index = outbound_syms_index; + symstrtab[0].destshndx_index = outbound_shndx_index; + outbound_syms_index++; if (outbound_shndx != NULL) - outbound_shndx += sizeof (Elf_External_Sym_Shndx); + outbound_shndx_index++; } name_local_sections @@ -7048,7 +7499,7 @@ swap_out_syms (bfd *abfd, && bed->elf_backend_name_local_section_symbols (abfd)); syms = bfd_get_outsymbols (abfd); - for (idx = 0; idx < symcount; idx++) + for (idx = 0; idx < symcount;) { Elf_Internal_Sym sym; bfd_vma value = syms[idx]->value; @@ -7060,18 +7511,17 @@ swap_out_syms (bfd *abfd, && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM) { /* Local section symbols have no name. */ - sym.st_name = 0; + sym.st_name = (unsigned long) -1; } else { - sym.st_name = (unsigned long) _bfd_stringtab_add (stt, - syms[idx]->name, - TRUE, FALSE); + /* Call _bfd_elf_strtab_offset after _bfd_elf_strtab_finalize + to get the final offset for st_name. */ + sym.st_name + = (unsigned long) _bfd_elf_strtab_add (stt, syms[idx]->name, + FALSE); if (sym.st_name == (unsigned long) -1) - { - _bfd_stringtab_free (stt); - return FALSE; - } + goto error_return; } type_ptr = elf_symbol_from (abfd, syms[idx]); @@ -7131,7 +7581,8 @@ swap_out_syms (bfd *abfd, shndx = elf_shstrtab_sec (abfd); break; case MAP_SYM_SHNDX: - shndx = elf_symtab_shndx (abfd); + if (elf_symtab_shndx_list (abfd)) + shndx = elf_symtab_shndx_list (abfd)->ndx; break; default: shndx = SHN_ABS; @@ -7161,8 +7612,7 @@ Unable to find equivalent output section for symbol '%s' from section '%s'"), syms[idx]->name ? syms[idx]->name : "", sec->name); bfd_set_error (bfd_error_invalid_operation); - _bfd_stringtab_free (stt); - return FALSE; + goto error_return; } shndx = _bfd_elf_section_from_bfd_section (abfd, sec2); @@ -7206,12 +7656,16 @@ Unable to find equivalent output section for symbol '%s' from section '%s'"), } else if (bfd_is_com_section (syms[idx]->section)) { -#ifdef USE_STT_COMMON - if (type == STT_OBJECT) - sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON); - else -#endif - sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); + if (type != STT_TLS) + { + if ((abfd->flags & BFD_CONVERT_ELF_COMMON)) + type = ((abfd->flags & BFD_USE_ELF_STT_COMMON) + ? STT_COMMON : STT_OBJECT); + else + type = ((flags & BSF_ELF_COMMON) != 0 + ? STT_COMMON : STT_OBJECT); + } + sym.st_info = ELF_ST_INFO (STB_GLOBAL, type); } else if (bfd_is_und_section (syms[idx]->section)) sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK) @@ -7248,17 +7702,42 @@ Unable to find equivalent output section for symbol '%s' from section '%s'"), sym.st_target_internal = 0; } - bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx); - outbound_syms += bed->s->sizeof_sym; + idx++; + symstrtab[idx].sym = sym; + symstrtab[idx].dest_index = outbound_syms_index; + symstrtab[idx].destshndx_index = outbound_shndx_index; + + outbound_syms_index++; if (outbound_shndx != NULL) - outbound_shndx += sizeof (Elf_External_Sym_Shndx); + outbound_shndx_index++; } + /* Finalize the .strtab section. */ + _bfd_elf_strtab_finalize (stt); + + /* Swap out the .strtab section. */ + for (idx = 0; idx <= symcount; idx++) + { + struct elf_sym_strtab *elfsym = &symstrtab[idx]; + if (elfsym->sym.st_name == (unsigned long) -1) + elfsym->sym.st_name = 0; + else + elfsym->sym.st_name = _bfd_elf_strtab_offset (stt, + elfsym->sym.st_name); + bed->s->swap_symbol_out (abfd, &elfsym->sym, + (outbound_syms + + (elfsym->dest_index + * bed->s->sizeof_sym)), + (outbound_shndx + + (elfsym->destshndx_index + * sizeof (Elf_External_Sym_Shndx)))); + } + free (symstrtab); + *sttp = stt; - symstrtab_hdr->sh_size = _bfd_stringtab_size (stt); + symstrtab_hdr->sh_size = _bfd_elf_strtab_size (stt); symstrtab_hdr->sh_type = SHT_STRTAB; - - symstrtab_hdr->sh_flags = 0; + symstrtab_hdr->sh_flags = bed->elf_strtab_flags; symstrtab_hdr->sh_addr = 0; symstrtab_hdr->sh_entsize = 0; symstrtab_hdr->sh_link = 0; @@ -7666,7 +8145,7 @@ error_return_verref: goto error_return_bad_verdef; iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1]; - memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef)); + memcpy (iverdef, &iverdefmem, offsetof (Elf_Internal_Verdef, vd_bfd)); iverdef->vd_bfd = abfd; @@ -7715,6 +8194,7 @@ error_return_verref: ((bfd_byte *) everdaux + iverdaux->vda_next)); } + iverdef->vd_nodename = NULL; if (iverdef->vd_cnt) iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename; @@ -7828,9 +8308,46 @@ _bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_') return TRUE; - /* Treat assembler generated local labels as local. */ - if (name[0] == 'L' && name[strlen (name) - 1] < 32) - return TRUE; + /* Treat assembler generated fake symbols, dollar local labels and + forward-backward labels (aka local labels) as locals. + These labels have the form: + + L0^A.* (fake symbols) + + [.]?L[0123456789]+{^A|^B}[0123456789]* (local labels) + + Versions which start with .L will have already been matched above, + so we only need to match the rest. */ + if (name[0] == 'L' && ISDIGIT (name[1])) + { + bfd_boolean ret = FALSE; + const char * p; + char c; + + for (p = name + 2; (c = *p); p++) + { + if (c == 1 || c == 2) + { + if (c == 1 && p == name + 2) + /* A fake symbol. */ + return TRUE; + + /* FIXME: We are being paranoid here and treating symbols like + L0^Bfoo as if there were non-local, on the grounds that the + assembler will never generate them. But can any symbol + containing an ASCII value in the range 1-31 ever be anything + other than some kind of local ? */ + ret = TRUE; + } + + if (! ISDIGIT (c)) + { + ret = FALSE; + break; + } + } + return ret; + } return FALSE; } @@ -7945,7 +8462,7 @@ _bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info) const struct elf_backend_data *bed = get_elf_backend_data (abfd); int ret = bed->s->sizeof_ehdr; - if (!info->relocatable) + if (!bfd_link_relocatable (info)) { bfd_size_type phdr_size = elf_program_header_size (abfd); @@ -8968,24 +9485,31 @@ elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note) case NT_SIGINFO: return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo", note); + + case NT_FREEBSD_THRMISC: + if (note->namesz == 8 + && strcmp (note->namedata, "FreeBSD") == 0) + return elfcore_make_note_pseudosection (abfd, ".thrmisc", note); + else + return TRUE; } } static bfd_boolean elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note) { - struct elf_obj_tdata *t; + struct bfd_build_id* build_id; if (note->descsz == 0) return FALSE; - t = elf_tdata (abfd); - t->build_id = bfd_alloc (abfd, sizeof (*t->build_id) - 1 + note->descsz); - if (t->build_id == NULL) + build_id = bfd_alloc (abfd, sizeof (struct bfd_build_id) - 1 + note->descsz); + if (build_id == NULL) return FALSE; - t->build_id->size = note->descsz; - memcpy (t->build_id->data, note->descdata, note->descsz); + build_id->size = note->descsz; + memcpy (build_id->data, note->descdata, note->descsz); + abfd->build_id = build_id; return TRUE; } @@ -9465,9 +9989,7 @@ elfcore_write_linux_prpsinfo32 { struct elf_external_linux_prpsinfo32 data; - memset (&data, 0, sizeof (data)); - LINUX_PRPSINFO32_SWAP_FIELDS (abfd, prpsinfo, data); - + swap_linux_prpsinfo32_out (abfd, prpsinfo, &data); return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO, &data, sizeof (data)); } @@ -9479,9 +10001,7 @@ elfcore_write_linux_prpsinfo64 { struct elf_external_linux_prpsinfo64 data; - memset (&data, 0, sizeof (data)); - LINUX_PRPSINFO64_SWAP_FIELDS (abfd, prpsinfo, data); - + swap_linux_prpsinfo64_out (abfd, prpsinfo, &data); return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO, &data, sizeof (data)); } @@ -10129,6 +10649,12 @@ _bfd_elf_rel_local_sym (bfd *abfd, sym->st_value + addend); } +/* Adjust an address within a section. Given OFFSET within SEC, return + the new offset within the section, based upon changes made to the + section. Returns -1 if the offset is now invalid. + The offset (in abnd out) is in target sized bytes, however big a + byte may be. */ + bfd_vma _bfd_elf_section_offset (bfd *abfd, struct bfd_link_info *info, @@ -10142,12 +10668,17 @@ _bfd_elf_section_offset (bfd *abfd, offset); case SEC_INFO_TYPE_EH_FRAME: return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset); + default: if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0) { + /* Reverse the offset. */ const struct elf_backend_data *bed = get_elf_backend_data (abfd); bfd_size_type address_size = bed->s->arch_size / 8; - offset = sec->size - offset - address_size; + + /* address_size and sec->size are in octets. Convert + to bytes before subtracting the original offset. */ + offset = (sec->size - address_size) / bfd_octets_per_byte (abfd) - offset; } return offset; }