/* M32R-specific support for 32-bit ELF.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
static bfd_boolean m32r_elf_finish_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *));
-
+
static bfd_boolean m32r_elf_finish_dynamic_symbol
PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
Elf_Internal_Sym *));
-
+
static bfd_boolean allocate_dynrelocs
PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean readonly_dynrelocs
/* Use RELA. But use REL to link old objects for backwords compatibility. */
/* Functions for the M32R ELF linker. */
-
+
/* The name of the dynamic interpreter. This is put in the .interp
section. */
-
+
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
-
+
/* The nop opcode we use. */
-
+
#define M32R_NOP 0x7000f000
-
+
#define PLT_EMPTY 0x10101010 /* RIE -> RIE */
-
+
/* The size in bytes of an entry in the procedure linkage table. */
#define PLT_ENTRY_SIZE 20
#define PLT_HEADER_SIZE 20
-
+
/* The first one entries in a procedure linkage table are reserved,
and the initial contents are unimportant (we zero them out).
Subsequent entries look like this. */
-
+
#define PLT0_ENTRY_WORD0 0xd6c00000 /* seth r6, #high(.got+4) */
#define PLT0_ENTRY_WORD1 0x86e60000 /* or3 r6, r6, #low(.got)+4) */
#define PLT0_ENTRY_WORD2 0x24e626c6 /* ld r4, @r6+ -> ld r6, @r6 */
#define PLT0_ENTRY_WORD3 0x1fc6f000 /* jmp r6 || pnop */
#define PLT0_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
-
+
#define PLT0_PIC_ENTRY_WORD0 0xa4cc0004 /* ld r4, @(4,r12) */
#define PLT0_PIC_ENTRY_WORD1 0xa6cc0008 /* ld r6, @(8,r12) */
#define PLT0_PIC_ENTRY_WORD2 0x1fc6f000 /* jmp r6 || nop */
#define PLT0_PIC_ENTRY_WORD3 PLT_EMPTY /* RIE -> RIE */
#define PLT0_PIC_ENTRY_WORD4 PLT_EMPTY /* RIE -> RIE */
-
+
#define PLT_ENTRY_WORD0 0xe6000000 /* ld24 r6, .name_in_GOT */
#define PLT_ENTRY_WORD1 0x06acf000 /* add r6, r12 || nop */
#define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT) */
{ BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
{ BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
{ BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
-
+
{ BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
{ BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
{ BFD_RELOC_M32R_COPY, R_M32R_COPY },
{
struct elf_m32r_link_hash_entry *ret =
(struct elf_m32r_link_hash_entry *) entry;
-
+
/* Allocate the structure if it has not already been allocated by a
subclass. */
if (ret == (struct elf_m32r_link_hash_entry *) NULL)
sizeof (struct elf_m32r_link_hash_entry)));
if (ret == (struct elf_m32r_link_hash_entry *) NULL)
return (struct bfd_hash_entry *) ret;
-
+
/* Call the allocation method of the superclass. */
ret = ((struct elf_m32r_link_hash_entry *)
_bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
if (ret != (struct elf_m32r_link_hash_entry *) NULL)
{
struct elf_m32r_link_hash_entry *eh;
-
+
eh = (struct elf_m32r_link_hash_entry *) ret;
eh->dyn_relocs = NULL;
// eh->gotplt_refcount = 0;
/* eh->pcrel_relocs_copied = NULL; FIXME */
}
-
+
return (struct bfd_hash_entry *) ret;
}
{
struct elf_m32r_link_hash_table *ret;
bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
-
+
ret = (struct elf_m32r_link_hash_table *) bfd_malloc (amt);
if (ret == (struct elf_m32r_link_hash_table *) NULL)
return NULL;
-
+
if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
m32r_elf_link_hash_newfunc))
{
free (ret);
return NULL;
}
-
+
ret->sgot = NULL;
ret->sgotplt = NULL;
ret->srelgot = NULL;
ret->sdynbss = NULL;
ret->srelbss = NULL;
ret->sym_sec.abfd = NULL;
-
+
return &ret->root.root;
}
{
/* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
.plt section. */
- struct elf_link_hash_entry *h = NULL;
+ struct bfd_link_hash_entry *bh = NULL;
+ struct elf_link_hash_entry *h;
if (! (_bfd_generic_link_add_one_symbol
(info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
(bfd_vma) 0, (const char *) NULL, FALSE,
- get_elf_backend_data (abfd)->collect,
- (struct bfd_link_hash_entry **) &h)))
+ get_elf_backend_data (abfd)->collect, &bh)))
return FALSE;
+ h = (struct elf_link_hash_entry *) bh;
h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
h->type = STT_OBJECT;
static void m32r_elf_copy_indirect_symbol (const struct elf_backend_data *,
struct elf_link_hash_entry *,
struct elf_link_hash_entry *);
-
+
static void
m32r_elf_copy_indirect_symbol (const struct elf_backend_data *bed,
struct elf_link_hash_entry *dir,
struct elf_link_hash_entry *ind)
{
struct elf_m32r_link_hash_entry *edir, *eind;
-
+
edir = (struct elf_m32r_link_hash_entry *) dir;
eind = (struct elf_m32r_link_hash_entry *) ind;
-
+
if (eind->dyn_relocs != NULL)
{
if (edir->dyn_relocs != NULL)
{
struct elf_m32r_dyn_relocs **pp;
struct elf_m32r_dyn_relocs *p;
-
+
if (ind->root.type == bfd_link_hash_indirect)
abort ();
-
+
/* Add reloc counts against the weak sym to the strong sym
list. Merge any entries against the same section. */
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
{
struct elf_m32r_dyn_relocs *q;
-
+
for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec)
{
}
*pp = edir->dyn_relocs;
}
-
+
edir->dyn_relocs = eind->dyn_relocs;
eind->dyn_relocs = NULL;
}
-
+
// if (ind->root.type == bfd_link_hash_indirect
// && dir->got.refcount <= 0)
// {
dynamic object, but we're not including those sections. We have to
change the definition to something the rest of the link can
understand. */
-
+
static bfd_boolean
m32r_elf_adjust_dynamic_symbol (info, h)
struct bfd_link_info *info;
#ifdef DEBUG_PIC
printf("m32r_elf_adjust_dynamic_symbol()\n");
#endif
-
+
dynobj = elf_hash_table (info)->dynobj;
-
+
/* Make sure we know what is going on here. */
BFD_ASSERT (dynobj != NULL
&& ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
&& (h->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0)));
-
+
/* 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. */
}
else
h->plt.offset = (bfd_vma) -1;
-
+
/* 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. */
h->root.u.def.value = h->weakdef->root.u.def.value;
return TRUE;
}
-
+
/* This is a reference to a symbol defined by a dynamic object which
is not a function. */
-
+
/* If we are creating a shared library, we must presume that the
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
if (info->shared)
return TRUE;
-
+
/* If there are no references to this symbol that do not use the
GOT, we don't need to generate a copy reloc. */
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
determine the address it must put in the global offset table, so
both the dynamic object and the regular object will refer to the
same memory location for the variable. */
-
+
htab = m32r_elf_hash_table (info);
s = htab->sdynbss;
BFD_ASSERT (s != NULL);
-
+
/* We must generate a R_M32R_COPY reloc to tell the dynamic linker
to copy the initial value out of the dynamic object and into the
runtime process image. We need to remember the offset into the
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
{
asection *srel;
-
+
srel = htab->srelbss;
BFD_ASSERT (srel != NULL);
srel->_raw_size += sizeof (Elf32_External_Rela);
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
}
-
+
/* We need to figure out the alignment required for this symbol. I
have no idea how ELF linkers handle this. */
power_of_two = bfd_log2 (h->size);
if (power_of_two > 3)
power_of_two = 3;
-
+
/* Apply the required alignment. */
s->_raw_size = BFD_ALIGN (s->_raw_size,
(bfd_size_type) (1 << power_of_two));
if (! bfd_set_section_alignment (dynobj, s, power_of_two))
return FALSE;
}
-
+
/* Define the symbol as being at this point in the section. */
h->root.u.def.section = s;
h->root.u.def.value = s->_raw_size;
-
+
/* Increment the section size to make room for the symbol. */
s->_raw_size += h->size;
-
+
return TRUE;
}
/* Allocate space in .plt, .got and associated reloc sections for
dynamic relocs. */
-
+
static bfd_boolean
allocate_dynrelocs (h, inf)
struct elf_link_hash_entry *h;
struct elf_m32r_link_hash_table *htab;
struct elf_m32r_link_hash_entry *eh;
struct elf_m32r_dyn_relocs *p;
-
+
if (h->root.type == bfd_link_hash_indirect)
return TRUE;
-
+
if (h->root.type == bfd_link_hash_warning)
/* When warning symbols are created, they **replace** the "real"
entry in the hash table, thus we never get to see the real
symbol in a hash traversal. So look at it now. */
h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
+
info = (struct bfd_link_info *) inf;
htab = m32r_elf_hash_table (info);
-
+
eh = (struct elf_m32r_link_hash_entry *) h;
// if ((h->got.refcount > 0
// || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
// if (h->plt.refcount >= eh->gotplt_refcount)
// h->plt.refcount -= eh->gotplt_refcount;
// }
-
+
if (htab->root.dynamic_sections_created
&& h->plt.refcount > 0)
{
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
-
+
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
{
asection *s = htab->splt;
-
+
/* 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;
-
+
h->plt.offset = s->_raw_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 room for this entry. */
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. */
htab->sgotplt->_raw_size += 4;
-
+
/* We also need to make an entry in the .rel.plt section. */
htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
}
h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
}
-
+
if (h->got.refcount > 0)
{
asection *s;
bfd_boolean dyn;
-
+
/* Make sure this symbol is output as a dynamic symbol.
Undefined weak syms won't yet be marked as dynamic. */
if (h->dynindx == -1
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
-
+
s = htab->sgot;
h->got.offset = s->_raw_size;
}
else
h->got.offset = (bfd_vma) -1;
-
+
if (eh->dyn_relocs == NULL)
return TRUE;
-
+
/* In the shared -Bsymbolic case, discard space allocated for
dynamic pc-relative relocs against symbols which turn out to be
defined in regular objects. For the normal shared case, discard
/* For the non-shared case, discard space for relocs against
symbols which turn out to need copy relocs or are not
dynamic. */
-
+
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
&& (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
-
+
/* If that succeeded, we know we'll be keeping all the
relocs. */
if (h->dynindx != -1)
goto keep;
}
-
+
eh->dyn_relocs = NULL;
-
+
keep: ;
}
-
+
/* Finally, allocate space. */
for (p = eh->dyn_relocs; p != NULL; p = p->next)
{
asection *sreloc = elf_section_data (p->sec)->sreloc;
sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
}
-
+
return TRUE;
}
/* Find any dynamic relocs that apply to read-only sections. */
-
+
static bfd_boolean
readonly_dynrelocs (h, inf)
struct elf_link_hash_entry *h;
}
/* Set the sizes of the dynamic sections. */
-
+
static bfd_boolean
m32r_elf_size_dynamic_sections (output_bfd, info)
bfd *output_bfd ATTRIBUTE_UNUSED;
dynobj = htab->root.dynobj;
local_got_offsets = elf_local_got_offsets (input_bfd);
-
+
sgot = htab->sgot;
splt = htab->splt;
sreloc = NULL;
section symbol winds up in the output section. */
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
rel->r_addend += sec->output_offset + sym->st_value;
-
+
continue;
}
}
|| r_type == R_M32R_26_PCREL_RELA)
&& ((input_section->flags & SEC_ALLOC) != 0
/* DWARF will emit R_M32R_16(24,32) relocations
- in its sections against symbols defined
+ in its sections against symbols defined
externally in shared libraries. We can't do
anything with them here. */
|| ((input_section->flags & SEC_DEBUGGING) != 0
if (! ((*info->callbacks->undefined_symbol)
(info, h->root.root.string, input_bfd,
input_section, offset,
- (!info->shared
+ (!info->shared
|| ELF_ST_VISIBILITY (h->other)))))
return FALSE;
relocation = 0;
case R_M32R_GOTPC_HI_ULO:
case R_M32R_GOTPC_HI_SLO:
- case R_M32R_GOTPC_LO:
+ case R_M32R_GOTPC_LO:
{
/* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
bl .+4
relocation -= (input_section->output_section->vma
+ input_section->output_offset
+ rel->r_offset);
- if ((r_type == R_M32R_GOTPC_HI_SLO)
+ if ((r_type == R_M32R_GOTPC_HI_SLO)
&& ((relocation + rel->r_addend) & 0x8000))
rel->r_addend += 0x10000;
}
case R_M32R_GOT16_HI_ULO:
case R_M32R_GOT16_HI_SLO:
- case R_M32R_GOT16_LO:
+ case R_M32R_GOT16_LO:
/* Fall through. */
case R_M32R_GOT24:
/* Relocation is to the entry for this symbol in the global
offset table. */
BFD_ASSERT (sgot != NULL);
-
+
if (h != NULL)
{
bfd_boolean dyn;
bfd_vma off;
-
+
off = h->got.offset;
BFD_ASSERT (off != (bfd_vma) -1);
offset must always be a multiple of 4, we use the
least significant bit to record whether we have
initialized it already.
-
+
When doing a dynamic link, we create a .rela.got
relocation entry to initialize the value. This
is done in the finish_dynamic_symbol routine. */
h->got.offset |= 1;
}
}
-
+
relocation = sgot->output_offset + off;
}
else
{
bfd_vma off;
bfd_byte *loc;
-
+
BFD_ASSERT (local_got_offsets != NULL
&& local_got_offsets[r_symndx] != (bfd_vma) -1);
-
+
off = local_got_offsets[r_symndx];
-
+
/* The offset must always be a multiple of 4. We use
the least significant bit to record whether we have
already processed this entry. */
else
{
bfd_put_32 (output_bfd, relocation, sgot->contents + off);
-
+
if (info->shared)
{
asection *srelgot;
Elf_Internal_Rela outrel;
-
+
/* We need to generate a R_M32R_RELATIVE reloc
for the dynamic linker. */
srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
BFD_ASSERT (srelgot != NULL);
-
+
outrel.r_offset = (sgot->output_section->vma
+ sgot->output_offset
+ off);
bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
++srelgot->reloc_count;
}
-
+
local_got_offsets[r_symndx] |= 1;
}
-
+
relocation = sgot->output_offset + off;
}
if ((r_type == R_M32R_GOT16_HI_SLO)
rel->r_addend += 0x10000;
break;
-
+
case R_M32R_26_PLTREL:
/* Relocation is to the entry for this symbol in the
procedure linkage table. */
-
+
/* The native assembler will generate a 26_PLTREL reloc
for a local symbol if you assemble a call from one
section to another when using -K pic. */
using -Bsymbolic. */
break;
}
-
+
relocation = (splt->output_section->vma
+ splt->output_offset
+ h->plt.offset);
break;
-
+
case R_M32R_HI16_SLO_RELA:
{
if ((relocation + rel->r_addend) & 0x8000)
Elf_Internal_Rela outrel;
bfd_boolean skip, relocate;
bfd_byte *loc;
-
+
/* When generating a shared object, these relocations
are copied into the output file to be resolved at run
time. */
-
+
if (sreloc == NULL)
{
const char *name;
-
+
name = (bfd_elf_string_from_elf_section
(input_bfd,
elf_elfheader (input_bfd)->e_shstrndx,
elf_section_data (input_section)->rel_hdr.sh_name));
if (name == NULL)
return FALSE;
-
+
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
&& strcmp (bfd_get_section_name (input_bfd,
input_section),
name + 5) == 0);
-
+
sreloc = bfd_get_section_by_name (dynobj, name);
BFD_ASSERT (sreloc != NULL);
}
-
+
skip = FALSE;
relocate = FALSE;
-
+
outrel.r_offset = _bfd_elf_section_offset (output_bfd,
info,
input_section,
skip = TRUE, relocate = TRUE;
outrel.r_offset += (input_section->output_section->vma
+ input_section->output_offset);
-
+
if (skip)
memset (&outrel, 0, sizeof outrel);
else if (r_type == R_M32R_18_PCREL_RELA
continue;
}
break;
-
+
case (int) R_M32R_10_PCREL :
r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
contents, offset,
struct elf_m32r_link_hash_table *htab;
bfd *dynobj;
bfd_byte *loc;
-
+
#ifdef DEBUG_PIC
printf("m32r_elf_finish_dynamic_symbol()\n");
#endif
-
+
htab = m32r_elf_hash_table (info);
dynobj = htab->root.dynobj;
bfd_vma plt_index;
bfd_vma got_offset;
Elf_Internal_Rela rela;
-
+
/* This symbol has an entry in the procedure linkage table. Set
it up. */
-
+
BFD_ASSERT (h->dynindx != -1);
-
+
splt = htab->splt;
sgot = htab->sgotplt;
srela = htab->srelplt;
+ (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
splt->contents + h->plt.offset + 16);
}
-
+
/* Fill in the entry in the global offset table. */
bfd_put_32 (output_bfd,
(splt->output_section->vma
loc = srela->contents;
loc += plt_index * sizeof(Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
-
+
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
{
/* Mark the symbol as undefined, rather than as defined in
asection *sgot;
asection *srela;
Elf_Internal_Rela rela;
-
+
/* This symbol has an entry in the global offset table. Set it
up. */
-
+
sgot = htab->sgot;
srela = htab->srelgot;
BFD_ASSERT (sgot != NULL && srela != NULL);
-
+
rela.r_offset = (sgot->output_section->vma
+ sgot->output_offset
+ (h->got.offset &~ 1));
-
+
/* If this is a -Bsymbolic link, and the symbol is defined
locally, we just want to emit a RELATIVE reloc. Likewise if
the symbol was forced to be local because of a version file.
rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
rela.r_addend = 0;
}
-
+
loc = srela->contents;
loc += srela->reloc_count * sizeof(Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
++srela->reloc_count;
}
-
+
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
{
asection *s;
Elf_Internal_Rela rela;
-
+
/* This symbols needs a copy reloc. Set it up. */
-
+
BFD_ASSERT (h->dynindx != -1
&& (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak));
-
+
s = bfd_get_section_by_name (h->root.u.def.section->owner,
".rela.bss");
BFD_ASSERT (s != NULL);
-
+
rela.r_offset = (h->root.u.def.value
+ h->root.u.def.section->output_section->vma
+ h->root.u.def.section->output_offset);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
++s->reloc_count;
}
-
+
/* Mark some specially defined symbols as absolute. */
if (strcmp (h->root.root.string, "_DYNAMIC") == 0
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
sym->st_shndx = SHN_ABS;
-
+
return TRUE;
}
/* Finish up the dynamic sections. */
-
+
static bfd_boolean
m32r_elf_finish_dynamic_sections (output_bfd, info)
bfd *output_bfd;
#ifdef DEBUG_PIC
printf("m32r_elf_finish_dynamic_sections()\n");
#endif
-
+
htab = m32r_elf_hash_table (info);
dynobj = htab->root.dynobj;
sgot = htab->sgotplt;
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
-
+
if (htab->root.dynamic_sections_created)
{
asection *splt;
Elf32_External_Dyn *dyncon, *dynconend;
-
+
BFD_ASSERT (sgot != NULL && sdyn != NULL);
-
+
dyncon = (Elf32_External_Dyn *) sdyn->contents;
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
Elf_Internal_Dyn dyn;
const char *name;
asection *s;
-
+
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
-
+
switch (dyn.d_tag)
{
default:
case DT_PLTGOT:
name = ".got";
- s = htab->sgot->output_section;
+ s = htab->sgot->output_section;
goto get_vma;
case DT_JMPREL:
name = ".rela.plt";
break;
}
}
-
+
/* Fill in the first entry in the procedure linkage table. */
splt = htab->splt;
if (splt && splt->_raw_size > 0)
bfd_put_32 (output_bfd,
PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
splt->contents);
- bfd_put_32 (output_bfd,
+ bfd_put_32 (output_bfd,
PLT0_ENTRY_WORD1 | (addr & 0xffff),
splt->contents + 4);
bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
}
-
+
return TRUE;
}
{
case R_M32R_GOT16_HI_ULO:
case R_M32R_GOT16_HI_SLO:
- case R_M32R_GOT16_LO:
+ case R_M32R_GOT16_LO:
case R_M32R_GOT24:
if (h != NULL)
because this might be a case of linking PIC code without
linking in any dynamic objects, in which case we don't
need to generate a procedure linkage table after all. */
-
+
/* If this is a local symbol, we resolve it directly without
creating a procedure linkage table entry. */
if (h == NULL)
if (sreloc == NULL)
{
const char *name;
-
+
name = (bfd_elf_string_from_elf_section
(abfd,
elf_elfheader (abfd)->e_shstrndx,
elf_section_data (sec)->rel_hdr.sh_name));
if (name == NULL)
return FALSE;
-
+
BFD_ASSERT (strncmp (name, ".rela", 5) == 0
&& strcmp (bfd_get_section_name (abfd, sec),
name + 5) == 0);
-
+
sreloc = bfd_get_section_by_name (dynobj, name);
if (sreloc == NULL)
{
flagword flags;
-
+
sreloc = bfd_make_section (dynobj, name);
flags = (SEC_HAS_CONTENTS | SEC_READONLY
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
}
elf_section_data (sec)->sreloc = sreloc;
}
-
+
/* If this is a global symbol, we count the number of
relocations we need for this symbol. */
if (h != NULL)
projects / binutils-gdb.git / commitdiff