#endif
+/* An initial stub used if the PLT entry is referenced from Thumb code. */
+#define PLT_THUMB_STUB_SIZE 4
+static const bfd_vma elf32_arm_plt_thumb_stub [] =
+ {
+ 0x4778, /* bx pc */
+ 0x46c0 /* nop */
+ };
+
/* The entries in a PLT when using a DLL-based target with multiple
address spaces. */
static const bfd_vma elf32_arm_symbian_plt_entry [] =
/* Number of PC relative relocs copied for this symbol. */
struct elf32_arm_relocs_copied * relocs_copied;
+
+ /* We reference count Thumb references to a PLT entry separately,
+ so that we can emit the Thumb trampoline only if needed. */
+ bfd_signed_vma plt_thumb_refcount;
+
+ /* Since PLT entries have variable size if the Thumb prologue is
+ used, we need to record the index into .got.plt instead of
+ recomputing it from the PLT offset. */
+ bfd_signed_vma plt_got_offset;
};
/* Traverse an arm ELF linker hash table. */
#define elf32_arm_link_hash_traverse(table, func, info) \
(elf_link_hash_traverse \
(&(table)->root, \
- (bfd_boolean (*) (struct elf_link_hash_entry *, void *))) (func), \
+ (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
(info)))
/* Get the ARM elf linker hash table from a link_info structure. */
/* An arbitrary input BFD chosen to hold the glue sections. */
bfd * bfd_of_glue_owner;
- /* A boolean indicating whether knowledge of the ARM's pipeline
- length should be applied by the linker. */
- int no_pipeline_knowledge;
-
/* Nonzero to output a BE8 image. */
int byteswap_code;
/* Small local sym to section mapping cache. */
struct sym_sec_cache sym_sec;
+
+ /* For convenience in allocate_dynrelocs. */
+ bfd * obfd;
};
/* Create an entry in an ARM ELF linker hash table. */
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
table, string));
if (ret != NULL)
- ret->relocs_copied = NULL;
+ {
+ ret->relocs_copied = NULL;
+ ret->plt_thumb_refcount = 0;
+ ret->plt_got_offset = -1;
+ }
return (struct bfd_hash_entry *) ret;
}
eind->relocs_copied = NULL;
}
+ /* If the direct symbol already has an associated PLT entry, the
+ indirect symbol should not. If it doesn't, swap refcount information
+ from the indirect symbol. */
+ if (edir->plt_thumb_refcount == 0)
+ {
+ edir->plt_thumb_refcount = eind->plt_thumb_refcount;
+ eind->plt_thumb_refcount = 0;
+ }
+ else
+ BFD_ASSERT (eind->plt_thumb_refcount == 0);
+
_bfd_elf_link_hash_copy_indirect (bed, dir, ind);
}
ret->thumb_glue_size = 0;
ret->arm_glue_size = 0;
ret->bfd_of_glue_owner = NULL;
- ret->no_pipeline_knowledge = 0;
ret->byteswap_code = 0;
ret->target1_is_rel = 0;
ret->target2_reloc = R_ARM_NONE;
#endif
ret->symbian_p = 0;
ret->sym_sec.abfd = NULL;
+ ret->obfd = abfd;
return &ret->root.root;
}
tmp_name, BSF_GLOBAL, s, val,
NULL, TRUE, FALSE, &bh);
+ myh = (struct elf_link_hash_entry *) bh;
+ myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
+ myh->forced_local = 1;
+
free (tmp_name);
globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
struct elf_link_hash_entry *myh;
struct bfd_link_hash_entry *bh;
struct elf32_arm_link_hash_table *hash_table;
- char bind;
bfd_vma val;
hash_table = elf32_arm_hash_table (link_info);
/* If we mark it 'Thumb', the disassembler will do a better job. */
myh = (struct elf_link_hash_entry *) bh;
- bind = ELF_ST_BIND (myh->type);
- myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
+ myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
+ myh->forced_local = 1;
free (tmp_name);
if (info->relocatable)
return TRUE;
+ /* Make sure we don't attach the glue sections to a dynamic object. */
+ BFD_ASSERT (!(abfd->flags & DYNAMIC));
+
globals = elf32_arm_hash_table (info);
BFD_ASSERT (globals != NULL);
bfd_boolean
bfd_elf32_arm_process_before_allocation (bfd *abfd,
struct bfd_link_info *link_info,
- int no_pipeline_knowledge,
int byteswap_code)
{
Elf_Internal_Shdr *symtab_hdr;
BFD_ASSERT (globals != NULL);
BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
- globals->no_pipeline_knowledge = no_pipeline_knowledge;
-
if (byteswap_code && !bfd_big_endian (abfd))
{
_bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
/* These are the only relocation types we care about. */
if ( r_type != R_ARM_PC24
+ && r_type != R_ARM_PLT32
#ifndef OLD_ARM_ABI
&& r_type != R_ARM_CALL
&& r_type != R_ARM_JUMP24
if (h == NULL)
continue;
+ /* If the call will go through a PLT entry then we do not need
+ glue. */
+ if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
+ continue;
+
switch (r_type)
{
case R_ARM_PC24:
will use the symbol's value, which may point to a PLT entry, but we
don't need to handle that here. If we created a PLT entry, all
branches in this object should go to it. */
- if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
-#ifndef OLD_ARM_ABI
- && r_type != R_ARM_PREL31
-#endif
- )
+ if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
&& h != NULL
&& splt != NULL
&& h->plt.offset != (bfd_vma) -1)
into the output file to be resolved at run time. */
if (info->shared
&& (input_section->flags & SEC_ALLOC)
- && ((r_type != R_ARM_REL32
-#ifndef OLD_ARM_ABI
- && r_type != R_ARM_PREL31
-#endif
- ) || !SYMBOL_CALLS_LOCAL (info, h))
+ && (r_type != R_ARM_REL32
+ || !SYMBOL_CALLS_LOCAL (info, h))
&& (h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak)
#ifndef OLD_ARM_ABI
&& r_type != R_ARM_CALL
&& r_type != R_ARM_JUMP24
+ && r_type != R_ARM_PREL31
#endif
&& r_type != R_ARM_PLT32)
{
/* This symbol is local, or marked to become local. */
relocate = TRUE;
+ if (sym_flags == STT_ARM_TFUNC)
+ value |= 1;
if (globals->symbian_p)
{
/* On Symbian OS, the data segment and text segement
}
}
- if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
- || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
- {
- /* The old way of doing things. Trearing the addend as a
- byte sized field and adding in the pipeline offset. */
- value -= (input_section->output_section->vma
- + input_section->output_offset);
- value -= rel->r_offset;
- value += addend;
-
- if (! globals->no_pipeline_knowledge)
- value -= 8;
- }
- else
- {
- /* The ARM ELF ABI says that this reloc is computed as: S - P + A
- where:
- S is the address of the symbol in the relocation.
- P is address of the instruction being relocated.
- A is the addend (extracted from the instruction) in bytes.
-
- S is held in 'value'.
- P is the base address of the section containing the
- instruction plus the offset of the reloc into that
- section, ie:
- (input_section->output_section->vma +
- input_section->output_offset +
- rel->r_offset).
- A is the addend, converted into bytes, ie:
- (signed_addend * 4)
-
- Note: None of these operations have knowledge of the pipeline
- size of the processor, thus it is up to the assembler to
- encode this information into the addend. */
- value -= (input_section->output_section->vma
- + input_section->output_offset);
- value -= rel->r_offset;
- value += (signed_addend << howto->size);
-
- /* Previous versions of this code also used to add in the
- pipeline offset here. This is wrong because the linker is
- not supposed to know about such things, and one day it might
- change. In order to support old binaries that need the old
- behaviour however, so we attempt to detect which ABI was
- used to create the reloc. */
- if (! globals->no_pipeline_knowledge)
- {
- Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
-
- i_ehdrp = elf_elfheader (input_bfd);
-
- if (i_ehdrp->e_ident[EI_OSABI] == 0)
- value -= 8;
- }
- }
+ /* The ARM ELF ABI says that this reloc is computed as: S - P + A
+ where:
+ S is the address of the symbol in the relocation.
+ P is address of the instruction being relocated.
+ A is the addend (extracted from the instruction) in bytes.
+
+ S is held in 'value'.
+ P is the base address of the section containing the
+ instruction plus the offset of the reloc into that
+ section, ie:
+ (input_section->output_section->vma +
+ input_section->output_offset +
+ rel->r_offset).
+ A is the addend, converted into bytes, ie:
+ (signed_addend * 4)
+
+ Note: None of these operations have knowledge of the pipeline
+ size of the processor, thus it is up to the assembler to
+ encode this information into the addend. */
+ value -= (input_section->output_section->vma
+ + input_section->output_offset);
+ value -= rel->r_offset;
+ value += (signed_addend << howto->size);
signed_addend = value;
signed_addend >>= howto->rightshift;
{
/* If it is not a call to Thumb, assume call to Arm.
If it is a call relative to a section name, then it is not a
- function call at all, but rather a long jump. */
- if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
+ function call at all, but rather a long jump. Calls through
+ the PLT do not require stubs. */
+ if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
+ && (h == NULL || splt == NULL
+ || h->plt.offset == (bfd_vma) -1))
{
if (elf32_thumb_to_arm_stub
(info, sym_name, input_bfd, output_bfd, input_section,
}
}
+ /* Handle calls via the PLT. */
+ if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
+ {
+ value = (splt->output_section->vma
+ + splt->output_offset
+ + h->plt.offset);
+ /* Target the Thumb stub before the ARM PLT entry. */
+ value -= 4;
+ }
+
relocation = value + signed_addend;
relocation -= (input_section->output_section->vma
+ input_section->output_offset
+ rel->r_offset);
- if (! globals->no_pipeline_knowledge)
- {
- Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form. */
-
- i_ehdrp = elf_elfheader (input_bfd);
-
- /* Previous versions of this code also used to add in the pipline
- offset here. This is wrong because the linker is not supposed
- to know about such things, and one day it might change. In order
- to support old binaries that need the old behaviour however, so
- we attempt to detect which ABI was used to create the reloc. */
- if ( strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
- || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
- || i_ehdrp->e_ident[EI_OSABI] == 0)
- relocation += 4;
- }
-
check = relocation >> howto->rightshift;
/* If this is a signed value, the rightshift just dropped
off &= ~1;
else
{
+ /* If we are addressing a Thumb function, we need to
+ adjust the address by one, so that attempts to
+ call the function pointer will correctly
+ interpret it as Thumb code. */
+ if (sym_flags == STT_ARM_TFUNC)
+ value |= 1;
+
bfd_put_32 (output_bfd, value, sgot->contents + off);
if (info->shared)
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
const char *name;
+ struct elf32_arm_link_hash_table * globals;
#if !USE_REL
if (info->relocatable)
return TRUE;
#endif
+ globals = elf32_arm_hash_table (info);
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (input_bfd);
r_symndx = ELF32_R_SYM (rel->r_info);
r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = arm_real_reloc_type (globals, r_type);
if ( r_type == R_ARM_GNU_VTENTRY
|| r_type == R_ARM_GNU_VTINHERIT)
continue;
- elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
+ bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
howto = bfd_reloc.howto;
#if USE_REL
#ifndef OLD_ARM_ABI
case R_ARM_CALL:
case R_ARM_JUMP24:
+ case R_ARM_PREL31:
#endif
case R_ARM_ABS32:
case R_ARM_THM_PC22:
elf_elfheader (obfd)->e_flags = in_flags;
elf_flags_init (obfd) = TRUE;
+ /* Also copy the EI_OSABI field. */
+ elf_elfheader (obfd)->e_ident[EI_OSABI] =
+ elf_elfheader (ibfd)->e_ident[EI_OSABI];
+
return TRUE;
}
case R_ARM_JUMP24:
case R_ARM_PREL31:
#endif
+ case R_ARM_THM_PC22:
+ /* Should the interworking branches be here also? */
+
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx >= symtab_hdr->sh_info)
{
struct elf32_arm_relocs_copied *p;
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ eh = (struct elf32_arm_link_hash_entry *) h;
if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
+ {
+ h->plt.refcount -= 1;
+ if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_PC22)
+ eh->plt_thumb_refcount--;
+ }
if (r_type == R_ARM_ABS32
-#ifndef OLD_ARM_ABI
- || r_type == R_ARM_PREL31
-#endif
|| r_type == R_ARM_REL32)
{
- eh = (struct elf32_arm_link_hash_entry *) h;
-
for (pp = &eh->relocs_copied; (p = *pp) != NULL;
pp = &p->next)
if (p->section == sec)
for (rel = relocs; rel < rel_end; rel++)
{
struct elf_link_hash_entry *h;
+ struct elf32_arm_link_hash_entry *eh;
unsigned long r_symndx;
int r_type;
else
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+ eh = (struct elf32_arm_link_hash_entry *) h;
+
switch (r_type)
{
case R_ARM_GOT32:
case R_ARM_JUMP24:
case R_ARM_PREL31:
#endif
+ case R_ARM_THM_PC22:
+ /* Should the interworking branches be listed here? */
if (h != NULL)
{
/* If this reloc is in a read-only section, we might
#ifndef OLD_ARM_ABI
|| r_type == R_ARM_CALL
|| r_type == R_ARM_JUMP24
+ || r_type == R_ARM_PREL31
#endif
- || r_type == R_ARM_PLT32)
+ || r_type == R_ARM_PLT32
+ || r_type == R_ARM_THM_PC22)
h->needs_plt = 1;
/* If we create a PLT entry, this relocation will reference
it, even if it's an ABS32 relocation. */
h->plt.refcount += 1;
+
+ if (r_type == R_ARM_THM_PC22)
+ eh->plt_thumb_refcount += 1;
}
/* If we are creating a shared library, and this is a reloc
&& r_type != R_ARM_JUMP24
&& r_type != R_ARM_PREL31
#endif
- && r_type != R_ARM_REL32)
+ && r_type != R_ARM_REL32
+ && r_type != R_ARM_THM_PC22)
|| (h != NULL
&& (! info->symbolic
|| !h->def_regular))))
}
if (r_type == R_ARM_ABS32
-#ifndef OLD_ARM_ABI
- || r_type == R_ARM_PREL31
-#endif
|| r_type == R_ARM_REL32)
p->count += 1;
}
bfd * dynobj;
asection * s;
unsigned int power_of_two;
+ struct elf32_arm_link_hash_entry * eh;
dynobj = elf_hash_table (info)->dynobj;
&& h->ref_regular
&& !h->def_regular)));
+ eh = (struct elf32_arm_link_hash_entry *) h;
+
/* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later,
when we know the address of the .got section. */
- if (h->type == STT_FUNC
+ if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
|| h->needs_plt)
{
if (h->plt.refcount <= 0
such a case, we don't actually need to build a procedure
linkage table, and we can just do a PC24 reloc instead. */
h->plt.offset = (bfd_vma) -1;
+ eh->plt_thumb_refcount = 0;
h->needs_plt = 0;
}
return TRUE;
}
else
- /* It's possible that we incorrectly decided a .plt reloc was
- needed for an R_ARM_PC24 or similar reloc to a non-function sym
- in check_relocs. We can't decide accurately between function
- and non-function syms in check-relocs; Objects loaded later in
- the link may change h->type. So fix it now. */
- h->plt.offset = (bfd_vma) -1;
+ {
+ /* It's possible that we incorrectly decided a .plt reloc was
+ needed for an R_ARM_PC24 or similar reloc to a non-function sym
+ in check_relocs. We can't decide accurately between function
+ and non-function syms in check-relocs; Objects loaded later in
+ the link may change h->type. So fix it now. */
+ h->plt.offset = (bfd_vma) -1;
+ eh->plt_thumb_refcount = 0;
+ }
/* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the
struct elf32_arm_link_hash_entry *eh;
struct elf32_arm_relocs_copied *p;
+ eh = (struct elf32_arm_link_hash_entry *) h;
+
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
h->plt.offset = s->size;
+ /* If we will insert a Thumb trampoline before this PLT, leave room
+ for it. */
+ if (!htab->symbian_p && eh->plt_thumb_refcount > 0)
+ {
+ h->plt.offset += PLT_THUMB_STUB_SIZE;
+ s->size += PLT_THUMB_STUB_SIZE;
+ }
+
/* If this symbol is not defined in a regular file, and we are
not generating a shared library, then set the symbol to this
location in the .plt. This is required to make function
{
h->root.u.def.section = s;
h->root.u.def.value = h->plt.offset;
+
+ /* Make sure the function is not marked as Thumb, in case
+ it is the target of an ABS32 relocation, which will
+ point to the PLT entry. */
+ if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
+ h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
}
/* Make room for this entry. */
s->size += htab->plt_entry_size;
if (!htab->symbian_p)
- /* We also need to make an entry in the .got.plt section, which
- will be placed in the .got section by the linker script. */
- htab->sgotplt->size += 4;
+ {
+ /* We also need to make an entry in the .got.plt section, which
+ will be placed in the .got section by the linker script. */
+ eh->plt_got_offset = htab->sgotplt->size;
+ htab->sgotplt->size += 4;
+ }
/* We also need to make an entry in the .rel.plt section. */
htab->srelplt->size += sizeof (Elf32_External_Rel);
else
h->got.offset = (bfd_vma) -1;
- eh = (struct elf32_arm_link_hash_entry *) h;
if (eh->relocs_copied == NULL)
return TRUE;
{
bfd * dynobj;
struct elf32_arm_link_hash_table *htab;
+ struct elf32_arm_link_hash_entry *eh;
dynobj = elf_hash_table (info)->dynobj;
htab = elf32_arm_hash_table (info);
+ eh = (struct elf32_arm_link_hash_entry *) h;
if (h->plt.offset != (bfd_vma) -1)
{
srel = bfd_get_section_by_name (dynobj, ".rel.plt");
BFD_ASSERT (splt != NULL && srel != NULL);
- /* Get the index in the procedure linkage table which
- corresponds to this symbol. This is the index of this symbol
- in all the symbols for which we are making plt entries. The
- first entry in the procedure linkage table is reserved. */
- plt_index = ((h->plt.offset - htab->plt_header_size)
- / htab->plt_entry_size);
-
/* Fill in the entry in the procedure linkage table. */
if (htab->symbian_p)
{
+ splt->output_offset
+ h->plt.offset + 4 * (i - 1));
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
+
+ /* Get the index in the procedure linkage table which
+ corresponds to this symbol. This is the index of this symbol
+ in all the symbols for which we are making plt entries. The
+ first entry in the procedure linkage table is reserved. */
+ plt_index = ((h->plt.offset - htab->plt_header_size)
+ / htab->plt_entry_size);
}
else
{
sgot = bfd_get_section_by_name (dynobj, ".got.plt");
BFD_ASSERT (sgot != NULL);
- /* Get the offset into the .got table of the entry that
- corresponds to this function. Each .got entry is 4 bytes.
- The first three are reserved. */
- got_offset = (plt_index + 3) * 4;
+ /* Get the offset into the .got.plt table of the entry that
+ corresponds to this function. */
+ got_offset = eh->plt_got_offset;
+
+ /* Get the index in the procedure linkage table which
+ corresponds to this symbol. This is the index of this symbol
+ in all the symbols for which we are making plt entries. The
+ first three entries in .got.plt are reserved; after that
+ symbols appear in the same order as in .plt. */
+ plt_index = (got_offset - 12) / 4;
/* Calculate the displacement between the PLT slot and the
- entry in the GOT. */
+ entry in the GOT. The eight-byte offset accounts for the
+ value produced by adding to pc in the first instruction
+ of the PLT stub. */
got_displacement = (sgot->output_section->vma
+ sgot->output_offset
+ got_offset
BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
+ if (eh->plt_thumb_refcount > 0)
+ {
+ bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
+ splt->contents + h->plt.offset - 4);
+ bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
+ splt->contents + h->plt.offset - 2);
+ }
+
bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
splt->contents + h->plt.offset + 0);
bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
if (dyn.d_tag == DT_RELSZ
|| dyn.d_tag == DT_RELASZ)
dyn.d_un.d_val += hdr->sh_size;
- else if (dyn.d_un.d_val == 0
- || hdr->sh_offset < dyn.d_un.d_val)
+ else if ((ufile_ptr) hdr->sh_offset
+ <= dyn.d_un.d_val - 1)
dyn.d_un.d_val = hdr->sh_offset;
}
}
i_ehdrp = elf_elfheader (abfd);
- i_ehdrp->e_ident[EI_OSABI] = ARM_ELF_OS_ABI_VERSION;
+ if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
+ i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
+ else
+ i_ehdrp->e_ident[EI_OSABI] = 0;
i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
if (link_info)
return FALSE;
}
+/* Display STT_ARM_TFUNC symbols as functions. */
+
+static void
+elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
+ asymbol *asym)
+{
+ elf_symbol_type *elfsym = (elf_symbol_type *) asym;
+
+ if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
+ elfsym->symbol.flags |= BSF_FUNCTION;
+}
+
+
+/* Mangle thumb function symbols as we read them in. */
+
+static void
+elf32_arm_swap_symbol_in (bfd * abfd,
+ const void *psrc,
+ const void *pshn,
+ Elf_Internal_Sym *dst)
+{
+ bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
+
+ /* New EABI objects mark thumb function symbols by setting the low bit of
+ the address. Turn these into STT_ARM_TFUNC. */
+ if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
+ && (dst->st_value & 1))
+ {
+ dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
+ dst->st_value &= ~(bfd_vma) 1;
+ }
+}
+
+
+/* Mangle thumb function symbols as we write them out. */
+
+static void
+elf32_arm_swap_symbol_out (bfd *abfd,
+ const Elf_Internal_Sym *src,
+ void *cdst,
+ void *shndx)
+{
+ Elf_Internal_Sym newsym;
+
+ /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
+ of the address set, as per the new EABI. We do this unconditionally
+ because objcopy does not set the elf header flags until after
+ it writes out the symbol table. */
+ if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
+ {
+ newsym = *src;
+ newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
+ newsym.st_value |= 1;
+
+ src = &newsym;
+ }
+ bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
+}
+
+/* We use this to override swap_symbol_in and swap_symbol_out. */
+const struct elf_size_info elf32_arm_size_info = {
+ sizeof (Elf32_External_Ehdr),
+ sizeof (Elf32_External_Phdr),
+ sizeof (Elf32_External_Shdr),
+ sizeof (Elf32_External_Rel),
+ sizeof (Elf32_External_Rela),
+ sizeof (Elf32_External_Sym),
+ sizeof (Elf32_External_Dyn),
+ sizeof (Elf_External_Note),
+ 4,
+ 1,
+ 32, 2,
+ ELFCLASS32, EV_CURRENT,
+ bfd_elf32_write_out_phdrs,
+ bfd_elf32_write_shdrs_and_ehdr,
+ bfd_elf32_write_relocs,
+ elf32_arm_swap_symbol_in,
+ elf32_arm_swap_symbol_out,
+ bfd_elf32_slurp_reloc_table,
+ bfd_elf32_slurp_symbol_table,
+ bfd_elf32_swap_dyn_in,
+ bfd_elf32_swap_dyn_out,
+ bfd_elf32_swap_reloc_in,
+ bfd_elf32_swap_reloc_out,
+ bfd_elf32_swap_reloca_in,
+ bfd_elf32_swap_reloca_out
+};
+
#define ELF_ARCH bfd_arch_arm
#define ELF_MACHINE_CODE EM_ARM
#ifdef __QNXTARGET__
#define elf_backend_section_from_shdr elf32_arm_section_from_shdr
#define elf_backend_final_write_processing elf32_arm_final_write_processing
#define elf_backend_copy_indirect_symbol elf32_arm_copy_indirect_symbol
+#define elf_backend_symbol_processing elf32_arm_symbol_processing
+#define elf_backend_size_info elf32_arm_size_info
#define elf_backend_can_refcount 1
#define elf_backend_can_gc_sections 1
#define elf_backend_want_got_plt 0
#include "elf32-target.h"
-