X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Felf32-xtensa.c;h=12ff9f772aafaa577f1ac582e3cc9c9205dd9625;hb=b0eb7e3ea662525545e60fcb092272afaa1cddb2;hp=adc0a02216e0bfc171cb57eab1c205635a7f772c;hpb=1058c7532d0b012ac329219264ddad59049fb6e6;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elf32-xtensa.c b/bfd/elf32-xtensa.c index adc0a02216..12ff9f772a 100644 --- a/bfd/elf32-xtensa.c +++ b/bfd/elf32-xtensa.c @@ -1,5 +1,5 @@ /* Xtensa-specific support for 32-bit ELF. - Copyright (C) 2003-2014 Free Software Foundation, Inc. + Copyright (C) 2003-2020 Free Software Foundation, Inc. This file is part of BFD, the Binary File Descriptor library. @@ -28,9 +28,13 @@ #include "libbfd.h" #include "elf-bfd.h" #include "elf/xtensa.h" +#include "splay-tree.h" #include "xtensa-isa.h" #include "xtensa-config.h" +/* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */ +#define OCTETS_PER_BYTE(ABFD, SEC) 1 + #define XTENSA_NO_NOP_REMOVAL 0 /* Local helper functions. */ @@ -62,6 +66,8 @@ static bfd_boolean is_alt_relocation (int); static bfd_boolean is_operand_relocation (int); static bfd_size_type insn_decode_len (bfd_byte *, bfd_size_type, bfd_size_type); +static int insn_num_slots + (bfd_byte *, bfd_size_type, bfd_size_type); static xtensa_opcode insn_decode_opcode (bfd_byte *, bfd_size_type, bfd_size_type, int); static bfd_boolean check_branch_target_aligned @@ -109,7 +115,6 @@ static bfd_boolean xtensa_is_proptable_section (asection *); static int internal_reloc_compare (const void *, const void *); static int internal_reloc_matches (const void *, const void *); static asection *xtensa_get_property_section (asection *, const char *); -extern asection *xtensa_make_property_section (asection *, const char *); static flagword xtensa_get_property_predef_flags (asection *); /* Other functions called directly by the linker. */ @@ -154,6 +159,11 @@ static bfd_boolean relaxing_section = FALSE; int elf32xtensa_no_literal_movement = 1; +/* Place property records for a section into individual property section + with xt.prop. prefix. */ + +bfd_boolean elf32xtensa_separate_props = FALSE; + /* Rename one of the generic section flags to better document how it is used here. */ /* Whether relocations have been processed. */ @@ -161,7 +171,7 @@ int elf32xtensa_no_literal_movement = 1; static reloc_howto_type elf_howto_table[] = { - HOWTO (R_XTENSA_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont, + HOWTO (R_XTENSA_NONE, 0, 3, 0, FALSE, 0, complain_overflow_dont, bfd_elf_xtensa_reloc, "R_XTENSA_NONE", FALSE, 0, 0, FALSE), HOWTO (R_XTENSA_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, @@ -214,11 +224,11 @@ static reloc_howto_type elf_howto_table[] = /* GNU extension to record C++ vtable hierarchy. */ HOWTO (R_XTENSA_GNU_VTINHERIT, 0, 2, 0, FALSE, 0, complain_overflow_dont, - NULL, "R_XTENSA_GNU_VTINHERIT", + NULL, "R_XTENSA_GNU_VTINHERIT", FALSE, 0, 0, FALSE), /* GNU extension to record C++ vtable member usage. */ HOWTO (R_XTENSA_GNU_VTENTRY, 0, 2, 0, FALSE, 0, complain_overflow_dont, - _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY", + _bfd_elf_rel_vtable_reloc_fn, "R_XTENSA_GNU_VTENTRY", FALSE, 0, 0, FALSE), /* Relocations for supporting difference of symbols. */ @@ -450,6 +460,9 @@ elf_xtensa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, break; } + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code); + bfd_set_error (bfd_error_bad_value); TRACE ("Unknown"); return NULL; } @@ -472,15 +485,23 @@ elf_xtensa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, /* Given an ELF "rela" relocation, find the corresponding howto and record it in the BFD internal arelent representation of the relocation. */ -static void -elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, +static bfd_boolean +elf_xtensa_info_to_howto_rela (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst) { unsigned int r_type = ELF32_R_TYPE (dst->r_info); - BFD_ASSERT (r_type < (unsigned int) R_XTENSA_max); + if (r_type >= (unsigned int) R_XTENSA_max) + { + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: unsupported relocation type %#x"), + abfd, r_type); + bfd_set_error (bfd_error_bad_value); + return FALSE; + } cache_ptr->howto = &elf_howto_table[r_type]; + return TRUE; } @@ -514,24 +535,42 @@ elf_xtensa_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, invoked. Note: the 32-byte frame size used here cannot be changed without a corresponding change in the runtime linker. */ -static const bfd_byte elf_xtensa_be_plt_entry[PLT_ENTRY_SIZE] = +static const bfd_byte elf_xtensa_be_plt_entry[][PLT_ENTRY_SIZE] = { - 0x6c, 0x10, 0x04, /* entry sp, 32 */ - 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ - 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ - 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ - 0x0a, 0x80, 0x00, /* jx a8 */ - 0 /* unused */ + { + 0x6c, 0x10, 0x04, /* entry sp, 32 */ + 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ + 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ + 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ + 0x0a, 0x80, 0x00, /* jx a8 */ + 0 /* unused */ + }, + { + 0x18, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ + 0x1a, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ + 0x1b, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ + 0x0a, 0x80, 0x00, /* jx a8 */ + 0 /* unused */ + } }; -static const bfd_byte elf_xtensa_le_plt_entry[PLT_ENTRY_SIZE] = +static const bfd_byte elf_xtensa_le_plt_entry[][PLT_ENTRY_SIZE] = { - 0x36, 0x41, 0x00, /* entry sp, 32 */ - 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ - 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ - 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ - 0xa0, 0x08, 0x00, /* jx a8 */ - 0 /* unused */ + { + 0x36, 0x41, 0x00, /* entry sp, 32 */ + 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ + 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ + 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ + 0xa0, 0x08, 0x00, /* jx a8 */ + 0 /* unused */ + }, + { + 0x81, 0x00, 0x00, /* l32r a8, [got entry for rtld's resolver] */ + 0xa1, 0x00, 0x00, /* l32r a10, [got entry for rtld's link map] */ + 0xb1, 0x00, 0x00, /* l32r a11, [literal for reloc index] */ + 0xa0, 0x08, 0x00, /* jx a8 */ + 0 /* unused */ + } }; /* The size of the thread control block. */ @@ -591,11 +630,6 @@ struct elf_xtensa_link_hash_table struct elf_link_hash_table elf; /* Short-cuts to get to dynamic linker sections. */ - asection *sgot; - asection *sgotplt; - asection *srelgot; - asection *splt; - asection *srelplt; asection *sgotloc; asection *spltlittbl; @@ -773,7 +807,7 @@ property_table_matches (const void *ap, const void *bp) section. Sets TABLE_P and returns the number of entries. On error, returns a negative value. */ -static int +int xtensa_read_table_entries (bfd *abfd, asection *section, property_table_entry **table_p, @@ -894,7 +928,7 @@ xtensa_read_table_entries (bfd *abfd, property_table_compare); /* Check that the table contents are valid. Problems may occur, - for example, if an unrelocated object file is stripped. */ + for example, if an unrelocated object file is stripped. */ for (blk = 1; blk < block_count; blk++) { /* The only circumstance where two entries may legitimately @@ -904,8 +938,9 @@ xtensa_read_table_entries (bfd *abfd, if (blocks[blk - 1].address == blocks[blk].address && blocks[blk - 1].size != 0) { - (*_bfd_error_handler) (_("%B(%A): invalid property table"), - abfd, section); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB(%pA): invalid property table"), + abfd, section); bfd_set_error (bfd_error_bad_value); free (blocks); return -1; @@ -966,7 +1001,7 @@ elf_xtensa_check_relocs (bfd *abfd, const Elf_Internal_Rela *rel; const Elf_Internal_Rela *rel_end; - if (info->relocatable || (sec->flags & SEC_ALLOC) == 0) + if (bfd_link_relocatable (info) || (sec->flags & SEC_ALLOC) == 0) return TRUE; BFD_ASSERT (is_xtensa_elf (abfd)); @@ -982,7 +1017,7 @@ elf_xtensa_check_relocs (bfd *abfd, for (rel = relocs; rel < rel_end; rel++) { unsigned int r_type; - unsigned long r_symndx; + unsigned r_symndx; struct elf_link_hash_entry *h = NULL; struct elf_xtensa_link_hash_entry *eh; int tls_type, old_tls_type; @@ -995,8 +1030,9 @@ elf_xtensa_check_relocs (bfd *abfd, if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) { - (*_bfd_error_handler) (_("%B: bad symbol index: %d"), - abfd, r_symndx); + /* xgettext:c-format */ + _bfd_error_handler (_("%pB: bad symbol index: %d"), + abfd, r_symndx); return FALSE; } @@ -1006,17 +1042,13 @@ elf_xtensa_check_relocs (bfd *abfd, while (h->root.type == bfd_link_hash_indirect || h->root.type == bfd_link_hash_warning) h = (struct elf_link_hash_entry *) h->root.u.i.link; - - /* PR15323, ref flags aren't set for references in the same - object. */ - h->root.non_ir_ref = 1; } eh = elf_xtensa_hash_entry (h); switch (r_type) { case R_XTENSA_TLSDESC_FN: - if (info->shared) + if (bfd_link_pic (info)) { tls_type = GOT_TLS_GD; is_got = TRUE; @@ -1027,7 +1059,7 @@ elf_xtensa_check_relocs (bfd *abfd, break; case R_XTENSA_TLSDESC_ARG: - if (info->shared) + if (bfd_link_pic (info)) { tls_type = GOT_TLS_GD; is_got = TRUE; @@ -1041,7 +1073,7 @@ elf_xtensa_check_relocs (bfd *abfd, break; case R_XTENSA_TLS_DTPOFF: - if (info->shared) + if (bfd_link_pic (info)) tls_type = GOT_TLS_GD; else tls_type = GOT_TLS_IE; @@ -1049,9 +1081,9 @@ elf_xtensa_check_relocs (bfd *abfd, case R_XTENSA_TLS_TPOFF: tls_type = GOT_TLS_IE; - if (info->shared) + if (bfd_link_pic (info)) info->flags |= DF_STATIC_TLS; - if (info->shared || h) + if (bfd_link_pic (info) || h) is_got = TRUE; break; @@ -1075,9 +1107,7 @@ elf_xtensa_check_relocs (bfd *abfd, case R_XTENSA_GNU_VTENTRY: /* This relocation describes which C++ vtable entries are actually used. Record for later use during GC. */ - BFD_ASSERT (h != NULL); - if (h != NULL - && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) + if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) return FALSE; continue; @@ -1171,8 +1201,9 @@ elf_xtensa_check_relocs (bfd *abfd, tls_type |= old_tls_type; else { - (*_bfd_error_handler) - (_("%B: `%s' accessed both as normal and thread local symbol"), + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB: `%s' accessed both as normal and thread local symbol"), abfd, h ? h->root.root.string : ""); return FALSE; @@ -1194,19 +1225,19 @@ elf_xtensa_check_relocs (bfd *abfd, static void elf_xtensa_make_sym_local (struct bfd_link_info *info, - struct elf_link_hash_entry *h) + struct elf_link_hash_entry *h) { - if (info->shared) + if (bfd_link_pic (info)) { if (h->plt.refcount > 0) - { + { /* For shared objects, there's no need for PLT entries for local symbols (use RELATIVE relocs instead of JMP_SLOT relocs). */ - if (h->got.refcount < 0) - h->got.refcount = 0; - h->got.refcount += h->plt.refcount; - h->plt.refcount = 0; - } + if (h->got.refcount < 0) + h->got.refcount = 0; + h->got.refcount += h->plt.refcount; + h->plt.refcount = 0; + } } else { @@ -1219,8 +1250,8 @@ elf_xtensa_make_sym_local (struct bfd_link_info *info, static void elf_xtensa_hide_symbol (struct bfd_link_info *info, - struct elf_link_hash_entry *h, - bfd_boolean force_local) + struct elf_link_hash_entry *h, + bfd_boolean force_local) { /* For a shared link, move the plt refcount to the got refcount to leave space for RELATIVE relocs. */ @@ -1265,133 +1296,6 @@ elf_xtensa_gc_mark_hook (asection *sec, } -/* Update the GOT & PLT entry reference counts - for the section being removed. */ - -static bfd_boolean -elf_xtensa_gc_sweep_hook (bfd *abfd, - struct bfd_link_info *info, - asection *sec, - const Elf_Internal_Rela *relocs) -{ - Elf_Internal_Shdr *symtab_hdr; - struct elf_link_hash_entry **sym_hashes; - const Elf_Internal_Rela *rel, *relend; - struct elf_xtensa_link_hash_table *htab; - - htab = elf_xtensa_hash_table (info); - if (htab == NULL) - return FALSE; - - if (info->relocatable) - return TRUE; - - if ((sec->flags & SEC_ALLOC) == 0) - return TRUE; - - symtab_hdr = &elf_tdata (abfd)->symtab_hdr; - sym_hashes = elf_sym_hashes (abfd); - - relend = relocs + sec->reloc_count; - for (rel = relocs; rel < relend; rel++) - { - unsigned long r_symndx; - unsigned int r_type; - struct elf_link_hash_entry *h = NULL; - struct elf_xtensa_link_hash_entry *eh; - bfd_boolean is_got = FALSE; - bfd_boolean is_plt = FALSE; - bfd_boolean is_tlsfunc = FALSE; - - r_symndx = ELF32_R_SYM (rel->r_info); - if (r_symndx >= symtab_hdr->sh_info) - { - h = sym_hashes[r_symndx - symtab_hdr->sh_info]; - while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; - } - eh = elf_xtensa_hash_entry (h); - - r_type = ELF32_R_TYPE (rel->r_info); - switch (r_type) - { - case R_XTENSA_TLSDESC_FN: - if (info->shared) - { - is_got = TRUE; - is_tlsfunc = TRUE; - } - break; - - case R_XTENSA_TLSDESC_ARG: - if (info->shared) - is_got = TRUE; - else - { - if (h && elf_xtensa_hash_entry (h) != htab->tlsbase) - is_got = TRUE; - } - break; - - case R_XTENSA_TLS_TPOFF: - if (info->shared || h) - is_got = TRUE; - break; - - case R_XTENSA_32: - is_got = TRUE; - break; - - case R_XTENSA_PLT: - is_plt = TRUE; - break; - - default: - continue; - } - - if (h) - { - if (is_plt) - { - if (h->plt.refcount > 0) - h->plt.refcount--; - } - else if (is_got) - { - if (h->got.refcount > 0) - h->got.refcount--; - } - if (is_tlsfunc) - { - if (eh->tlsfunc_refcount > 0) - eh->tlsfunc_refcount--; - } - } - else - { - if (is_got || is_plt) - { - bfd_signed_vma *got_refcount - = &elf_local_got_refcounts (abfd) [r_symndx]; - if (*got_refcount > 0) - *got_refcount -= 1; - } - if (is_tlsfunc) - { - bfd_signed_vma *tlsfunc_refcount - = &elf_xtensa_local_tlsfunc_refcounts (abfd) [r_symndx]; - if (*tlsfunc_refcount > 0) - *tlsfunc_refcount -= 1; - } - } - } - - return TRUE; -} - - /* Create all the dynamic sections. */ static bfd_boolean @@ -1407,11 +1311,6 @@ elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) /* First do all the standard stuff. */ if (! _bfd_elf_create_dynamic_sections (dynobj, info)) return FALSE; - htab->splt = bfd_get_linker_section (dynobj, ".plt"); - htab->srelplt = bfd_get_linker_section (dynobj, ".rela.plt"); - htab->sgot = bfd_get_linker_section (dynobj, ".got"); - htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt"); - htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got"); /* Create any extra PLT sections in case check_relocs has already been called on all the non-dynamic input files. */ @@ -1423,22 +1322,22 @@ elf_xtensa_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) flags = noalloc_flags | SEC_ALLOC | SEC_LOAD; /* Mark the ".got.plt" section READONLY. */ - if (htab->sgotplt == NULL - || ! bfd_set_section_flags (dynobj, htab->sgotplt, flags)) + if (htab->elf.sgotplt == NULL + || !bfd_set_section_flags (htab->elf.sgotplt, flags)) return FALSE; /* Create ".got.loc" (literal tables for use by dynamic linker). */ htab->sgotloc = bfd_make_section_anyway_with_flags (dynobj, ".got.loc", flags); if (htab->sgotloc == NULL - || ! bfd_set_section_alignment (dynobj, htab->sgotloc, 2)) + || !bfd_set_section_alignment (htab->sgotloc, 2)) return FALSE; /* Create ".xt.lit.plt" (literal table for ".got.plt*"). */ htab->spltlittbl = bfd_make_section_anyway_with_flags (dynobj, ".xt.lit.plt", noalloc_flags); if (htab->spltlittbl == NULL - || ! bfd_set_section_alignment (dynobj, htab->spltlittbl, 2)) + || !bfd_set_section_alignment (htab->spltlittbl, 2)) return FALSE; return TRUE; @@ -1470,14 +1369,14 @@ add_extra_plt_sections (struct bfd_link_info *info, int count) sprintf (sname, ".plt.%u", chunk); s = bfd_make_section_anyway_with_flags (dynobj, sname, flags | SEC_CODE); if (s == NULL - || ! bfd_set_section_alignment (dynobj, s, 2)) + || !bfd_set_section_alignment (s, 2)) return FALSE; sname = (char *) bfd_malloc (14); sprintf (sname, ".got.plt.%u", chunk); s = bfd_make_section_anyway_with_flags (dynobj, sname, flags); if (s == NULL - || ! bfd_set_section_alignment (dynobj, s, 2)) + || !bfd_set_section_alignment (s, 2)) return FALSE; } @@ -1498,12 +1397,12 @@ elf_xtensa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, /* If this is a weak symbol, and there is a real definition, the processor independent code will have arranged for us to see the real definition first, and we can just use the same value. */ - if (h->u.weakdef) + if (h->is_weakalias) { - BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined - || h->u.weakdef->root.type == bfd_link_hash_defweak); - h->root.u.def.section = h->u.weakdef->root.u.def.section; - h->root.u.def.value = h->u.weakdef->root.u.def.value; + struct elf_link_hash_entry *def = weakdef (h); + BFD_ASSERT (def->root.type == bfd_link_hash_defined); + h->root.u.def.section = def->root.u.def.section; + h->root.u.def.value = def->root.u.def.value; return TRUE; } @@ -1541,11 +1440,15 @@ elf_xtensa_allocate_dynrelocs (struct elf_link_hash_entry *h, void *arg) if (! elf_xtensa_dynamic_symbol_p (h, info)) elf_xtensa_make_sym_local (info, h); + if (! elf_xtensa_dynamic_symbol_p (h, info) + && h->root.type == bfd_link_hash_undefweak) + return TRUE; + if (h->plt.refcount > 0) - htab->srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela)); + htab->elf.srelplt->size += (h->plt.refcount * sizeof (Elf32_External_Rela)); if (h->got.refcount > 0) - htab->srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela)); + htab->elf.srelgot->size += (h->got.refcount * sizeof (Elf32_External_Rela)); return TRUE; } @@ -1561,7 +1464,7 @@ elf_xtensa_allocate_local_got_size (struct bfd_link_info *info) if (htab == NULL) return; - for (i = info->input_bfds; i; i = i->link_next) + for (i = info->input_bfds; i; i = i->link.next) { bfd_signed_vma *local_got_refcounts; bfd_size_type j, cnt; @@ -1587,8 +1490,8 @@ elf_xtensa_allocate_local_got_size (struct bfd_link_info *info) } if (local_got_refcounts[j] > 0) - htab->srelgot->size += (local_got_refcounts[j] - * sizeof (Elf32_External_Rela)); + htab->elf.srelgot->size += (local_got_refcounts[j] + * sizeof (Elf32_External_Rela)); } } } @@ -1616,19 +1519,19 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, dynobj = elf_hash_table (info)->dynobj; if (dynobj == NULL) abort (); - srelgot = htab->srelgot; - srelplt = htab->srelplt; + srelgot = htab->elf.srelgot; + srelplt = htab->elf.srelplt; if (elf_hash_table (info)->dynamic_sections_created) { - BFD_ASSERT (htab->srelgot != NULL - && htab->srelplt != NULL - && htab->sgot != NULL + BFD_ASSERT (htab->elf.srelgot != NULL + && htab->elf.srelplt != NULL + && htab->elf.sgot != NULL && htab->spltlittbl != NULL && htab->sgotloc != NULL); /* Set the contents of the .interp section to the interpreter. */ - if (info->executable) + if (bfd_link_executable (info) && !info->nointerp) { s = bfd_get_linker_section (dynobj, ".interp"); if (s == NULL) @@ -1638,7 +1541,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, } /* Allocate room for one word in ".got". */ - htab->sgot->size = 4; + htab->elf.sgot->size = 4; /* Allocate space in ".rela.got" for literals that reference global symbols and space in ".rela.plt" for literals that have PLT @@ -1650,7 +1553,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, /* If we are generating a shared object, we also need space in ".rela.got" for R_XTENSA_RELATIVE relocs for literals that reference local symbols. */ - if (info->shared) + if (bfd_link_pic (info)) elf_xtensa_allocate_local_got_size (info); /* Allocate space in ".plt" to match the size of ".rela.plt". For @@ -1700,7 +1603,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, literal tables. */ sgotloc = htab->sgotloc; sgotloc->size = spltlittbl->size; - for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next) { if (abfd->flags & DYNAMIC) continue; @@ -1726,7 +1629,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, /* It's OK to base decisions on the section name, because none of the dynobj section names depend upon the input files. */ - name = bfd_get_section_name (dynobj, s); + name = bfd_section_name (s); if (CONST_STRNEQ (name, ".rela")) { @@ -1806,7 +1709,7 @@ elf_xtensa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, #define add_dynamic_entry(TAG, VAL) \ _bfd_elf_add_dynamic_entry (info, TAG, VAL) - if (info->executable) + if (bfd_link_executable (info)) { if (!add_dynamic_entry (DT_DEBUG, 0)) return FALSE; @@ -1974,7 +1877,7 @@ elf_xtensa_do_reloc (reloc_howto_type *howto, case R_XTENSA_ASM_SIMPLIFY: { - /* Convert the L32R/CALLX to CALL. */ + /* Convert the L32R/CALLX to CALL. */ bfd_reloc_status_type retval = elf_xtensa_do_asm_simplify (contents, address, input_size, error_message); @@ -2057,8 +1960,9 @@ elf_xtensa_do_reloc (reloc_howto_type *howto, } else if (opcode == get_const16_opcode ()) { - /* ALT used for high 16 bits. */ - newval = relocation >> 16; + /* ALT used for high 16 bits. + Ignore 32-bit overflow. */ + newval = (relocation >> 16) & 0xffff; opnd = 1; } else @@ -2202,7 +2106,8 @@ bfd_elf_xtensa_reloc (bfd *abfd, { bfd_vma relocation; bfd_reloc_status_type flag; - bfd_size_type octets = reloc_entry->address * bfd_octets_per_byte (abfd); + bfd_size_type octets = (reloc_entry->address + * OCTETS_PER_BYTE (abfd, input_section)); bfd_vma output_base = 0; reloc_howto_type *howto = reloc_entry->howto; asection *reloc_target_output_section; @@ -2308,7 +2213,7 @@ elf_xtensa_create_plt_entry (struct bfd_link_info *info, { asection *splt, *sgotplt; bfd_vma plt_base, got_base; - bfd_vma code_offset, lit_offset; + bfd_vma code_offset, lit_offset, abi_offset; int chunk; chunk = reloc_index / PLT_ENTRIES_PER_CHUNK; @@ -2330,18 +2235,19 @@ elf_xtensa_create_plt_entry (struct bfd_link_info *info, /* Fill in the entry in the procedure linkage table. */ memcpy (splt->contents + code_offset, (bfd_big_endian (output_bfd) - ? elf_xtensa_be_plt_entry - : elf_xtensa_le_plt_entry), + ? elf_xtensa_be_plt_entry[XSHAL_ABI != XTHAL_ABI_WINDOWED] + : elf_xtensa_le_plt_entry[XSHAL_ABI != XTHAL_ABI_WINDOWED]), PLT_ENTRY_SIZE); + abi_offset = XSHAL_ABI == XTHAL_ABI_WINDOWED ? 3 : 0; bfd_put_16 (output_bfd, l32r_offset (got_base + 0, - plt_base + code_offset + 3), - splt->contents + code_offset + 4); + plt_base + code_offset + abi_offset), + splt->contents + code_offset + abi_offset + 1); bfd_put_16 (output_bfd, l32r_offset (got_base + 4, - plt_base + code_offset + 6), - splt->contents + code_offset + 7); + plt_base + code_offset + abi_offset + 3), + splt->contents + code_offset + abi_offset + 4); bfd_put_16 (output_bfd, l32r_offset (got_base + lit_offset, - plt_base + code_offset + 9), - splt->contents + code_offset + 10); + plt_base + code_offset + abi_offset + 6), + splt->contents + code_offset + abi_offset + 7); return plt_base + code_offset; } @@ -2514,7 +2420,7 @@ replace_tls_insn (Elf_Internal_Rela *rel, xtensa_format_set_slot (isa, fmt, 0, ibuff, sbuff); xtensa_insnbuf_to_chars (isa, ibuff, contents + rel->r_offset, - input_size - rel->r_offset); + input_size - rel->r_offset); return TRUE; } @@ -2557,7 +2463,11 @@ elf_xtensa_relocate_section (bfd *output_bfd, if (!xtensa_default_isa) xtensa_default_isa = xtensa_isa_init (0, 0); - BFD_ASSERT (is_xtensa_elf (input_bfd)); + if (!is_xtensa_elf (input_bfd)) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } htab = elf_xtensa_hash_table (info); if (htab == NULL) @@ -2618,7 +2528,7 @@ elf_xtensa_relocate_section (bfd *output_bfd, unresolved_reloc = FALSE; warned = FALSE; - if (howto->partial_inplace && !info->relocatable) + if (howto->partial_inplace && !bfd_link_relocatable (info)) { /* Because R_XTENSA_32 was made partial_inplace to fix some problems with DWARF info in partial links, there may be @@ -2656,7 +2566,7 @@ elf_xtensa_relocate_section (bfd *output_bfd, RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, rel, 1, relend, howto, 0, contents); - if (info->relocatable) + if (bfd_link_relocatable (info)) { bfd_vma dest_addr; asection * sym_sec = get_elf_r_symndx_section (input_bfd, r_symndx); @@ -2688,12 +2598,10 @@ elf_xtensa_relocate_section (bfd *output_bfd, r = contract_asm_expansion (contents, input_size, rel, &error_message); if (r != bfd_reloc_ok) - { - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; - } + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); + r_type = ELF32_R_TYPE (rel->r_info); } @@ -2745,12 +2653,9 @@ elf_xtensa_relocate_section (bfd *output_bfd, } } if (r != bfd_reloc_ok) - { - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; - } + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); /* Done with work for relocatable link; continue with next reloc. */ continue; @@ -2769,9 +2674,12 @@ elf_xtensa_relocate_section (bfd *output_bfd, if (rel->r_offset >= input_size && ELF32_R_TYPE (rel->r_info) != R_XTENSA_NONE) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): relocation offset out of range (size=0x%x)"), - input_bfd, input_section, rel->r_offset, input_size); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): " + "relocation offset out of range (size=%#" PRIx64 ")"), + input_bfd, input_section, (uint64_t) rel->r_offset, + (uint64_t) input_size); bfd_set_error (bfd_error_bad_value); return FALSE; } @@ -2783,7 +2691,7 @@ elf_xtensa_relocate_section (bfd *output_bfd, name = (bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link, sym->st_name)); if (name == NULL || *name == '\0') - name = bfd_section_name (input_bfd, sec); + name = bfd_section_name (sec); } if (r_symndx != STN_UNDEF @@ -2793,13 +2701,15 @@ elf_xtensa_relocate_section (bfd *output_bfd, || h->root.type == bfd_link_hash_defweak) && IS_XTENSA_TLS_RELOC (r_type) != (sym_type == STT_TLS)) { - (*_bfd_error_handler) + _bfd_error_handler ((sym_type == STT_TLS - ? _("%B(%A+0x%lx): %s used with TLS symbol %s") - : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")), + /* xgettext:c-format */ + ? _("%pB(%pA+%#" PRIx64 "): %s used with TLS symbol %s") + /* xgettext:c-format */ + : _("%pB(%pA+%#" PRIx64 "): %s used with non-TLS symbol %s")), input_bfd, input_section, - (long) rel->r_offset, + (uint64_t) rel->r_offset, howto->name, name); } @@ -2818,16 +2728,16 @@ elf_xtensa_relocate_section (bfd *output_bfd, case R_XTENSA_PLT: if (elf_hash_table (info)->dynamic_sections_created && (input_section->flags & SEC_ALLOC) != 0 - && (dynamic_symbol || info->shared)) + && (dynamic_symbol || bfd_link_pic (info))) { Elf_Internal_Rela outrel; bfd_byte *loc; asection *srel; if (dynamic_symbol && r_type == R_XTENSA_PLT) - srel = htab->srelplt; + srel = htab->elf.srelplt; else - srel = htab->srelgot; + srel = htab->elf.srelgot; BFD_ASSERT (srel != NULL); @@ -2850,10 +2760,9 @@ elf_xtensa_relocate_section (bfd *output_bfd, { error_message = _("dynamic relocation in read-only section"); - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); } if (dynamic_symbol) @@ -2881,12 +2790,16 @@ elf_xtensa_relocate_section (bfd *output_bfd, } unresolved_reloc = FALSE; } - else + else if (!is_weak_undef) { /* Generate a RELATIVE relocation. */ outrel.r_info = ELF32_R_INFO (0, R_XTENSA_RELATIVE); outrel.r_addend = 0; } + else + { + continue; + } } loc = (srel->contents @@ -2906,7 +2819,7 @@ elf_xtensa_relocate_section (bfd *output_bfd, case R_XTENSA_TLS_TPOFF: /* Switch to LE model for local symbols in an executable. */ - if (! info->shared && ! dynamic_symbol) + if (! bfd_link_pic (info) && ! dynamic_symbol) { relocation = tpoff (info, relocation); break; @@ -2918,12 +2831,12 @@ elf_xtensa_relocate_section (bfd *output_bfd, { if (r_type == R_XTENSA_TLSDESC_FN) { - if (! info->shared || (tls_type & GOT_TLS_IE) != 0) + if (! bfd_link_pic (info) || (tls_type & GOT_TLS_IE) != 0) r_type = R_XTENSA_NONE; } else if (r_type == R_XTENSA_TLSDESC_ARG) { - if (info->shared) + if (bfd_link_pic (info)) { if ((tls_type & GOT_TLS_IE) != 0) r_type = R_XTENSA_TLS_TPOFF; @@ -2947,16 +2860,15 @@ elf_xtensa_relocate_section (bfd *output_bfd, { error_message = _("TLS relocation invalid without dynamic sections"); - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); } else { Elf_Internal_Rela outrel; bfd_byte *loc; - asection *srel = htab->srelgot; + asection *srel = htab->elf.srelgot; int indx; outrel.r_offset = (input_section->output_section->vma @@ -2971,10 +2883,9 @@ elf_xtensa_relocate_section (bfd *output_bfd, { error_message = _("dynamic relocation in read-only section"); - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); } indx = h && h->dynindx != -1 ? h->dynindx : 0; @@ -2999,7 +2910,7 @@ elf_xtensa_relocate_section (bfd *output_bfd, break; case R_XTENSA_TLS_DTPOFF: - if (! info->shared) + if (! bfd_link_pic (info)) /* Switch from LD model to LE model. */ relocation = tpoff (info, relocation); else @@ -3016,12 +2927,9 @@ elf_xtensa_relocate_section (bfd *output_bfd, (h && elf_xtensa_hash_entry (h) == htab->tlsbase); if (! replace_tls_insn (rel, input_bfd, input_section, contents, is_ld_model, &error_message)) - { - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; - } + (*info->callbacks->reloc_dangerous) + (info, error_message, + input_bfd, input_section, rel->r_offset); if (r_type != R_XTENSA_TLS_ARG || is_ld_model) { @@ -3040,10 +2948,8 @@ elf_xtensa_relocate_section (bfd *output_bfd, error_message = vsprint_msg ("invalid relocation for dynamic symbol", ": %s", strlen (name) + 2, name); - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; + (*info->callbacks->reloc_dangerous) + (info, error_message, input_bfd, input_section, rel->r_offset); continue; } break; @@ -3058,11 +2964,13 @@ elf_xtensa_relocate_section (bfd *output_bfd, && _bfd_elf_section_offset (output_bfd, info, input_section, rel->r_offset) != (bfd_vma) -1) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): " + "unresolvable %s relocation against symbol `%s'"), input_bfd, input_section, - (long) rel->r_offset, + (uint64_t) rel->r_offset, howto->name, name); return FALSE; @@ -3091,10 +2999,8 @@ elf_xtensa_relocate_section (bfd *output_bfd, strlen (name) + 22, name, (int) rel->r_addend); - if (!((*info->callbacks->reloc_dangerous) - (info, error_message, input_bfd, input_section, - rel->r_offset))) - return FALSE; + (*info->callbacks->reloc_dangerous) + (info, error_message, input_bfd, input_section, rel->r_offset); } } @@ -3164,7 +3070,7 @@ elf_xtensa_combine_prop_entries (bfd *output_bfd, sgotloc_size = sgotloc->size; if (sgotloc_size != section_size) { - (*_bfd_error_handler) + _bfd_error_handler (_("internal inconsistency in size of .got.loc section")); return -1; } @@ -3259,7 +3165,7 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, { struct elf_xtensa_link_hash_table *htab; bfd *dynobj; - asection *sdyn, *srelplt, *sgot, *sxtlit, *sgotloc; + asection *sdyn, *srelplt, *srelgot, *sgot, *sxtlit, *sgotloc; Elf32_External_Dyn *dyncon, *dynconend; int num_xtlit_entries = 0; @@ -3276,7 +3182,7 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, /* Set the first entry in the global offset table to the address of the dynamic section. */ - sgot = htab->sgot; + sgot = htab->elf.sgot; if (sgot) { BFD_ASSERT (sgot->size == 4); @@ -3288,16 +3194,16 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, sgot->contents); } - srelplt = htab->srelplt; + srelplt = htab->elf.srelplt; + srelgot = htab->elf.srelgot; if (srelplt && srelplt->size != 0) { - asection *sgotplt, *srelgot, *spltlittbl; + asection *sgotplt, *spltlittbl; int chunk, plt_chunks, plt_entries; Elf_Internal_Rela irela; bfd_byte *loc; unsigned rtld_reloc; - srelgot = htab->srelgot; spltlittbl = htab->spltlittbl; BFD_ASSERT (srelgot != NULL && spltlittbl != NULL); @@ -3363,14 +3269,6 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, spltlittbl->contents + (chunk * 8) + 4); } - /* All the dynamic relocations have been emitted at this point. - Make sure the relocation sections are the correct size. */ - if (srelgot->size != (sizeof (Elf32_External_Rela) - * srelgot->reloc_count) - || srelplt->size != (sizeof (Elf32_External_Rela) - * srelplt->reloc_count)) - abort (); - /* The .xt.lit.plt section has just been modified. This must happen before the code below which combines adjacent literal table entries, and the .xt.lit.plt contents have to be forced to @@ -3385,8 +3283,16 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, spltlittbl->flags &= ~SEC_HAS_CONTENTS; } + /* All the dynamic relocations have been emitted at this point. + Make sure the relocation sections are the correct size. */ + if ((srelgot && srelgot->size != (sizeof (Elf32_External_Rela) + * srelgot->reloc_count)) + || (srelplt && srelplt->size != (sizeof (Elf32_External_Rela) + * srelplt->reloc_count))) + abort (); + /* Combine adjacent literal table entries. */ - BFD_ASSERT (! info->relocatable); + BFD_ASSERT (! bfd_link_relocatable (info)); sxtlit = bfd_get_section_by_name (output_bfd, ".xt.lit"); sgotloc = htab->sgotloc; BFD_ASSERT (sgotloc); @@ -3416,30 +3322,22 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, break; case DT_XTENSA_GOT_LOC_OFF: - dyn.d_un.d_ptr = htab->sgotloc->output_section->vma; + dyn.d_un.d_ptr = (htab->sgotloc->output_section->vma + + htab->sgotloc->output_offset); break; case DT_PLTGOT: - dyn.d_un.d_ptr = htab->sgot->output_section->vma; + dyn.d_un.d_ptr = (htab->elf.sgot->output_section->vma + + htab->elf.sgot->output_offset); break; case DT_JMPREL: - dyn.d_un.d_ptr = htab->srelplt->output_section->vma; + dyn.d_un.d_ptr = (htab->elf.srelplt->output_section->vma + + htab->elf.srelplt->output_offset); break; case DT_PLTRELSZ: - dyn.d_un.d_val = htab->srelplt->output_section->size; - break; - - case DT_RELASZ: - /* Adjust RELASZ to not include JMPREL. This matches what - glibc expects and what is done for several other ELF - targets (e.g., i386, alpha), but the "correct" behavior - seems to be unresolved. Since the linker script arranges - for .rela.plt to follow all other relocation sections, we - don't have to worry about changing the DT_RELA entry. */ - if (htab->srelplt) - dyn.d_un.d_val -= htab->srelplt->output_section->size; + dyn.d_un.d_val = htab->elf.srelplt->size; break; } @@ -3456,13 +3354,14 @@ elf_xtensa_finish_dynamic_sections (bfd *output_bfd, object file when linking. */ static bfd_boolean -elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +elf_xtensa_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) { + bfd *obfd = info->output_bfd; unsigned out_mach, in_mach; flagword out_flag, in_flag; /* Check if we have the same endianness. */ - if (!_bfd_generic_verify_endian_match (ibfd, obfd)) + if (!_bfd_generic_verify_endian_match (ibfd, info)) return FALSE; /* Don't even pretend to support mixed-format linking. */ @@ -3477,8 +3376,9 @@ elf_xtensa_merge_private_bfd_data (bfd *ibfd, bfd *obfd) in_mach = in_flag & EF_XTENSA_MACH; if (out_mach != in_mach) { - (*_bfd_error_handler) - (_("%B: incompatible machine type. Output is 0x%x. Input is 0x%x"), + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB: incompatible machine type; output is 0x%x; input is 0x%x"), ibfd, out_mach, in_mach); bfd_set_error (bfd_error_wrong_format); return FALSE; @@ -3568,12 +3468,11 @@ elf_xtensa_object_p (bfd *abfd) file. This gets the Xtensa architecture right based on the machine number. */ -static void -elf_xtensa_final_write_processing (bfd *abfd, - bfd_boolean linker ATTRIBUTE_UNUSED) +static bfd_boolean +elf_xtensa_final_write_processing (bfd *abfd) { int mach; - unsigned long val; + unsigned long val = elf_elfheader (abfd)->e_flags & EF_XTENSA_MACH; switch (mach = bfd_get_mach (abfd)) { @@ -3581,11 +3480,12 @@ elf_xtensa_final_write_processing (bfd *abfd, val = E_XTENSA_MACH; break; default: - return; + break; } - elf_elfheader (abfd)->e_flags &= (~ EF_XTENSA_MACH); + elf_elfheader (abfd)->e_flags &= ~EF_XTENSA_MACH; elf_elfheader (abfd)->e_flags |= val; + return _bfd_elf_final_write_processing (abfd); } @@ -3963,6 +3863,33 @@ l32r_offset (bfd_vma addr, bfd_vma pc) } +static xtensa_opcode +get_rsr_lend_opcode (void) +{ + static xtensa_opcode rsr_lend_opcode = XTENSA_UNDEFINED; + static bfd_boolean done_lookup = FALSE; + if (!done_lookup) + { + rsr_lend_opcode = xtensa_opcode_lookup (xtensa_default_isa, "rsr.lend"); + done_lookup = TRUE; + } + return rsr_lend_opcode; +} + +static xtensa_opcode +get_wsr_lbeg_opcode (void) +{ + static xtensa_opcode wsr_lbeg_opcode = XTENSA_UNDEFINED; + static bfd_boolean done_lookup = FALSE; + if (!done_lookup) + { + wsr_lbeg_opcode = xtensa_opcode_lookup (xtensa_default_isa, "wsr.lbeg"); + done_lookup = TRUE; + } + return wsr_lbeg_opcode; +} + + static int get_relocation_opnd (xtensa_opcode opcode, int r_type) { @@ -4163,6 +4090,28 @@ insn_decode_len (bfd_byte *contents, return insn_len; } +int +insn_num_slots (bfd_byte *contents, + bfd_size_type content_len, + bfd_size_type offset) +{ + xtensa_isa isa = xtensa_default_isa; + xtensa_format fmt; + static xtensa_insnbuf ibuff = NULL; + + if (offset + MIN_INSN_LENGTH > content_len) + return XTENSA_UNDEFINED; + + if (ibuff == NULL) + ibuff = xtensa_insnbuf_alloc (isa); + xtensa_insnbuf_from_chars (isa, ibuff, &contents[offset], + content_len - offset); + fmt = xtensa_format_decode (isa, ibuff); + if (fmt == XTENSA_UNDEFINED) + return XTENSA_UNDEFINED; + return xtensa_format_num_slots (isa, fmt); +} + /* Decode the opcode for a single slot instruction. Return 0 if it fails to decode or the instruction is multi-slot. */ @@ -4242,6 +4191,20 @@ check_loop_aligned (bfd_byte *contents, return FALSE; } + /* If this is relaxed loop, analyze first instruction of the actual loop + body. It must be at offset 27 from the loop instruction address. */ + if (insn_len == 3 + && insn_num_slots (contents, content_length, offset + loop_len) == 1 + && insn_decode_opcode (contents, content_length, + offset + loop_len, 0) == get_rsr_lend_opcode() + && insn_decode_len (contents, content_length, offset + loop_len + 3) == 3 + && insn_num_slots (contents, content_length, offset + loop_len + 3) == 1 + && insn_decode_opcode (contents, content_length, + offset + loop_len + 3, 0) == get_wsr_lbeg_opcode()) + { + loop_len = 27; + insn_len = insn_decode_len (contents, content_length, offset + loop_len); + } return check_branch_target_aligned_address (address + loop_len, insn_len); } @@ -4709,7 +4672,7 @@ elf_xtensa_do_asm_simplify (bfd_byte *contents, if (content_length < address) { - *error_message = _("Attempt to convert L32R/CALLX to CALL failed"); + *error_message = _("attempt to convert L32R/CALLX to CALL failed"); return bfd_reloc_other; } @@ -4717,7 +4680,7 @@ elf_xtensa_do_asm_simplify (bfd_byte *contents, direct_call_opcode = swap_callx_for_call_opcode (opcode); if (direct_call_opcode == XTENSA_UNDEFINED) { - *error_message = _("Attempt to convert L32R/CALLX to CALL failed"); + *error_message = _("attempt to convert L32R/CALLX to CALL failed"); return bfd_reloc_other; } @@ -5363,23 +5326,23 @@ add_value_map (value_map_hash_table *map, /* The following text actions are generated: - "ta_remove_insn" remove an instruction or instructions - "ta_remove_longcall" convert longcall to call + "ta_remove_insn" remove an instruction or instructions + "ta_remove_longcall" convert longcall to call "ta_convert_longcall" convert longcall to nop/call - "ta_narrow_insn" narrow a wide instruction - "ta_widen" widen a narrow instruction - "ta_fill" add fill or remove fill + "ta_narrow_insn" narrow a wide instruction + "ta_widen" widen a narrow instruction + "ta_fill" add fill or remove fill removed < 0 is a fill; branches to the fill address will be changed to address + fill size (e.g., address - removed) removed >= 0 branches to the fill address will stay unchanged - "ta_remove_literal" remove a literal; this action is + "ta_remove_literal" remove a literal; this action is indicated when a literal is removed - or replaced. - "ta_add_literal" insert a new literal; this action is - indicated when a literal has been moved. - It may use a virtual_offset because + or replaced. + "ta_add_literal" insert a new literal; this action is + indicated when a literal has been moved. + It may use a virtual_offset because multiple literals can be placed at the - same location. + same location. For each of these text actions, we also record the number of bytes removed by performing the text action. In the case of a "ta_widen" @@ -5392,12 +5355,12 @@ typedef enum text_action_enum_t text_action_t; enum text_action_enum_t { ta_none, - ta_remove_insn, /* removed = -size */ - ta_remove_longcall, /* removed = -size */ - ta_convert_longcall, /* removed = 0 */ - ta_narrow_insn, /* removed = -1 */ - ta_widen_insn, /* removed = +1 */ - ta_fill, /* removed = +size */ + ta_remove_insn, /* removed = -size */ + ta_remove_longcall, /* removed = -size */ + ta_convert_longcall, /* removed = 0 */ + ta_narrow_insn, /* removed = -1 */ + ta_widen_insn, /* removed = +1 */ + ta_fill, /* removed = +size */ ta_remove_literal, ta_add_literal }; @@ -5412,35 +5375,49 @@ struct text_action_struct bfd_vma virtual_offset; /* Zero except for adding literals. */ int removed_bytes; literal_value value; /* Only valid when adding literals. */ +}; + +struct removal_by_action_entry_struct +{ + bfd_vma offset; + int removed; + int eq_removed; + int eq_removed_before_fill; +}; +typedef struct removal_by_action_entry_struct removal_by_action_entry; - text_action *next; +struct removal_by_action_map_struct +{ + unsigned n_entries; + removal_by_action_entry *entry; }; +typedef struct removal_by_action_map_struct removal_by_action_map; /* List of all of the actions taken on a text section. */ struct text_action_list_struct { - text_action *head; + unsigned count; + splay_tree tree; + removal_by_action_map map; }; static text_action * find_fill_action (text_action_list *l, asection *sec, bfd_vma offset) { - text_action **m_p; + text_action a; /* It is not necessary to fill at the end of a section. */ if (sec->size == offset) return NULL; - for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next) - { - text_action *t = *m_p; - /* When the action is another fill at the same address, - just increase the size. */ - if (t->offset == offset && t->action == ta_fill) - return t; - } + a.offset = offset; + a.action = ta_fill; + + splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a); + if (node) + return (text_action *)node->value; return NULL; } @@ -5488,6 +5465,49 @@ adjust_fill_action (text_action *ta, int fill_diff) } +static int +text_action_compare (splay_tree_key a, splay_tree_key b) +{ + text_action *pa = (text_action *)a; + text_action *pb = (text_action *)b; + static const int action_priority[] = + { + [ta_fill] = 0, + [ta_none] = 1, + [ta_convert_longcall] = 2, + [ta_narrow_insn] = 3, + [ta_remove_insn] = 4, + [ta_remove_longcall] = 5, + [ta_remove_literal] = 6, + [ta_widen_insn] = 7, + [ta_add_literal] = 8, + }; + + if (pa->offset == pb->offset) + { + if (pa->action == pb->action) + return 0; + return action_priority[pa->action] - action_priority[pb->action]; + } + else + return pa->offset < pb->offset ? -1 : 1; +} + +static text_action * +action_first (text_action_list *action_list) +{ + splay_tree_node node = splay_tree_min (action_list->tree); + return node ? (text_action *)node->value : NULL; +} + +static text_action * +action_next (text_action_list *action_list, text_action *action) +{ + splay_tree_node node = splay_tree_successor (action_list->tree, + (splay_tree_key)action); + return node ? (text_action *)node->value : NULL; +} + /* Add a modification action to the text. For the case of adding or removing space, modify any current fill and assume that "unreachable_space" bytes can be freely contracted. Note that a @@ -5500,8 +5520,8 @@ text_action_add (text_action_list *l, bfd_vma offset, int removed) { - text_action **m_p; text_action *ta; + text_action a; /* It is not necessary to fill at the end of a section. */ if (action == ta_fill && sec->size == offset) @@ -5511,34 +5531,30 @@ text_action_add (text_action_list *l, if (action == ta_fill && removed == 0) return; - for (m_p = &l->head; *m_p && (*m_p)->offset <= offset; m_p = &(*m_p)->next) + a.action = action; + a.offset = offset; + + if (action == ta_fill) { - text_action *t = *m_p; + splay_tree_node node = splay_tree_lookup (l->tree, (splay_tree_key)&a); - if (action == ta_fill) + if (node) { - /* When the action is another fill at the same address, - just increase the size. */ - if (t->offset == offset && t->action == ta_fill) - { - t->removed_bytes += removed; - return; - } - /* Fills need to happen before widens so that we don't - insert fill bytes into the instruction stream. */ - if (t->offset == offset && t->action == ta_widen_insn) - break; + ta = (text_action *)node->value; + ta->removed_bytes += removed; + return; } } + else + BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)&a) == NULL); - /* Create a new record and fill it up. */ ta = (text_action *) bfd_zmalloc (sizeof (text_action)); ta->action = action; ta->sec = sec; ta->offset = offset; ta->removed_bytes = removed; - ta->next = (*m_p); - *m_p = ta; + splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta); + ++l->count; } @@ -5549,7 +5565,6 @@ text_action_add_literal (text_action_list *l, const literal_value *value, int removed) { - text_action **m_p; text_action *ta; asection *sec = r_reloc_get_section (loc); bfd_vma offset = loc->target_offset; @@ -5557,14 +5572,6 @@ text_action_add_literal (text_action_list *l, BFD_ASSERT (action == ta_add_literal); - for (m_p = &l->head; *m_p != NULL; m_p = &(*m_p)->next) - { - if ((*m_p)->offset > offset - && ((*m_p)->offset != offset - || (*m_p)->virtual_offset > virtual_offset)) - break; - } - /* Create a new record and fill it up. */ ta = (text_action *) bfd_zmalloc (sizeof (text_action)); ta->action = action; @@ -5573,8 +5580,10 @@ text_action_add_literal (text_action_list *l, ta->virtual_offset = virtual_offset; ta->value = *value; ta->removed_bytes = removed; - ta->next = (*m_p); - *m_p = ta; + + BFD_ASSERT (splay_tree_lookup (l->tree, (splay_tree_key)ta) == NULL); + splay_tree_insert (l->tree, (splay_tree_key)ta, (splay_tree_value)ta); + ++l->count; } @@ -5585,7 +5594,8 @@ text_action_add_literal (text_action_list *l, so that each search may begin where the previous one left off. */ static int -removed_by_actions (text_action **p_start_action, +removed_by_actions (text_action_list *action_list, + text_action **p_start_action, bfd_vma offset, bfd_boolean before_fill) { @@ -5593,6 +5603,13 @@ removed_by_actions (text_action **p_start_action, int removed = 0; r = *p_start_action; + if (r) + { + splay_tree_node node = splay_tree_lookup (action_list->tree, + (splay_tree_key)r); + BFD_ASSERT (node != NULL && r == (text_action *)node->value); + } + while (r) { if (r->offset > offset) @@ -5604,7 +5621,7 @@ removed_by_actions (text_action **p_start_action, removed += r->removed_bytes; - r = r->next; + r = action_next (action_list, r); } *p_start_action = r; @@ -5615,51 +5632,150 @@ removed_by_actions (text_action **p_start_action, static bfd_vma offset_with_removed_text (text_action_list *action_list, bfd_vma offset) { - text_action *r = action_list->head; - return offset - removed_by_actions (&r, offset, FALSE); + text_action *r = action_first (action_list); + + return offset - removed_by_actions (action_list, &r, offset, FALSE); } static unsigned action_list_count (text_action_list *action_list) { - text_action *r = action_list->head; - unsigned count = 0; - for (r = action_list->head; r != NULL; r = r->next) - { - count++; - } - return count; + return action_list->count; } +typedef struct map_action_fn_context_struct map_action_fn_context; +struct map_action_fn_context_struct +{ + int removed; + removal_by_action_map map; + bfd_boolean eq_complete; +}; -/* The find_insn_action routine will only find non-fill actions. */ - -static text_action * -find_insn_action (text_action_list *action_list, bfd_vma offset) +static int +map_action_fn (splay_tree_node node, void *p) { - text_action *t; - for (t = action_list->head; t; t = t->next) + map_action_fn_context *ctx = p; + text_action *r = (text_action *)node->value; + removal_by_action_entry *ientry = ctx->map.entry + ctx->map.n_entries; + + if (ctx->map.n_entries && (ientry - 1)->offset == r->offset) + { + --ientry; + } + else { - if (t->offset == offset) + ++ctx->map.n_entries; + ctx->eq_complete = FALSE; + ientry->offset = r->offset; + ientry->eq_removed_before_fill = ctx->removed; + } + + if (!ctx->eq_complete) + { + if (r->action != ta_fill || r->removed_bytes >= 0) { - switch (t->action) - { - case ta_none: - case ta_fill: - break; - case ta_remove_insn: - case ta_remove_longcall: - case ta_convert_longcall: - case ta_narrow_insn: - case ta_widen_insn: - return t; - case ta_remove_literal: - case ta_add_literal: - BFD_ASSERT (0); - break; - } + ientry->eq_removed = ctx->removed; + ctx->eq_complete = TRUE; } + else + ientry->eq_removed = ctx->removed + r->removed_bytes; + } + + ctx->removed += r->removed_bytes; + ientry->removed = ctx->removed; + return 0; +} + +static void +map_removal_by_action (text_action_list *action_list) +{ + map_action_fn_context ctx; + + ctx.removed = 0; + ctx.map.n_entries = 0; + ctx.map.entry = bfd_malloc (action_list_count (action_list) * + sizeof (removal_by_action_entry)); + ctx.eq_complete = FALSE; + + splay_tree_foreach (action_list->tree, map_action_fn, &ctx); + action_list->map = ctx.map; +} + +static int +removed_by_actions_map (text_action_list *action_list, bfd_vma offset, + bfd_boolean before_fill) +{ + unsigned a, b; + + if (!action_list->map.entry) + map_removal_by_action (action_list); + + if (!action_list->map.n_entries) + return 0; + + a = 0; + b = action_list->map.n_entries; + + while (b - a > 1) + { + unsigned c = (a + b) / 2; + + if (action_list->map.entry[c].offset <= offset) + a = c; + else + b = c; + } + + if (action_list->map.entry[a].offset < offset) + { + return action_list->map.entry[a].removed; + } + else if (action_list->map.entry[a].offset == offset) + { + return before_fill ? + action_list->map.entry[a].eq_removed_before_fill : + action_list->map.entry[a].eq_removed; + } + else + { + return 0; + } +} + +static bfd_vma +offset_with_removed_text_map (text_action_list *action_list, bfd_vma offset) +{ + int removed = removed_by_actions_map (action_list, offset, FALSE); + return offset - removed; +} + + +/* The find_insn_action routine will only find non-fill actions. */ + +static text_action * +find_insn_action (text_action_list *action_list, bfd_vma offset) +{ + static const text_action_t action[] = + { + ta_convert_longcall, + ta_remove_longcall, + ta_widen_insn, + ta_narrow_insn, + ta_remove_insn, + }; + text_action a; + unsigned i; + + a.offset = offset; + for (i = 0; i < sizeof (action) / sizeof (*action); ++i) + { + splay_tree_node node; + + a.action = action[i]; + node = splay_tree_lookup (action_list->tree, (splay_tree_key)&a); + if (node) + return (text_action *)node->value; } return NULL; } @@ -5668,40 +5784,50 @@ find_insn_action (text_action_list *action_list, bfd_vma offset) #if DEBUG static void -print_action_list (FILE *fp, text_action_list *action_list) +print_action (FILE *fp, text_action *r) +{ + const char *t = "unknown"; + switch (r->action) + { + case ta_remove_insn: + t = "remove_insn"; break; + case ta_remove_longcall: + t = "remove_longcall"; break; + case ta_convert_longcall: + t = "convert_longcall"; break; + case ta_narrow_insn: + t = "narrow_insn"; break; + case ta_widen_insn: + t = "widen_insn"; break; + case ta_fill: + t = "fill"; break; + case ta_none: + t = "none"; break; + case ta_remove_literal: + t = "remove_literal"; break; + case ta_add_literal: + t = "add_literal"; break; + } + + fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n", + r->sec->owner->filename, + r->sec->name, (unsigned long) r->offset, t, r->removed_bytes); +} + +static int +print_action_list_fn (splay_tree_node node, void *p) { - text_action *r; + text_action *r = (text_action *)node->value; - fprintf (fp, "Text Action\n"); - for (r = action_list->head; r != NULL; r = r->next) - { - const char *t = "unknown"; - switch (r->action) - { - case ta_remove_insn: - t = "remove_insn"; break; - case ta_remove_longcall: - t = "remove_longcall"; break; - case ta_convert_longcall: - t = "convert_longcall"; break; - case ta_narrow_insn: - t = "narrow_insn"; break; - case ta_widen_insn: - t = "widen_insn"; break; - case ta_fill: - t = "fill"; break; - case ta_none: - t = "none"; break; - case ta_remove_literal: - t = "remove_literal"; break; - case ta_add_literal: - t = "add_literal"; break; - } + print_action (p, r); + return 0; +} - fprintf (fp, "%s: %s[0x%lx] \"%s\" %d\n", - r->sec->owner->filename, - r->sec->name, (unsigned long) r->offset, t, r->removed_bytes); - } +static void +print_action_list (FILE *fp, text_action_list *action_list) +{ + fprintf (fp, "Text Action\n"); + splay_tree_foreach (action_list->tree, print_action_list_fn, fp); } #endif /* DEBUG */ @@ -5716,6 +5842,7 @@ print_action_list (FILE *fp, text_action_list *action_list) by the "from" offset field. */ typedef struct removed_literal_struct removed_literal; +typedef struct removed_literal_map_entry_struct removed_literal_map_entry; typedef struct removed_literal_list_struct removed_literal_list; struct removed_literal_struct @@ -5725,10 +5852,19 @@ struct removed_literal_struct removed_literal *next; }; +struct removed_literal_map_entry_struct +{ + bfd_vma addr; + removed_literal *literal; +}; + struct removed_literal_list_struct { removed_literal *head; removed_literal *tail; + + unsigned n_map; + removed_literal_map_entry *map; }; @@ -5777,6 +5913,39 @@ add_removed_literal (removed_literal_list *removed_list, } } +static void +map_removed_literal (removed_literal_list *removed_list) +{ + unsigned n_map = 0; + unsigned i; + removed_literal_map_entry *map = NULL; + removed_literal *r = removed_list->head; + + for (i = 0; r; ++i, r = r->next) + { + if (i == n_map) + { + n_map = (n_map * 2) + 2; + map = bfd_realloc (map, n_map * sizeof (*map)); + } + map[i].addr = r->from.target_offset; + map[i].literal = r; + } + removed_list->map = map; + removed_list->n_map = i; +} + +static int +removed_literal_compare (const void *a, const void *b) +{ + const removed_literal_map_entry *pa = a; + const removed_literal_map_entry *pb = b; + + if (pa->addr == pb->addr) + return 0; + else + return pa->addr < pb->addr ? -1 : 1; +} /* Check if the list of removed literals contains an entry for the given address. Return the entry if found. */ @@ -5784,12 +5953,21 @@ add_removed_literal (removed_literal_list *removed_list, static removed_literal * find_removed_literal (removed_literal_list *removed_list, bfd_vma addr) { - removed_literal *r = removed_list->head; - while (r && r->from.target_offset < addr) - r = r->next; - if (r && r->from.target_offset == addr) - return r; - return NULL; + removed_literal_map_entry *p; + removed_literal *r = NULL; + + if (removed_list->map == NULL) + map_removed_literal (removed_list); + + p = bsearch (&addr, removed_list->map, removed_list->n_map, + sizeof (*removed_list->map), removed_literal_compare); + if (p) + { + while (p != removed_list->map && (p - 1)->addr == addr) + --p; + r = p->literal; + } + return r; } @@ -5903,7 +6081,10 @@ init_xtensa_relax_info (asection *sec) relax_info->removed_list.head = NULL; relax_info->removed_list.tail = NULL; - relax_info->action_list.head = NULL; + relax_info->action_list.tree = splay_tree_new (text_action_compare, + NULL, NULL); + relax_info->action_list.map.n_entries = 0; + relax_info->action_list.map.entry = NULL; relax_info->fix_list = NULL; relax_info->fix_array = NULL; @@ -6325,9 +6506,12 @@ extend_ebb_bounds_forward (ebb_t *ebb) entry_end - ebb->end_offset); if (insn_block_len != (entry_end - ebb->end_offset)) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"), - ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; " + "possible configuration mismatch"), + ebb->sec->owner, ebb->sec, + (uint64_t) (ebb->end_offset + insn_block_len)); return FALSE; } ebb->end_offset += insn_block_len; @@ -6401,9 +6585,12 @@ extend_ebb_bounds_backward (ebb_t *ebb) ebb->start_offset - block_begin); if (insn_block_len != ebb->start_offset - block_begin) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"), - ebb->sec->owner, ebb->sec, ebb->end_offset + insn_block_len); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; " + "possible configuration mismatch"), + ebb->sec->owner, ebb->sec, + (uint64_t) (ebb->end_offset + insn_block_len)); return FALSE; } ebb->start_offset -= insn_block_len; @@ -6615,13 +6802,14 @@ static bfd_boolean compute_text_actions (bfd *, asection *, struct bfd_link_info *); static bfd_boolean compute_ebb_proposed_actions (ebb_constraint *); static bfd_boolean compute_ebb_actions (ebb_constraint *); +typedef struct reloc_range_list_struct reloc_range_list; static bfd_boolean check_section_ebb_pcrels_fit - (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, const ebb_constraint *, + (bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, + reloc_range_list *, const ebb_constraint *, const xtensa_opcode *); static bfd_boolean check_section_ebb_reduces (const ebb_constraint *); static void text_action_add_proposed (text_action_list *, const ebb_constraint *, asection *); -static int compute_fill_extra_space (property_table_entry *); /* First pass: */ static bfd_boolean compute_removed_literals @@ -6746,14 +6934,14 @@ analyze_relocations (struct bfd_link_info *link_info) bfd_boolean is_relaxable = FALSE; /* Initialize the per-section relaxation info. */ - for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) for (sec = abfd->sections; sec != NULL; sec = sec->next) { init_xtensa_relax_info (sec); } /* Mark relaxable sections (and count relocations against each one). */ - for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) for (sec = abfd->sections; sec != NULL; sec = sec->next) { if (!find_relaxable_sections (abfd, sec, link_info, &is_relaxable)) @@ -6765,7 +6953,7 @@ analyze_relocations (struct bfd_link_info *link_info) return TRUE; /* Allocate space for source_relocs. */ - for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) for (sec = abfd->sections; sec != NULL; sec = sec->next) { xtensa_relax_info *relax_info; @@ -6782,7 +6970,7 @@ analyze_relocations (struct bfd_link_info *link_info) } /* Collect info on relocations against each relaxable section. */ - for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) for (sec = abfd->sections; sec != NULL; sec = sec->next) { if (!collect_source_relocs (abfd, sec, link_info)) @@ -6790,7 +6978,7 @@ analyze_relocations (struct bfd_link_info *link_info) } /* Compute the text actions. */ - for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link_next) + for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next) for (sec = abfd->sections; sec != NULL; sec = sec->next) { if (!compute_text_actions (abfd, sec, link_info)) @@ -6871,7 +7059,7 @@ find_relaxable_sections (bfd *abfd, continue; /* Count PC-relative operand relocations against the target section. - Note: The conditions tested here must match the conditions under + Note: The conditions tested here must match the conditions under which init_source_reloc is called in collect_source_relocs(). */ is_l32r_reloc = FALSE; if (is_operand_relocation (ELF32_R_TYPE (irel->r_info))) @@ -7074,6 +7262,11 @@ is_resolvable_asm_expansion (bfd *abfd, bfd_boolean *is_reachable_p) { asection *target_sec; + asection *s; + bfd_vma first_vma; + bfd_vma last_vma; + unsigned int first_align; + unsigned int adjust; bfd_vma target_offset; r_reloc r_rel; xtensa_opcode opcode, direct_call_opcode; @@ -7119,15 +7312,98 @@ is_resolvable_asm_expansion (bfd *abfd, /* For relocatable sections, we can only simplify when the output section of the target is the same as the output section of the source. */ - if (link_info->relocatable + if (bfd_link_relocatable (link_info) && (target_sec->output_section != sec->output_section || is_reloc_sym_weak (abfd, irel))) return FALSE; - self_address = (sec->output_section->vma - + sec->output_offset + irel->r_offset + 3); - dest_address = (target_sec->output_section->vma - + target_sec->output_offset + target_offset); + if (target_sec->output_section != sec->output_section) + { + /* If the two sections are sufficiently far away that relaxation + might take the call out of range, we can't simplify. For + example, a positive displacement call into another memory + could get moved to a lower address due to literal removal, + but the destination won't move, and so the displacment might + get larger. + + If the displacement is negative, assume the destination could + move as far back as the start of the output section. The + self_address will be at least as far into the output section + as it is prior to relaxation. + + If the displacement is postive, assume the destination will be in + it's pre-relaxed location (because relaxation only makes sections + smaller). The self_address could go all the way to the beginning + of the output section. */ + + dest_address = target_sec->output_section->vma; + self_address = sec->output_section->vma; + + if (sec->output_section->vma > target_sec->output_section->vma) + self_address += sec->output_offset + irel->r_offset + 3; + else + dest_address += bfd_get_section_limit (abfd, target_sec->output_section); + /* Call targets should be four-byte aligned. */ + dest_address = (dest_address + 3) & ~3; + } + else + { + + self_address = (sec->output_section->vma + + sec->output_offset + irel->r_offset + 3); + dest_address = (target_sec->output_section->vma + + target_sec->output_offset + target_offset); + } + + /* Adjust addresses with alignments for the worst case to see if call insn + can fit. Don't relax l32r + callx to call if the target can be out of + range due to alignment. + Caller and target addresses are highest and lowest address. + Search all sections between caller and target, looking for max alignment. + The adjustment is max alignment bytes. If the alignment at the lowest + address is less than the adjustment, apply the adjustment to highest + address. */ + + /* Start from lowest address. + Lowest address aligmnet is from input section. + Initial alignment (adjust) is from input section. */ + if (dest_address > self_address) + { + s = sec->output_section; + last_vma = dest_address; + first_align = sec->alignment_power; + adjust = target_sec->alignment_power; + } + else + { + s = target_sec->output_section; + last_vma = self_address; + first_align = target_sec->alignment_power; + adjust = sec->alignment_power; + } + + first_vma = s->vma; + + /* Find the largest alignment in output section list. */ + for (; s && s->vma >= first_vma && s->vma <= last_vma ; s = s->next) + { + if (s->alignment_power > adjust) + adjust = s->alignment_power; + } + + if (adjust > first_align) + { + /* Alignment may enlarge the range, adjust highest address. */ + adjust = 1 << adjust; + if (dest_address > self_address) + { + dest_address += adjust; + } + else + { + self_address += adjust; + } + } *is_reachable_p = pcrel_reloc_fits (direct_call_opcode, 0, self_address, dest_address); @@ -7182,6 +7458,221 @@ build_reloc_opcodes (bfd *abfd, return reloc_opcodes; } +struct reloc_range_struct +{ + bfd_vma addr; + bfd_boolean add; /* TRUE if start of a range, FALSE otherwise. */ + /* Original irel index in the array of relocations for a section. */ + unsigned irel_index; +}; +typedef struct reloc_range_struct reloc_range; + +typedef struct reloc_range_list_entry_struct reloc_range_list_entry; +struct reloc_range_list_entry_struct +{ + reloc_range_list_entry *next; + reloc_range_list_entry *prev; + Elf_Internal_Rela *irel; + xtensa_opcode opcode; + int opnum; +}; + +struct reloc_range_list_struct +{ + /* The rest of the structure is only meaningful when ok is TRUE. */ + bfd_boolean ok; + + unsigned n_range; /* Number of range markers. */ + reloc_range *range; /* Sorted range markers. */ + + unsigned first; /* Index of a first range element in the list. */ + unsigned last; /* One past index of a last range element in the list. */ + + unsigned n_list; /* Number of list elements. */ + reloc_range_list_entry *reloc; /* */ + reloc_range_list_entry list_root; +}; + +static int +reloc_range_compare (const void *a, const void *b) +{ + const reloc_range *ra = a; + const reloc_range *rb = b; + + if (ra->addr != rb->addr) + return ra->addr < rb->addr ? -1 : 1; + if (ra->add != rb->add) + return ra->add ? -1 : 1; + return 0; +} + +static void +build_reloc_ranges (bfd *abfd, asection *sec, + bfd_byte *contents, + Elf_Internal_Rela *internal_relocs, + xtensa_opcode *reloc_opcodes, + reloc_range_list *list) +{ + unsigned i; + size_t n = 0; + size_t max_n = 0; + reloc_range *ranges = NULL; + reloc_range_list_entry *reloc = + bfd_malloc (sec->reloc_count * sizeof (*reloc)); + + memset (list, 0, sizeof (*list)); + list->ok = TRUE; + + for (i = 0; i < sec->reloc_count; i++) + { + Elf_Internal_Rela *irel = &internal_relocs[i]; + int r_type = ELF32_R_TYPE (irel->r_info); + reloc_howto_type *howto = &elf_howto_table[r_type]; + r_reloc r_rel; + + if (r_type == R_XTENSA_ASM_SIMPLIFY + || r_type == R_XTENSA_32_PCREL + || !howto->pc_relative) + continue; + + r_reloc_init (&r_rel, abfd, irel, contents, + bfd_get_section_limit (abfd, sec)); + + if (r_reloc_get_section (&r_rel) != sec) + continue; + + if (n + 2 > max_n) + { + max_n = (max_n + 2) * 2; + ranges = bfd_realloc (ranges, max_n * sizeof (*ranges)); + } + + ranges[n].addr = irel->r_offset; + ranges[n + 1].addr = r_rel.target_offset; + + ranges[n].add = ranges[n].addr < ranges[n + 1].addr; + ranges[n + 1].add = !ranges[n].add; + + ranges[n].irel_index = i; + ranges[n + 1].irel_index = i; + + n += 2; + + reloc[i].irel = irel; + + /* Every relocation won't possibly be checked in the optimized version of + check_section_ebb_pcrels_fit, so this needs to be done here. */ + if (is_alt_relocation (ELF32_R_TYPE (irel->r_info))) + { + /* None of the current alternate relocs are PC-relative, + and only PC-relative relocs matter here. */ + } + else + { + xtensa_opcode opcode; + int opnum; + + if (reloc_opcodes) + opcode = reloc_opcodes[i]; + else + opcode = get_relocation_opcode (abfd, sec, contents, irel); + + if (opcode == XTENSA_UNDEFINED) + { + list->ok = FALSE; + break; + } + + opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info)); + if (opnum == XTENSA_UNDEFINED) + { + list->ok = FALSE; + break; + } + + /* Record relocation opcode and opnum as we've calculated them + anyway and they won't change. */ + reloc[i].opcode = opcode; + reloc[i].opnum = opnum; + } + } + + if (list->ok) + { + ranges = bfd_realloc (ranges, n * sizeof (*ranges)); + qsort (ranges, n, sizeof (*ranges), reloc_range_compare); + + list->n_range = n; + list->range = ranges; + list->reloc = reloc; + list->list_root.prev = &list->list_root; + list->list_root.next = &list->list_root; + } + else + { + free (ranges); + free (reloc); + } +} + +static void reloc_range_list_append (reloc_range_list *list, + unsigned irel_index) +{ + reloc_range_list_entry *entry = list->reloc + irel_index; + + entry->prev = list->list_root.prev; + entry->next = &list->list_root; + entry->prev->next = entry; + entry->next->prev = entry; + ++list->n_list; +} + +static void reloc_range_list_remove (reloc_range_list *list, + unsigned irel_index) +{ + reloc_range_list_entry *entry = list->reloc + irel_index; + + entry->next->prev = entry->prev; + entry->prev->next = entry->next; + --list->n_list; +} + +/* Update relocation list object so that it lists all relocations that cross + [first; last] range. Range bounds should not decrease with successive + invocations. */ +static void reloc_range_list_update_range (reloc_range_list *list, + bfd_vma first, bfd_vma last) +{ + /* This should not happen: EBBs are iterated from lower addresses to higher. + But even if that happens there's no need to break: just flush current list + and start from scratch. */ + if ((list->last > 0 && list->range[list->last - 1].addr > last) || + (list->first > 0 && list->range[list->first - 1].addr >= first)) + { + list->first = 0; + list->last = 0; + list->n_list = 0; + list->list_root.next = &list->list_root; + list->list_root.prev = &list->list_root; + fprintf (stderr, "%s: move backwards requested\n", __func__); + } + + for (; list->last < list->n_range && + list->range[list->last].addr <= last; ++list->last) + if (list->range[list->last].add) + reloc_range_list_append (list, list->range[list->last].irel_index); + + for (; list->first < list->n_range && + list->range[list->first].addr < first; ++list->first) + if (!list->range[list->first].add) + reloc_range_list_remove (list, list->range[list->first].irel_index); +} + +static void free_reloc_range_list (reloc_range_list *list) +{ + free (list->range); + free (list->reloc); +} /* The compute_text_actions function will build a list of potential transformation actions for code in the extended basic block of each @@ -7208,6 +7699,7 @@ compute_text_actions (bfd *abfd, property_table_entry *prop_table = 0; int ptblsize = 0; bfd_size_type sec_size; + reloc_range_list relevant_relocs; relax_info = get_xtensa_relax_info (sec); BFD_ASSERT (relax_info); @@ -7240,6 +7732,12 @@ compute_text_actions (bfd *abfd, goto error_return; } + /* Precompute the opcode for each relocation. */ + reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, internal_relocs); + + build_reloc_ranges (abfd, sec, contents, internal_relocs, reloc_opcodes, + &relevant_relocs); + for (i = 0; i < sec->reloc_count; i++) { Elf_Internal_Rela *irel = &internal_relocs[i]; @@ -7257,9 +7755,12 @@ compute_text_actions (bfd *abfd, simplify_size = get_asm_simplify_size (contents, sec_size, r_offset); if (simplify_size == 0) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): could not decode instruction for XTENSA_ASM_SIMPLIFY relocation; possible configuration mismatch"), - sec->owner, sec, r_offset); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): could not decode instruction for " + "XTENSA_ASM_SIMPLIFY relocation; " + "possible configuration mismatch"), + sec->owner, sec, (uint64_t) r_offset); continue; } @@ -7303,17 +7804,13 @@ compute_text_actions (bfd *abfd, ebb->start_reloc_idx = i; ebb->end_reloc_idx = i; - /* Precompute the opcode for each relocation. */ - if (reloc_opcodes == NULL) - reloc_opcodes = build_reloc_opcodes (abfd, sec, contents, - internal_relocs); - if (!extend_ebb_bounds (ebb) || !compute_ebb_proposed_actions (&ebb_table) || !compute_ebb_actions (&ebb_table) || !check_section_ebb_pcrels_fit (abfd, sec, contents, - internal_relocs, &ebb_table, - reloc_opcodes) + internal_relocs, + &relevant_relocs, + &ebb_table, reloc_opcodes) || !check_section_ebb_reduces (&ebb_table)) { /* If anything goes wrong or we get unlucky and something does @@ -7335,8 +7832,10 @@ compute_text_actions (bfd *abfd, free_ebb_constraint (&ebb_table); } + free_reloc_range_list (&relevant_relocs); + #if DEBUG - if (relax_info->action_list.head) + if (action_list_count (&relax_info->action_list)) print_action_list (stderr, &relax_info->action_list); #endif @@ -7517,9 +8016,11 @@ compute_ebb_proposed_actions (ebb_constraint *ebb_table) return TRUE; decode_error: - (*_bfd_error_handler) - (_("%B(%A+0x%lx): could not decode instruction; possible configuration mismatch"), - ebb->sec->owner, ebb->sec, offset); + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): could not decode instruction; " + "possible configuration mismatch"), + ebb->sec->owner, ebb->sec, (uint64_t) offset); return FALSE; } @@ -7769,7 +8270,7 @@ compute_ebb_actions (ebb_constraint *ebb_table) BFD_ASSERT (action->action == ta_fill); BFD_ASSERT (ebb->ends_unreachable->flags & XTENSA_PROP_UNREACHABLE); - extra_space = compute_fill_extra_space (ebb->ends_unreachable); + extra_space = xtensa_compute_fill_extra_space (ebb->ends_unreachable); br = action->removed_bytes + removed_bytes + extra_space; br = br & ((1 << ebb->sec->alignment_power ) - 1); @@ -7788,8 +8289,8 @@ typedef struct xlate_map xlate_map_t; struct xlate_map_entry { - unsigned orig_address; - unsigned new_address; + bfd_vma orig_address; + bfd_vma new_address; unsigned size; }; @@ -7820,6 +8321,7 @@ xlate_offset_with_removed_text (const xlate_map_t *map, { void *r; xlate_map_entry_t *e; + struct xlate_map_entry se; if (map == NULL) return offset_with_removed_text (action_list, offset); @@ -7827,16 +8329,73 @@ xlate_offset_with_removed_text (const xlate_map_t *map, if (map->entry_count == 0) return offset; - r = bsearch (&offset, map->entry, map->entry_count, + se.orig_address = offset; + r = bsearch (&se, map->entry, map->entry_count, sizeof (xlate_map_entry_t), &xlate_compare); e = (xlate_map_entry_t *) r; + /* There could be a jump past the end of the section, + allow it using the last xlate map entry to translate its address. */ + if (e == NULL) + { + e = map->entry + map->entry_count - 1; + if (xlate_compare (&se, e) <= 0) + e = NULL; + } BFD_ASSERT (e != NULL); if (e == NULL) return offset; return e->new_address - e->orig_address + offset; } +typedef struct xlate_map_context_struct xlate_map_context; +struct xlate_map_context_struct +{ + xlate_map_t *map; + xlate_map_entry_t *current_entry; + int removed; +}; + +static int +xlate_map_fn (splay_tree_node node, void *p) +{ + text_action *r = (text_action *)node->value; + xlate_map_context *ctx = p; + unsigned orig_size = 0; + + switch (r->action) + { + case ta_none: + case ta_remove_insn: + case ta_convert_longcall: + case ta_remove_literal: + case ta_add_literal: + break; + case ta_remove_longcall: + orig_size = 6; + break; + case ta_narrow_insn: + orig_size = 3; + break; + case ta_widen_insn: + orig_size = 2; + break; + case ta_fill: + break; + } + ctx->current_entry->size = + r->offset + orig_size - ctx->current_entry->orig_address; + if (ctx->current_entry->size != 0) + { + ctx->current_entry++; + ctx->map->entry_count++; + } + ctx->current_entry->orig_address = r->offset + orig_size; + ctx->removed += r->removed_bytes; + ctx->current_entry->new_address = r->offset + orig_size - ctx->removed; + ctx->current_entry->size = 0; + return 0; +} /* Build a binary searchable offset translation map from a section's action list. */ @@ -7844,75 +8403,40 @@ xlate_offset_with_removed_text (const xlate_map_t *map, static xlate_map_t * build_xlate_map (asection *sec, xtensa_relax_info *relax_info) { - xlate_map_t *map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t)); text_action_list *action_list = &relax_info->action_list; unsigned num_actions = 0; - text_action *r; - int removed; - xlate_map_entry_t *current_entry; + xlate_map_context ctx; - if (map == NULL) + ctx.map = (xlate_map_t *) bfd_malloc (sizeof (xlate_map_t)); + + if (ctx.map == NULL) return NULL; num_actions = action_list_count (action_list); - map->entry = (xlate_map_entry_t *) + ctx.map->entry = (xlate_map_entry_t *) bfd_malloc (sizeof (xlate_map_entry_t) * (num_actions + 1)); - if (map->entry == NULL) + if (ctx.map->entry == NULL) { - free (map); + free (ctx.map); return NULL; } - map->entry_count = 0; + ctx.map->entry_count = 0; - removed = 0; - current_entry = &map->entry[0]; + ctx.removed = 0; + ctx.current_entry = &ctx.map->entry[0]; - current_entry->orig_address = 0; - current_entry->new_address = 0; - current_entry->size = 0; + ctx.current_entry->orig_address = 0; + ctx.current_entry->new_address = 0; + ctx.current_entry->size = 0; - for (r = action_list->head; r != NULL; r = r->next) - { - unsigned orig_size = 0; - switch (r->action) - { - case ta_none: - case ta_remove_insn: - case ta_convert_longcall: - case ta_remove_literal: - case ta_add_literal: - break; - case ta_remove_longcall: - orig_size = 6; - break; - case ta_narrow_insn: - orig_size = 3; - break; - case ta_widen_insn: - orig_size = 2; - break; - case ta_fill: - break; - } - current_entry->size = - r->offset + orig_size - current_entry->orig_address; - if (current_entry->size != 0) - { - current_entry++; - map->entry_count++; - } - current_entry->orig_address = r->offset + orig_size; - removed += r->removed_bytes; - current_entry->new_address = r->offset + orig_size - removed; - current_entry->size = 0; - } + splay_tree_foreach (action_list->tree, xlate_map_fn, &ctx); - current_entry->size = (bfd_get_section_limit (sec->owner, sec) - - current_entry->orig_address); - if (current_entry->size != 0) - map->entry_count++; + ctx.current_entry->size = (bfd_get_section_limit (sec->owner, sec) + - ctx.current_entry->orig_address); + if (ctx.current_entry->size != 0) + ctx.map->entry_count++; - return map; + return ctx.map; } @@ -7937,14 +8461,17 @@ check_section_ebb_pcrels_fit (bfd *abfd, asection *sec, bfd_byte *contents, Elf_Internal_Rela *internal_relocs, + reloc_range_list *relevant_relocs, const ebb_constraint *constraint, const xtensa_opcode *reloc_opcodes) { unsigned i, j; + unsigned n = sec->reloc_count; Elf_Internal_Rela *irel; xlate_map_t *xmap = NULL; bfd_boolean ok = TRUE; xtensa_relax_info *relax_info; + reloc_range_list_entry *entry = NULL; relax_info = get_xtensa_relax_info (sec); @@ -7955,7 +8482,40 @@ check_section_ebb_pcrels_fit (bfd *abfd, can still be used. */ } - for (i = 0; i < sec->reloc_count; i++) + if (relevant_relocs && constraint->action_count) + { + if (!relevant_relocs->ok) + { + ok = FALSE; + n = 0; + } + else + { + bfd_vma min_offset, max_offset; + min_offset = max_offset = constraint->actions[0].offset; + + for (i = 1; i < constraint->action_count; ++i) + { + proposed_action *action = &constraint->actions[i]; + bfd_vma offset = action->offset; + + if (offset < min_offset) + min_offset = offset; + if (offset > max_offset) + max_offset = offset; + } + reloc_range_list_update_range (relevant_relocs, min_offset, + max_offset); + n = relevant_relocs->n_list; + entry = &relevant_relocs->list_root; + } + } + else + { + relevant_relocs = NULL; + } + + for (i = 0; i < n; i++) { r_reloc r_rel; bfd_vma orig_self_offset, orig_target_offset; @@ -7964,7 +8524,15 @@ check_section_ebb_pcrels_fit (bfd *abfd, reloc_howto_type *howto; int self_removed_bytes, target_removed_bytes; - irel = &internal_relocs[i]; + if (relevant_relocs) + { + entry = entry->next; + irel = entry->irel; + } + else + { + irel = internal_relocs + i; + } r_type = ELF32_R_TYPE (irel->r_info); howto = &elf_howto_table[r_type]; @@ -8030,21 +8598,30 @@ check_section_ebb_pcrels_fit (bfd *abfd, xtensa_opcode opcode; int opnum; - if (reloc_opcodes) - opcode = reloc_opcodes[i]; - else - opcode = get_relocation_opcode (abfd, sec, contents, irel); - if (opcode == XTENSA_UNDEFINED) + if (relevant_relocs) { - ok = FALSE; - break; + opcode = entry->opcode; + opnum = entry->opnum; } - - opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info)); - if (opnum == XTENSA_UNDEFINED) + else { - ok = FALSE; - break; + if (reloc_opcodes) + opcode = reloc_opcodes[relevant_relocs ? + (unsigned)(entry - relevant_relocs->reloc) : i]; + else + opcode = get_relocation_opcode (abfd, sec, contents, irel); + if (opcode == XTENSA_UNDEFINED) + { + ok = FALSE; + break; + } + + opnum = get_relocation_opnd (opcode, ELF32_R_TYPE (irel->r_info)); + if (opnum == XTENSA_UNDEFINED) + { + ok = FALSE; + break; + } } if (!pcrel_reloc_fits (opcode, opnum, self_offset, target_offset)) @@ -8117,7 +8694,7 @@ text_action_add_proposed (text_action_list *l, int -compute_fill_extra_space (property_table_entry *entry) +xtensa_compute_fill_extra_space (property_table_entry *entry) { int fill_extra_space; @@ -8398,7 +8975,7 @@ remove_dead_literal (bfd *abfd, do not add fill. */ the_add_entry = elf_xtensa_find_property_entry (prop_table, ptblsize, entry_sec_offset); - fill_extra_space = compute_fill_extra_space (the_add_entry); + fill_extra_space = xtensa_compute_fill_extra_space (the_add_entry); fa = find_fill_action (&relax_info->action_list, sec, entry_sec_offset); removed_diff = compute_removed_action_diff (fa, sec, entry_sec_offset, @@ -8456,7 +9033,7 @@ identify_literal_placement (bfd *abfd, sec_size = bfd_get_section_limit (abfd, sec); final_static_link = - (!link_info->relocatable + (!bfd_link_relocatable (link_info) && !elf_hash_table (link_info)->dynamic_sections_created); /* The placement algorithm first checks to see if the literal is @@ -8495,7 +9072,7 @@ identify_literal_placement (bfd *abfd, /* For relocatable links, do not try to move literals. To do it correctly might increase the number of relocations in an input section making the default relocatable linking fail. */ - if (!link_info->relocatable && !literal_placed + if (!bfd_link_relocatable (link_info) && !literal_placed && values->has_last_loc && !(*last_loc_is_prev_p)) { asection *target_sec = r_reloc_get_section (&values->last_loc); @@ -8574,7 +9151,7 @@ relocations_reach (source_reloc *reloc, continue; /* The original and new output section for these must be the same - in order to coalesce. */ + in order to coalesce. */ if (r_reloc_get_section (&reloc[i].r_rel)->output_section != sec->output_section) return FALSE; @@ -8741,7 +9318,7 @@ move_shared_literal (asection *sec, /* Check all of the PC-relative relocations to make sure they still fit. */ relocs_fit = check_section_ebb_pcrels_fit (target_sec->owner, target_sec, target_sec_cache->contents, - target_sec_cache->relocs, + target_sec_cache->relocs, NULL, &ebb_table, NULL); if (!relocs_fit) @@ -8823,6 +9400,16 @@ move_shared_literal (asection *sec, /* Second relaxation pass. */ +static int +action_remove_bytes_fn (splay_tree_node node, void *p) +{ + bfd_size_type *final_size = p; + text_action *action = (text_action *)node->value; + + *final_size -= action->removed_bytes; + return 0; +} + /* Modify all of the relocations to point to the right spot, and if this is a relaxable section, delete the unwanted literals and fix the section size. */ @@ -8855,7 +9442,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) internal_relocs = retrieve_internal_relocs (abfd, sec, link_info->keep_memory); - if (!internal_relocs && !relax_info->action_list.head) + if (!internal_relocs && !action_list_count (&relax_info->action_list)) return TRUE; contents = retrieve_contents (abfd, sec, link_info->keep_memory); @@ -8906,7 +9493,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) if (elf_hash_table (link_info)->dynamic_sections_created) shrink_dynamic_reloc_sections (link_info, abfd, sec, irel); irel->r_info = ELF32_R_INFO (0, R_XTENSA_NONE); - irel->r_offset = offset_with_removed_text + irel->r_offset = offset_with_removed_text_map (&relax_info->action_list, irel->r_offset); continue; } @@ -8933,6 +9520,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) } /* Update the action so that the code that moves the contents will do the right thing. */ + /* ta_remove_longcall and ta_remove_insn actions are + grouped together in the tree as well as + ta_convert_longcall and ta_none, so that changes below + can be done w/o removing and reinserting action into + the tree. */ + if (action->action == ta_remove_longcall) action->action = ta_remove_insn; else @@ -8943,7 +9536,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) } } - source_offset = offset_with_removed_text + source_offset = offset_with_removed_text_map (&relax_info->action_list, irel->r_offset); irel->r_offset = source_offset; } @@ -9040,7 +9633,7 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) break; } - new_end_offset = offset_with_removed_text + new_end_offset = offset_with_removed_text_map (&target_relax_info->action_list, r_rel.target_offset + diff_value); diff_value = new_end_offset - new_reloc.target_offset; @@ -9105,13 +9698,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) if ((relax_info->is_relaxable_literal_section || relax_info->is_relaxable_asm_section) - && relax_info->action_list.head) + && action_list_count (&relax_info->action_list)) { /* Walk through the planned actions and build up a table of move, copy and fill records. Use the move, copy and fill records to perform the actions once. */ - int removed = 0; bfd_size_type final_size, copy_size, orig_insn_size; bfd_byte *scratch = NULL; bfd_byte *dup_contents = NULL; @@ -9122,15 +9714,12 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) bfd_vma orig_dot_vo = 0; /* Virtual offset from orig_dot. */ bfd_vma dup_dot = 0; - text_action *action = relax_info->action_list.head; + text_action *action; final_size = sec->size; - for (action = relax_info->action_list.head; action; - action = action->next) - { - final_size -= action->removed_bytes; - } + splay_tree_foreach (relax_info->action_list.tree, + action_remove_bytes_fn, &final_size); scratch = (bfd_byte *) bfd_zmalloc (final_size); dup_contents = (bfd_byte *) bfd_zmalloc (final_size); @@ -9139,8 +9728,8 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) print_action_list (stderr, &relax_info->action_list); #endif - for (action = relax_info->action_list.head; action; - action = action->next) + for (action = action_first (&relax_info->action_list); action; + action = action_next (&relax_info->action_list, action)) { virtual_action = FALSE; if (action->offset > orig_dot) @@ -9269,7 +9858,6 @@ relax_section (bfd *abfd, asection *sec, struct bfd_link_info *link_info) break; } - removed += action->removed_bytes; BFD_ASSERT (dup_dot <= final_size); BFD_ASSERT (orig_dot <= orig_size); } @@ -9438,7 +10026,6 @@ translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec) xtensa_relax_info *relax_info; removed_literal *removed; bfd_vma target_offset, base_offset; - text_action *act; *new_rel = *orig_rel; @@ -9491,19 +10078,26 @@ translate_reloc (const r_reloc *orig_rel, r_reloc *new_rel, asection *sec) offset. */ base_offset = r_reloc_get_target_offset (new_rel) - new_rel->rela.r_addend; - act = relax_info->action_list.head; if (base_offset <= target_offset) { - int base_removed = removed_by_actions (&act, base_offset, FALSE); - int addend_removed = removed_by_actions (&act, target_offset, FALSE); + int base_removed = removed_by_actions_map (&relax_info->action_list, + base_offset, FALSE); + int addend_removed = removed_by_actions_map (&relax_info->action_list, + target_offset, FALSE) - + base_removed; + new_rel->target_offset = target_offset - base_removed - addend_removed; new_rel->rela.r_addend -= addend_removed; } else { /* Handle a negative addend. The base offset comes first. */ - int tgt_removed = removed_by_actions (&act, target_offset, FALSE); - int addend_removed = removed_by_actions (&act, base_offset, FALSE); + int tgt_removed = removed_by_actions_map (&relax_info->action_list, + target_offset, FALSE); + int addend_removed = removed_by_actions_map (&relax_info->action_list, + base_offset, FALSE) - + tgt_removed; + new_rel->target_offset = target_offset - tgt_removed; new_rel->rela.r_addend += addend_removed; } @@ -9554,18 +10148,21 @@ shrink_dynamic_reloc_sections (struct bfd_link_info *info, if ((r_type == R_XTENSA_32 || r_type == R_XTENSA_PLT) && (input_section->flags & SEC_ALLOC) != 0 - && (dynamic_symbol || info->shared)) + && (dynamic_symbol || bfd_link_pic (info)) + && (!h || h->root.type != bfd_link_hash_undefweak + || (dynamic_symbol + && (bfd_link_dll (info) || info->export_dynamic)))) { asection *srel; bfd_boolean is_plt = FALSE; if (dynamic_symbol && r_type == R_XTENSA_PLT) { - srel = htab->srelplt; + srel = htab->elf.srelplt; is_plt = TRUE; } else - srel = htab->srelgot; + srel = htab->elf.srelgot; /* Reduce size of the .rela.* section by one reloc. */ BFD_ASSERT (srel != NULL); @@ -9594,7 +10191,7 @@ shrink_dynamic_reloc_sections (struct bfd_link_info *info, if (reloc_index % PLT_ENTRIES_PER_CHUNK == 0) { /* The two magic GOT entries for that chunk can go away. */ - srelgot = htab->srelgot; + srelgot = htab->elf.srelgot; BFD_ASSERT (srelgot != NULL); srelgot->reloc_count -= 2; srelgot->size -= 2 * sizeof (Elf32_External_Rela); @@ -9660,7 +10257,7 @@ move_literal (bfd *abfd, bfd_put_32 (abfd, lit->value, contents + offset); /* Currently, we cannot move relocations during a relocatable link. */ - BFD_ASSERT (!link_info->relocatable); + BFD_ASSERT (!bfd_link_relocatable (link_info)); fix = reloc_bfd_fix_init (sec, offset, r_type, r_reloc_get_section (r_rel), r_rel->target_offset + r_rel->virtual_offset, @@ -9826,9 +10423,10 @@ relax_property_section (bfd *abfd, bfd_vma old_offset = val.r_rel.target_offset; bfd_vma new_offset; long old_size, new_size; - text_action *act = target_relax_info->action_list.head; - new_offset = old_offset - - removed_by_actions (&act, old_offset, FALSE); + int removed_by_old_offset = + removed_by_actions_map (&target_relax_info->action_list, + old_offset, FALSE); + new_offset = old_offset - removed_by_old_offset; /* Assert that we are not out of bounds. */ old_size = bfd_get_32 (abfd, size_p); @@ -9852,9 +10450,10 @@ relax_property_section (bfd *abfd, /* Recompute the new_offset, but this time don't include any fill inserted by relaxation. */ - act = target_relax_info->action_list.head; - new_offset = old_offset - - removed_by_actions (&act, old_offset, TRUE); + removed_by_old_offset = + removed_by_actions_map (&target_relax_info->action_list, + old_offset, TRUE); + new_offset = old_offset - removed_by_old_offset; /* If it is not unreachable and we have not yet seen an unreachable at this address, place it @@ -9870,8 +10469,12 @@ relax_property_section (bfd *abfd, } } else - new_size -= - removed_by_actions (&act, old_offset + old_size, TRUE); + { + int removed_by_old_offset_size = + removed_by_actions_map (&target_relax_info->action_list, + old_offset + old_size, TRUE); + new_size -= removed_by_old_offset_size - removed_by_old_offset; + } if (new_size != old_size) { @@ -9893,7 +10496,7 @@ relax_property_section (bfd *abfd, finish_dynamic_sections() but at that point it's too late to reclaim the space in the output section, so we do this twice. */ - if (internal_relocs && (!link_info->relocatable + if (internal_relocs && (!bfd_link_relocatable (link_info) || xtensa_is_littable_section (sec))) { Elf_Internal_Rela *last_irel = NULL; @@ -9905,7 +10508,7 @@ relax_property_section (bfd *abfd, predef_flags = xtensa_get_property_predef_flags (sec); /* Walk over memory and relocations at the same time. - This REQUIRES that the internal_relocs be sorted by offset. */ + This REQUIRES that the internal_relocs be sorted by offset. */ qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela), internal_reloc_compare); @@ -10129,14 +10732,16 @@ relax_section_symbols (bfd *abfd, asection *sec) if (isym->st_shndx == sec_shndx) { - text_action *act = relax_info->action_list.head; bfd_vma orig_addr = isym->st_value; + int removed = removed_by_actions_map (&relax_info->action_list, + orig_addr, FALSE); - isym->st_value -= removed_by_actions (&act, orig_addr, FALSE); - + isym->st_value -= removed; if (ELF32_ST_TYPE (isym->st_info) == STT_FUNC) isym->st_size -= - removed_by_actions (&act, orig_addr + isym->st_size, FALSE); + removed_by_actions_map (&relax_info->action_list, + orig_addr + isym->st_size, FALSE) - + removed; } } @@ -10154,15 +10759,17 @@ relax_section_symbols (bfd *abfd, asection *sec) || sym_hash->root.type == bfd_link_hash_defweak) && sym_hash->root.u.def.section == sec) { - text_action *act = relax_info->action_list.head; bfd_vma orig_addr = sym_hash->root.u.def.value; + int removed = removed_by_actions_map (&relax_info->action_list, + orig_addr, FALSE); - sym_hash->root.u.def.value -= - removed_by_actions (&act, orig_addr, FALSE); + sym_hash->root.u.def.value -= removed; if (sym_hash->type == STT_FUNC) sym_hash->size -= - removed_by_actions (&act, orig_addr + sym_hash->size, FALSE); + removed_by_actions_map (&relax_info->action_list, + orig_addr + sym_hash->size, FALSE) - + removed; } } @@ -10200,9 +10807,10 @@ do_fix_for_relocatable_link (Elf_Internal_Rela *rel, { if (r_type != R_XTENSA_ASM_EXPAND) { - (*_bfd_error_handler) - (_("%B(%A+0x%lx): unexpected fix for %s relocation"), - input_bfd, input_section, rel->r_offset, + _bfd_error_handler + /* xgettext:c-format */ + (_("%pB(%pA+%#" PRIx64 "): unexpected fix for %s relocation"), + input_bfd, input_section, (uint64_t) rel->r_offset, elf_howto_table[r_type].name); return FALSE; } @@ -10260,18 +10868,11 @@ do_fix_for_final_link (Elf_Internal_Rela *rel, static asection * elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk) { - struct elf_xtensa_link_hash_table *htab; bfd *dynobj; - char plt_name[10]; + char plt_name[17]; if (chunk == 0) - { - htab = elf_xtensa_hash_table (info); - if (htab == NULL) - return NULL; - - return htab->splt; - } + return elf_hash_table (info)->splt; dynobj = elf_hash_table (info)->dynobj; sprintf (plt_name, ".plt.%u", chunk); @@ -10282,17 +10883,11 @@ elf_xtensa_get_plt_section (struct bfd_link_info *info, int chunk) static asection * elf_xtensa_get_gotplt_section (struct bfd_link_info *info, int chunk) { - struct elf_xtensa_link_hash_table *htab; bfd *dynobj; - char got_name[14]; + char got_name[21]; if (chunk == 0) - { - htab = elf_xtensa_hash_table (info); - if (htab == NULL) - return NULL; - return htab->sgotplt; - } + return elf_hash_table (info)->sgotplt; dynobj = elf_hash_table (info)->dynobj; sprintf (got_name, ".got.plt.%u", chunk); @@ -10336,8 +10931,8 @@ get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx) struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx]; while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) - h = (struct elf_link_hash_entry *) h->root.u.i.link; + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; switch (h->root.type) { @@ -10401,10 +10996,10 @@ get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx) elf_sym_hashes (abfd)[indx]; while (h->root.type == bfd_link_hash_indirect - || h->root.type == bfd_link_hash_warning) + || h->root.type == bfd_link_hash_warning) h = (struct elf_link_hash_entry *) h->root.u.i.link; if (h->root.type == bfd_link_hash_defined - || h->root.type == bfd_link_hash_defweak) + || h->root.type == bfd_link_hash_defweak) offset = h->root.u.def.value; } return offset; @@ -10534,10 +11129,30 @@ match_section_group (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *inf) } +static char * +xtensa_add_names (const char *base, const char *suffix) +{ + if (suffix) + { + size_t base_len = strlen (base); + size_t suffix_len = strlen (suffix); + char *str = bfd_malloc (base_len + suffix_len + 1); + + memcpy (str, base, base_len); + memcpy (str + base_len, suffix, suffix_len + 1); + return str; + } + else + { + return strdup (base); + } +} + static int linkonce_len = sizeof (".gnu.linkonce.") - 1; static char * -xtensa_property_section_name (asection *sec, const char *base_name) +xtensa_property_section_name (asection *sec, const char *base_name, + bfd_boolean separate_sections) { const char *suffix, *group_name; char *prop_sec_name; @@ -10548,11 +11163,7 @@ xtensa_property_section_name (asection *sec, const char *base_name) suffix = strrchr (sec->name, '.'); if (suffix == sec->name) suffix = 0; - prop_sec_name = (char *) bfd_malloc (strlen (base_name) + 1 - + (suffix ? strlen (suffix) : 0)); - strcpy (prop_sec_name, base_name); - if (suffix) - strcat (prop_sec_name, suffix); + prop_sec_name = xtensa_add_names (base_name, suffix); } else if (strncmp (sec->name, ".gnu.linkonce.", linkonce_len) == 0) { @@ -10574,25 +11185,30 @@ xtensa_property_section_name (asection *sec, const char *base_name) suffix = sec->name + linkonce_len; /* For backward compatibility, replace "t." instead of inserting - the new linkonce_kind (but not for "prop" sections). */ + the new linkonce_kind (but not for "prop" sections). */ if (CONST_STRNEQ (suffix, "t.") && linkonce_kind[1] == '.') - suffix += 2; + suffix += 2; strcat (prop_sec_name + linkonce_len, suffix); } else - prop_sec_name = strdup (base_name); + { + prop_sec_name = xtensa_add_names (base_name, + separate_sections ? sec->name : NULL); + } return prop_sec_name; } static asection * -xtensa_get_property_section (asection *sec, const char *base_name) +xtensa_get_separate_property_section (asection *sec, const char *base_name, + bfd_boolean separate_section) { char *prop_sec_name; asection *prop_sec; - prop_sec_name = xtensa_property_section_name (sec, base_name); + prop_sec_name = xtensa_property_section_name (sec, base_name, + separate_section); prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name, match_section_group, (void *) elf_group_name (sec)); @@ -10600,6 +11216,21 @@ xtensa_get_property_section (asection *sec, const char *base_name) return prop_sec; } +static asection * +xtensa_get_property_section (asection *sec, const char *base_name) +{ + asection *prop_sec; + + /* Try individual property section first. */ + prop_sec = xtensa_get_separate_property_section (sec, base_name, TRUE); + + /* Refer to a common property section if individual is not present. */ + if (!prop_sec) + prop_sec = xtensa_get_separate_property_section (sec, base_name, FALSE); + + return prop_sec; +} + asection * xtensa_make_property_section (asection *sec, const char *base_name) @@ -10608,7 +11239,8 @@ xtensa_make_property_section (asection *sec, const char *base_name) asection *prop_sec; /* Check if the section already exists. */ - prop_sec_name = xtensa_property_section_name (sec, base_name); + prop_sec_name = xtensa_property_section_name (sec, base_name, + elf32xtensa_separate_props); prop_sec = bfd_get_section_by_name_if (sec->owner, prop_sec_name, match_section_group, (void *) elf_group_name (sec)); @@ -10616,7 +11248,7 @@ xtensa_make_property_section (asection *sec, const char *base_name) if (! prop_sec) { flagword flags = (SEC_RELOC | SEC_HAS_CONTENTS | SEC_READONLY); - flags |= (bfd_get_section_flags (sec->owner, sec) + flags |= (bfd_section_flags (sec) & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES)); prop_sec = bfd_make_section_anyway_with_flags @@ -10675,7 +11307,7 @@ xtensa_callback_required_dependence (bfd *abfd, /* Find the corresponding ".got.plt*" section. */ if (sec->name[4] == '\0') - sgotplt = bfd_get_linker_section (sec->owner, ".got.plt"); + sgotplt = elf_hash_table (link_info)->sgotplt; else { char got_name[14]; @@ -10753,9 +11385,9 @@ static const struct bfd_elf_special_section elf_xtensa_special_sections[] = { { STRING_COMMA_LEN (".fini.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, { STRING_COMMA_LEN (".init.literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, - { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, - { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 }, - { NULL, 0, 0, 0, 0 } + { STRING_COMMA_LEN (".literal"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR }, + { STRING_COMMA_LEN (".xtensa.info"), 0, SHT_NOTE, 0 }, + { NULL, 0, 0, 0, 0 } }; #define ELF_TARGET_ID XTENSA_ELF_DATA @@ -10769,11 +11401,7 @@ static const struct bfd_elf_special_section elf_xtensa_special_sections[] = #define ELF_MACHINE_CODE EM_XTENSA #define ELF_MACHINE_ALT1 EM_XTENSA_OLD -#if XCHAL_HAVE_MMU -#define ELF_MAXPAGESIZE (1 << XCHAL_MMU_MIN_PTE_PAGE_SIZE) -#else /* !XCHAL_HAVE_MMU */ -#define ELF_MAXPAGESIZE 1 -#endif /* !XCHAL_HAVE_MMU */ +#define ELF_MAXPAGESIZE 0x1000 #endif /* ELF_ARCH */ #define elf_backend_can_gc_sections 1 @@ -10782,6 +11410,7 @@ static const struct bfd_elf_special_section elf_xtensa_special_sections[] = #define elf_backend_got_header_size 4 #define elf_backend_want_dynbss 0 #define elf_backend_want_got_plt 1 +#define elf_backend_dtrel_excludes_plt 1 #define elf_info_to_howto elf_xtensa_info_to_howto_rela @@ -10806,7 +11435,6 @@ static const struct bfd_elf_special_section elf_xtensa_special_sections[] = #define elf_backend_finish_dynamic_sections elf_xtensa_finish_dynamic_sections #define elf_backend_finish_dynamic_symbol elf_xtensa_finish_dynamic_symbol #define elf_backend_gc_mark_hook elf_xtensa_gc_mark_hook -#define elf_backend_gc_sweep_hook elf_xtensa_gc_sweep_hook #define elf_backend_grok_prstatus elf_xtensa_grok_prstatus #define elf_backend_grok_psinfo elf_xtensa_grok_psinfo #define elf_backend_hide_symbol elf_xtensa_hide_symbol @@ -10815,8 +11443,7 @@ static const struct bfd_elf_special_section elf_xtensa_special_sections[] = #define elf_backend_relocate_section elf_xtensa_relocate_section #define elf_backend_size_dynamic_sections elf_xtensa_size_dynamic_sections #define elf_backend_always_size_sections elf_xtensa_always_size_sections -#define elf_backend_omit_section_dynsym \ - ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) +#define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all #define elf_backend_special_sections elf_xtensa_special_sections #define elf_backend_action_discarded elf_xtensa_action_discarded #define elf_backend_copy_indirect_symbol elf_xtensa_copy_indirect_symbol