along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+#ifndef USE_REL
+#define USE_REL 0
+#endif
+
typedef unsigned long int insn32;
typedef unsigned short int insn16;
PARAMS ((bfd *, struct bfd_link_info *));
static struct bfd_hash_entry * elf32_arm_link_hash_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-#ifdef USE_REL
+#if USE_REL
static void arm_add_to_rel
PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
#endif
boolean bfd_elf32_arm_process_before_allocation
PARAMS ((bfd *, struct bfd_link_info *, int));
#endif
-static boolean elf32_arm_create_dynamic_sections
- PARAMS ((bfd *, struct bfd_link_info *));
#define INTERWORK_FLAG(abfd) (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
/* The size in bytes of an entry in the procedure linkage table. */
-#define ARM_PLT_ENTRY_SIZE 16
-#define THUMB_PLT_ENTRY_SIZE 20
-#define PLT_ENTRY_SIZE(ARM) \
- ((ARM) ? ARM_PLT_ENTRY_SIZE : THUMB_PLT_ENTRY_SIZE)
+#define PLT_ENTRY_SIZE 16
/* The first entry in a procedure linkage table looks like
this. It is set up so that any shared library function that is
called before the relocation has been set up calls the dynamic
linker first. */
-static const bfd_vma elf32_arm_plt0_entry [ARM_PLT_ENTRY_SIZE / 4] =
+static const bfd_vma elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
{
0xe52de004, /* str lr, [sp, #-4]! */
0xe59fe010, /* ldr lr, [pc, #16] */
0xe5bef008 /* ldr pc, [lr, #8]! */
};
-static const insn16 elf32_thumb_plt0_entry [THUMB_PLT_ENTRY_SIZE / 2] =
- {
- 0xb500, /* push {lr} */
- 0xb082, /* sub sp, #8 */
- 0x9000, /* str r0, [sp] */
- 0x4807, /* ldr r0, [pc, #28] */
- 0x300c, /* add r0, #12 */
- 0x4478, /* add r0, pc */
- 0x4686, /* mov lr, r0 */
- 0x6800, /* ldr r0, [r0] */
- 0x9001, /* str r0, [sp, #4] */
- 0xbd01 /* pop {r0, pc} */
- };
-
/* Subsequent entries in a procedure linkage table look like
this. */
-static const bfd_vma elf32_arm_plt_entry [ARM_PLT_ENTRY_SIZE / 4] =
+static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
{
0xe59fc004, /* ldr ip, [pc, #4] */
0xe08fc00c, /* add ip, pc, ip */
0xe59cf000, /* ldr pc, [ip] */
0x00000000 /* offset to symbol in got */
};
-
-/* Note that on ARMv5 and above unlike the ARM PLT entries, the Thumb
- entry can switch mode depending on the corresponding address in the
- GOT. The dynamic linker should set or clear the last bit of the
- address in the GOT accordingly. */
-
-static const insn16 elf32_thumb_plt_entry [THUMB_PLT_ENTRY_SIZE / 2] =
- {
- 0xb082, /* sub sp, #8 */
- 0x9000, /* str r0, [sp] */
- 0x4802, /* ldr r0, [pc, #8] */
- 0x4478, /* add r0, pc */
- 0x4684, /* mov ip, r0 */
- 0x6800, /* ldr r0, [r0] */
- 0x9001, /* str r0, [sp, #4] */
- 0xbd01, /* pop {r0, pc} */
- 0x0000, /* offset to symbol in got */
- 0x0000
- };
/* The ARM linker needs to keep track of the number of relocs that it
decides to copy in check_relocs for each symbol. This is so that
bfd_size_type count;
};
-
-/* We can generate Thumb or ARM PLT entries. This structure holds
- additional information for symbols that have corresponding PLT
- entries. */
-
-struct elf32_arm_plt_entry_info
- {
- /* The first relocation type referring to this PLT entry. Used to
- determine the type of the entry if the symbol is undefined. */
- long first_rel_type;
-
- /* True if we decided to emit the ARM version of the PLT entry for
- this symbol. Otherwise the entry is Thumb. */
- boolean arm_plt;
-
- /* The offset of the corresponding .got.plt entry. */
- bfd_vma got_plt_offset;
- };
-
/* Arm ELF linker hash entry. */
struct elf32_arm_link_hash_entry
{
/* Number of PC relative relocs copied for this symbol. */
struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
-
- struct elf32_arm_plt_entry_info plt_info;
};
/* Declare this now that the above structures are defined. */
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
table, string));
if (ret != (struct elf32_arm_link_hash_entry *) NULL)
- {
- ret->pcrel_relocs_copied = NULL;
- ret->plt_info.first_rel_type = R_ARM_NONE;
- }
+ ret->pcrel_relocs_copied = NULL;
return (struct bfd_hash_entry *) ret;
}
static const insn16 t2a2_noop_insn = 0x46c0;
static const insn32 t2a3_b_insn = 0xea000000;
-static const insn16 t2a1_push_insn = 0xb540;
-static const insn16 t2a2_ldr_insn = 0x4e03;
-static const insn16 t2a3_mov_insn = 0x46fe;
-static const insn16 t2a4_bx_insn = 0x4730;
-static const insn32 t2a5_pop_insn = 0xe8bd4040;
-static const insn32 t2a6_bx_insn = 0xe12fff1e;
-
#ifndef ELFARM_NABI_C_INCLUDED
boolean
bfd_elf32_arm_allocate_interworking_sections (info)
asection * s;
char * tmp_name;
struct elf_link_hash_entry * myh;
+ struct bfd_link_hash_entry * bh;
struct elf32_arm_link_hash_table * globals;
bfd_vma val;
/* The only trick here is using hash_table->arm_glue_size as the value. Even
though the section isn't allocated yet, this is where we will be putting
it. */
+ bh = NULL;
val = globals->arm_glue_size + 1;
_bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
tmp_name, BSF_GLOBAL, s, val,
- NULL, true, false,
- (struct bfd_link_hash_entry **) &myh);
+ NULL, true, false, &bh);
free (tmp_name);
asection *s;
char *tmp_name;
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;
return;
}
+ bh = NULL;
val = hash_table->thumb_glue_size + 1;
_bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
tmp_name, BSF_GLOBAL, s, val,
- NULL, true, false,
- (struct bfd_link_hash_entry **) &myh);
+ NULL, true, false, &bh);
/* 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);
sprintf (tmp_name, CHANGE_TO_ARM, name);
- myh = NULL;
-
+ bh = NULL;
val = hash_table->thumb_glue_size + 4,
_bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
tmp_name, BSF_LOCAL, s, val,
- NULL, true, false,
- (struct bfd_link_hash_entry **) &myh);
+ NULL, true, false, &bh);
free (tmp_name);
bfd_vma * local_got_offsets;
asection * sgot = NULL;
asection * splt = NULL;
- asection * splt_thumb = NULL;
asection * sreloc = NULL;
bfd_vma addend;
bfd_signed_vma signed_addend;
{
sgot = bfd_get_section_by_name (dynobj, ".got");
splt = bfd_get_section_by_name (dynobj, ".plt");
- splt_thumb = bfd_get_section_by_name (dynobj, ".plt.thumb");
}
symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (input_bfd);
local_got_offsets = elf_local_got_offsets (input_bfd);
r_symndx = ELF32_R_SYM (rel->r_info);
-#ifdef USE_REL
+#if USE_REL
addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
if (addend & ((howto->src_mask + 1) >> 1))
case R_ARM_THM_ABS5:
/* Support ldr and str instructions for the thumb. */
-#ifdef USE_REL
+#if USE_REL
/* Need to refetch addend. */
addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
/* ??? Need to determine shift amount from operand size. */
bfd_vma check;
bfd_signed_vma signed_check;
-#ifdef USE_REL
+#if USE_REL
/* Need to refetch the addend and squish the two 11 bit pieces
together. */
{
signed_addend = addend;
}
#endif
-
- /* If value is zero then we are linking a shared object and
- this is a reference to an externally visible symbol. */
- if (h != NULL && h->plt.offset != (bfd_vma) -1 && value == 0)
- value = (splt_thumb->output_section->vma
- + splt_thumb->output_offset
- + h->plt.offset);
-
#ifndef OLD_ARM_ABI
if (r_type == R_ARM_THM_XPC22)
{
case R_ARM_THM_PC11:
/* Thumb B (branch) instruction). */
{
- bfd_vma relocation;
+ bfd_signed_vma relocation;
bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
- bfd_vma check;
bfd_signed_vma signed_check;
-#ifdef USE_REL
+#if USE_REL
/* Need to refetch addend. */
addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
- /* ??? Need to determine shift amount from operand size. */
- addend >>= howto->rightshift;
+ if (addend & ((howto->src_mask + 1) >> 1))
+ {
+ signed_addend = -1;
+ signed_addend &= ~ howto->src_mask;
+ signed_addend |= addend;
+ }
+ else
+ signed_addend = addend;
+ /* The value in the insn has been right shifted. We need to
+ undo this, so that we can perform the address calculation
+ in terms of bytes. */
+ signed_addend <<= howto->rightshift;
#endif
- relocation = value + addend;
+ relocation = value + signed_addend;
relocation -= (input_section->output_section->vma
+ input_section->output_offset
+ rel->r_offset);
- check = relocation >> howto->rightshift;
-
- /* If this is a signed value, the rightshift just
- dropped leading 1 bits (assuming twos complement). */
- if ((bfd_signed_vma) relocation >= 0)
- signed_check = check;
- else
- signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
-
+ relocation >>= howto->rightshift;
+ signed_check = relocation;
+ relocation &= howto->dst_mask;
relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
bfd_put_16 (input_bfd, relocation, hit_data);
}
}
-#ifdef USE_REL
+#if USE_REL
/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. */
static void
arm_add_to_rel (abfd, address, howto, increment)
Elf_Internal_Rela * relend;
const char * name;
-#ifndef USE_REL
+#if !USE_REL
if (info->relocateable)
return true;
#endif
|| r_type == R_ARM_GNU_VTINHERIT)
continue;
-#ifdef USE_REL
+#if USE_REL
elf32_arm_info_to_howto (input_bfd, & bfd_reloc,
(Elf_Internal_Rel *) rel);
#else
#endif
howto = bfd_reloc.howto;
-#ifdef USE_REL
+#if USE_REL
if (info->relocateable)
{
/* This is a relocateable link. We don't have to change
{
sym = local_syms + r_symndx;
sec = local_sections[r_symndx];
-#ifdef USE_REL
+#if USE_REL
relocation = (sec->output_section->vma
+ sec->output_offset
+ sym->st_value);
continue;
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
- {
- struct elf32_arm_link_hash_entry *eh;
-
- eh = (struct elf32_arm_link_hash_entry *) h;
- if (eh->plt_info.first_rel_type == R_ARM_NONE)
- eh->plt_info.first_rel_type = R_ARM_PLT32;
- }
- break;
-
- case R_ARM_THM_PC22:
- /* Since there is no PLT32 for Thumb if we are creating a
- shared library and this is an externally visible symbol
- then add it to the PLT. */
- if (info->shared && h != NULL && h->dynindx != -1
- && (! info->symbolic
- || (h->elf_link_hash_flags
- & ELF_LINK_HASH_DEF_REGULAR) == 0))
- {
- struct elf32_arm_link_hash_entry *eh;
-
- eh = (struct elf32_arm_link_hash_entry *) h;
- h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
- if (eh->plt_info.first_rel_type == R_ARM_NONE)
- eh->plt_info.first_rel_type = R_ARM_THM_PC22;
- }
break;
case R_ARM_ABS32:
/* 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 || h->type == STT_ARM_TFUNC
+ if (h->type == STT_FUNC
|| (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
{
- struct elf32_arm_plt_entry_info *plt_info;
-
- plt_info = &((struct elf32_arm_link_hash_entry *) h)->plt_info;
- plt_info->arm_plt = ! (h->type == STT_ARM_TFUNC ||
- (h->type != STT_ARM_TFUNC && h->type != STT_FUNC
- && plt_info->first_rel_type == R_ARM_THM_PC22));
-
+ /* If we link a program (not a DSO), we'll get rid of unnecessary
+ PLT entries; we point to the actual symbols -- even for pic
+ relocs, because a program built with -fpic should have the same
+ result as one built without -fpic, specifically considering weak
+ symbols.
+ FIXME: m68k and i386 differ here, for unclear reasons. */
if (! info->shared
- && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
- && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
+ && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0)
{
/* This case can occur if we saw a PLT32 reloc in an input
- file, but the symbol was never referred to by a dynamic
- object. In such a case, we don't actually need to build
- a procedure linkage table, and we can just do a PC32
- reloc instead. */
+ file, but the symbol was not defined by a dynamic object.
+ In such a case, we don't actually need to build a
+ procedure linkage table, and we can just do a PC32 reloc
+ instead. */
BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
+ h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
return true;
}
return false;
}
- s = bfd_get_section_by_name (dynobj,
- plt_info->arm_plt ? ".plt" : ".plt.thumb");
+ s = bfd_get_section_by_name (dynobj, ".plt");
BFD_ASSERT (s != NULL);
- /* If this is the first PLT entry, make room for the special
+ /* If this is the first .plt entry, make room for the special
first entry. */
if (s->_raw_size == 0)
- s->_raw_size += PLT_ENTRY_SIZE (plt_info->arm_plt);
+ s->_raw_size += PLT_ENTRY_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
h->plt.offset = s->_raw_size;
/* Make room for this entry. */
- s->_raw_size += PLT_ENTRY_SIZE (plt_info->arm_plt);
+ s->_raw_size += PLT_ENTRY_SIZE;
/* We also need to make an entry in the .got.plt section, which
will be placed in the .got section by the linker script. */
s = bfd_get_section_by_name (dynobj, ".got.plt");
BFD_ASSERT (s != NULL);
- plt_info->got_plt_offset = s->_raw_size;
s->_raw_size += 4;
/* We also need to make an entry in the .rel.plt section. */
strip = false;
- /* Match .plt.thumb as well. */
- if (strncmp (name, ".plt", 4) == 0)
+ if (strcmp (name, ".plt") == 0)
{
if (s->_raw_size == 0)
{
if (strip)
{
- asection ** spp;
-
- for (spp = &s->output_section->owner->sections;
- *spp != NULL;
- spp = &(*spp)->next)
- {
- if (*spp == s->output_section)
- {
- bfd_section_list_remove (s->output_section->owner, spp);
- --s->output_section->owner->section_count;
- break;
- }
- }
+ _bfd_strip_section_from_output (info, s);
continue;
}
if (h->plt.offset != (bfd_vma) -1)
{
asection * splt;
- asection * splt_thumb;
asection * sgot;
asection * srel;
- bfd_vma rel_index;
+ bfd_vma plt_index;
+ bfd_vma got_offset;
Elf_Internal_Rel rel;
- struct elf32_arm_plt_entry_info *plt_info;
/* This symbol has an entry in the procedure linkage table. Set
it up. */
BFD_ASSERT (h->dynindx != -1);
splt = bfd_get_section_by_name (dynobj, ".plt");
- splt_thumb = bfd_get_section_by_name (dynobj, ".plt.thumb");
sgot = bfd_get_section_by_name (dynobj, ".got.plt");
srel = bfd_get_section_by_name (dynobj, ".rel.plt");
- BFD_ASSERT (splt != NULL && splt_thumb != NULL && sgot != NULL
- && srel != NULL);
+ BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
- plt_info = &((struct elf32_arm_link_hash_entry *) h)->plt_info;
+ /* 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 / PLT_ENTRY_SIZE - 1;
- /* Get the index in the relocation table that corresponds to the
- entry in the global offset table. */
- rel_index = plt_info->got_plt_offset / 4 - 3;
+ /* 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;
/* Fill in the entry in the procedure linkage table. */
-
- if (plt_info->arm_plt)
- {
- bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
- splt->contents + h->plt.offset + 0);
- bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
- splt->contents + h->plt.offset + 4);
- bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
- splt->contents + h->plt.offset + 8);
-
- bfd_put_32 (output_bfd,
+ bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
+ splt->contents + h->plt.offset + 0);
+ bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
+ splt->contents + h->plt.offset + 4);
+ bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
+ splt->contents + h->plt.offset + 8);
+ bfd_put_32 (output_bfd,
(sgot->output_section->vma
+ sgot->output_offset
- + plt_info->got_plt_offset
+ + got_offset
- splt->output_section->vma
- splt->output_offset
- h->plt.offset - 12),
splt->contents + h->plt.offset + 12);
- /* Fill in the entry in the global offset table. */
- bfd_put_32 (output_bfd,
- (splt->output_section->vma
- + splt->output_offset),
- sgot->contents + plt_info->got_plt_offset);
- }
- else
- {
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[0],
- splt_thumb->contents + h->plt.offset + 0);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[1],
- splt_thumb->contents + h->plt.offset + 2);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[2],
- splt_thumb->contents + h->plt.offset + 4);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[3],
- splt_thumb->contents + h->plt.offset + 6);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[4],
- splt_thumb->contents + h->plt.offset + 8);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[5],
- splt_thumb->contents + h->plt.offset + 10);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[6],
- splt_thumb->contents + h->plt.offset + 12);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt_entry[7],
- splt_thumb->contents + h->plt.offset + 14);
-
- bfd_put_32 (output_bfd,
- (sgot->output_section->vma
- + sgot->output_offset
- + plt_info->got_plt_offset
- - splt_thumb->output_section->vma
- - splt_thumb->output_offset
- - h->plt.offset - 10),
- splt_thumb->contents + h->plt.offset + 16);
-
- /* Fill in the entry in the global offset table and set
- bottom bit as plt[0] is a Thumb function. */
- bfd_put_32 (output_bfd,
- (splt_thumb->output_section->vma
- + (splt_thumb->output_offset | 1)),
- sgot->contents + plt_info->got_plt_offset);
- }
+ /* Fill in the entry in the global offset table. */
+ bfd_put_32 (output_bfd,
+ (splt->output_section->vma
+ + splt->output_offset),
+ sgot->contents + got_offset);
/* Fill in the entry in the .rel.plt section. */
rel.r_offset = (sgot->output_section->vma
+ sgot->output_offset
- + plt_info->got_plt_offset);
+ + got_offset);
rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
bfd_elf32_swap_reloc_out (output_bfd, &rel,
((Elf32_External_Rel *) srel->contents
- + rel_index));
+ + plt_index));
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
{
if (elf_hash_table (info)->dynamic_sections_created)
{
asection *splt;
- asection *splt_thumb;
Elf32_External_Dyn *dyncon, *dynconend;
splt = bfd_get_section_by_name (dynobj, ".plt");
- splt_thumb = bfd_get_section_by_name (dynobj, ".plt.thumb");
- BFD_ASSERT (splt != NULL && splt_thumb != NULL && sdyn != NULL);
+ BFD_ASSERT (splt != NULL && sdyn != NULL);
dyncon = (Elf32_External_Dyn *) sdyn->contents;
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
}
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
break;
+
+ /* Set the bottom bit of DT_INIT/FINI if the
+ corresponding function is Thumb. */
+ case DT_INIT:
+ name = info->init_function;
+ goto get_sym;
+ case DT_FINI:
+ name = info->fini_function;
+ get_sym:
+ /* If it wasn't set by elf_bfd_final_link
+ then there is nothing to ajdust. */
+ if (dyn.d_un.d_val != 0)
+ {
+ struct elf_link_hash_entry * eh;
+
+ eh = elf_link_hash_lookup (elf_hash_table (info), name,
+ false, false, true);
+ if (eh != (struct elf_link_hash_entry *) NULL
+ && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
+ {
+ dyn.d_un.d_val |= 1;
+ bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
+ }
+ }
+ break;
}
}
- /* Fill in the first entries in the procedure linkage tables. */
+ /* Fill in the first entry in the procedure linkage table. */
if (splt->_raw_size > 0)
{
bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents + 0);
bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents + 8);
bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
}
- if (splt_thumb->_raw_size > 0)
- {
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[0],
- splt_thumb->contents + 0);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[1],
- splt_thumb->contents + 2);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[2],
- splt_thumb->contents + 4);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[3],
- splt_thumb->contents + 6);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[4],
- splt_thumb->contents + 8);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[5],
- splt_thumb->contents + 10);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[6],
- splt_thumb->contents + 12);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[7],
- splt_thumb->contents + 14);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[8],
- splt_thumb->contents + 16);
- bfd_put_16 (output_bfd, (bfd_vma) elf32_thumb_plt0_entry[9],
- splt_thumb->contents + 18);
- }
/* UnixWare sets the entsize of .plt to 4, although that doesn't
really seem like the right value. */
}
}
-boolean
-elf32_arm_create_dynamic_sections (abfd, info)
- bfd *abfd;
- struct bfd_link_info *info;
-{
- boolean ret;
-
- ret = _bfd_elf_create_dynamic_sections (abfd, info);
- if (ret)
- {
- asection *splt;
- asection *splt_thumb;
- flagword flags;
- unsigned int alignent_power;
-
- /* Let's match the attributes of .plt. */
- splt = bfd_get_section_by_name (abfd, ".plt");
- BFD_ASSERT (splt != NULL);
-
- flags = bfd_get_section_flags (abfd, splt);
- alignent_power = bfd_get_section_alignment (abfd, splt);
-
- splt_thumb = bfd_make_section (abfd, ".plt.thumb");
- if (splt_thumb == NULL
- || !bfd_set_section_flags (abfd, splt_thumb, flags)
- || !bfd_set_section_alignment (abfd, splt_thumb, alignent_power))
- return false;
- }
- return ret;
-}
#define ELF_ARCH bfd_arch_arm
#define ELF_MACHINE_CODE EM_ARM
-#ifndef ELF_MAXPAGESIZE
#define ELF_MAXPAGESIZE 0x8000
-#endif
#define bfd_elf32_bfd_copy_private_bfd_data elf32_arm_copy_private_bfd_data
#define bfd_elf32_bfd_merge_private_bfd_data elf32_arm_merge_private_bfd_data
#define elf_backend_check_relocs elf32_arm_check_relocs
#define elf_backend_relocate_section elf32_arm_relocate_section
#define elf_backend_adjust_dynamic_symbol elf32_arm_adjust_dynamic_symbol
-#define elf_backend_create_dynamic_sections elf32_arm_create_dynamic_sections
+#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
#define elf_backend_finish_dynamic_symbol elf32_arm_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections elf32_arm_finish_dynamic_sections
#define elf_backend_size_dynamic_sections elf32_arm_size_dynamic_sections
#define elf_backend_plt_readonly 1
#define elf_backend_want_got_plt 1
#define elf_backend_want_plt_sym 0
-#ifndef USE_REL
+#if !USE_REL
#define elf_backend_rela_normal 1
#endif
#define elf_backend_got_header_size 12
-#define elf_backend_plt_header_size ARM_PLT_ENTRY_SIZE
+#define elf_backend_plt_header_size PLT_ENTRY_SIZE
#include "elf32-target.h"
projects / deliverable / binutils-gdb.git / blobdiff