/* Offset of tp and dtp pointers from start of TLS block. */
#define TP_OFFSET 0x7000
#define DTP_OFFSET 0x8000
+
+/* The value of a defined global symbol. */
+#define SYM_VAL(SYM) \
+ ((SYM)->root.u.def.section->output_section->vma \
+ + (SYM)->root.u.def.section->output_offset \
+ + (SYM)->root.u.def.value)
\f
static reloc_howto_type *ppc_elf_howto_table[R_PPC_max];
apuinfo_list_finish ();
}
\f
+static bfd_boolean
+is_pic_glink_stub (bfd *abfd, asection *glink, bfd_vma off)
+{
+ bfd_byte buf[16];
+ unsigned int insn;
+
+ if (!bfd_get_section_contents (abfd, glink, buf, off, 16))
+ return FALSE;
+
+ insn = bfd_get_32 (abfd, buf);
+ if ((insn & 0xffff0000) == LWZ_11_30
+ && bfd_get_32 (abfd, buf + 4) == MTCTR_11
+ && bfd_get_32 (abfd, buf + 8) == BCTR)
+ return TRUE;
+
+ if ((insn & 0xffff0000) == ADDIS_11_30
+ && (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11
+ && bfd_get_32 (abfd, buf + 8) == MTCTR_11
+ && bfd_get_32 (abfd, buf + 12) == BCTR)
+ return TRUE;
+ return FALSE;
+}
+
+static bfd_boolean
+section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
+{
+ bfd_vma vma = *(bfd_vma *) ptr;
+ return ((section->flags & SEC_ALLOC) != 0
+ && section->vma <= vma
+ && vma < section->vma + section->size);
+}
+
+static long
+ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms,
+ long dynsymcount, asymbol **dynsyms,
+ asymbol **ret)
+{
+ bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
+ asection *plt, *relplt, *dynamic, *glink;
+ bfd_vma glink_vma = 0;
+ bfd_vma resolv_vma = 0;
+ bfd_vma stub_vma;
+ asymbol *s;
+ arelent *p;
+ long count, i;
+ size_t size;
+ char *names;
+ bfd_byte buf[4];
+
+ *ret = NULL;
+
+ if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
+ return 0;
+
+ if (dynsymcount <= 0)
+ return 0;
+
+ relplt = bfd_get_section_by_name (abfd, ".rela.plt");
+ if (relplt == NULL)
+ return 0;
+
+ plt = bfd_get_section_by_name (abfd, ".plt");
+ if (plt == NULL)
+ return 0;
+
+ /* Call common code to handle old-style executable PLTs. */
+ if (elf_section_flags (plt) & SHF_EXECINSTR)
+ return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms,
+ dynsymcount, dynsyms, ret);
+
+ /* If this object was prelinked, the prelinker stored the address
+ of .glink at got[1]. If it wasn't prelinked, got[1] will be zero. */
+ dynamic = bfd_get_section_by_name (abfd, ".dynamic");
+ if (dynamic != NULL)
+ {
+ bfd_byte *dynbuf, *extdyn, *extdynend;
+ size_t extdynsize;
+ void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
+
+ if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
+ return -1;
+
+ extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
+ swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
+
+ extdyn = dynbuf;
+ extdynend = extdyn + dynamic->size;
+ for (; extdyn < extdynend; extdyn += extdynsize)
+ {
+ Elf_Internal_Dyn dyn;
+ (*swap_dyn_in) (abfd, extdyn, &dyn);
+
+ if (dyn.d_tag == DT_NULL)
+ break;
+
+ if (dyn.d_tag == DT_PPC_GOT)
+ {
+ unsigned int g_o_t = dyn.d_un.d_val;
+ asection *got = bfd_get_section_by_name (abfd, ".got");
+ if (got != NULL
+ && bfd_get_section_contents (abfd, got, buf,
+ g_o_t - got->vma + 4, 4))
+ glink_vma = bfd_get_32 (abfd, buf);
+ break;
+ }
+ }
+ free (dynbuf);
+ }
+
+ /* Otherwise we read the first plt entry. */
+ if (glink_vma == 0)
+ {
+ if (bfd_get_section_contents (abfd, plt, buf, 0, 4))
+ glink_vma = bfd_get_32 (abfd, buf);
+ }
+
+ if (glink_vma == 0)
+ return 0;
+
+ /* The .glink section usually does not survive the final
+ link; search for the section (usually .text) where the
+ glink stubs now reside. */
+ glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma);
+ if (glink == NULL)
+ return 0;
+
+ /* Determine glink PLT resolver by reading the relative branch
+ from the first glink stub. */
+ if (bfd_get_section_contents (abfd, glink, buf,
+ glink_vma - glink->vma, 4))
+ {
+ unsigned int insn = bfd_get_32 (abfd, buf);
+
+ /* The first glink stub may either branch to the resolver ... */
+ insn ^= B;
+ if ((insn & ~0x3fffffc) == 0)
+ resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000;
+
+ /* ... or fall through a bunch of NOPs. */
+ else if ((insn ^ B ^ NOP) == 0)
+ for (i = 4;
+ bfd_get_section_contents (abfd, glink, buf,
+ glink_vma - glink->vma + i, 4);
+ i += 4)
+ if (bfd_get_32 (abfd, buf) != NOP)
+ {
+ resolv_vma = glink_vma + i;
+ break;
+ }
+ }
+
+ count = relplt->size / sizeof (Elf32_External_Rela);
+ stub_vma = glink_vma - (bfd_vma) count * 16;
+ /* If the stubs are those for -shared/-pie then we might have
+ multiple stubs for each plt entry. If that is the case then
+ there is no way to associate stubs with their plt entries short
+ of figuring out the GOT pointer value used in the stub. */
+ if (!bfd_get_section_contents (abfd, glink, buf,
+ stub_vma - glink->vma, 4)
+ || ((bfd_get_32 (abfd, buf) & 0xffff0000) != LIS_11
+ && is_pic_glink_stub (abfd, glink, stub_vma - glink->vma - 16)))
+ return 0;
+
+ slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
+ if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
+ return -1;
+
+ size = count * sizeof (asymbol);
+ p = relplt->relocation;
+ for (i = 0; i < count; i++, p++)
+ size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
+
+ size += sizeof (asymbol) + sizeof ("__glink");
+
+ if (resolv_vma)
+ size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
+
+ s = *ret = bfd_malloc (size);
+ if (s == NULL)
+ return -1;
+
+ names = (char *) (s + count + 1 + (resolv_vma != 0));
+ p = relplt->relocation;
+ for (i = 0; i < count; i++, p++)
+ {
+ size_t len;
+
+ *s = **p->sym_ptr_ptr;
+ /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
+ we are defining a symbol, ensure one of them is set. */
+ if ((s->flags & BSF_LOCAL) == 0)
+ s->flags |= BSF_GLOBAL;
+ s->flags |= BSF_SYNTHETIC;
+ s->section = glink;
+ s->value = stub_vma - glink->vma;
+ s->name = names;
+ s->udata.p = NULL;
+ len = strlen ((*p->sym_ptr_ptr)->name);
+ memcpy (names, (*p->sym_ptr_ptr)->name, len);
+ names += len;
+ memcpy (names, "@plt", sizeof ("@plt"));
+ names += sizeof ("@plt");
+ ++s;
+ stub_vma += 16;
+ }
+
+ /* Add a symbol at the start of the glink branch table. */
+ memset (s, 0, sizeof *s);
+ s->the_bfd = abfd;
+ s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
+ s->section = glink;
+ s->value = glink_vma - glink->vma;
+ s->name = names;
+ memcpy (names, "__glink", sizeof ("__glink"));
+ names += sizeof ("__glink");
+ s++;
+ count++;
+
+ if (resolv_vma)
+ {
+ /* Add a symbol for the glink PLT resolver. */
+ memset (s, 0, sizeof *s);
+ s->the_bfd = abfd;
+ s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
+ s->section = glink;
+ s->value = resolv_vma - glink->vma;
+ s->name = names;
+ memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
+ names += sizeof ("__glink_PLTresolve");
+ s++;
+ count++;
+ }
+
+ return count;
+}
+\f
/* The following functions are specific to the ELF linker, while
functions above are used generally. They appear in this file more
or less in the order in which they are called. eg.
bfd_vma glink_offset;
};
-/* Of those relocs that might be copied as dynamic relocs, this macro
+/* Of those relocs that might be copied as dynamic relocs, this function
selects those that must be copied when linking a shared library,
even when the symbol is local. */
-#define MUST_BE_DYN_RELOC(RTYPE) \
- ((RTYPE) != R_PPC_REL24 \
- && (RTYPE) != R_PPC_REL14 \
- && (RTYPE) != R_PPC_REL14_BRTAKEN \
- && (RTYPE) != R_PPC_REL14_BRNTAKEN \
- && (RTYPE) != R_PPC_REL32)
+static int
+must_be_dyn_reloc (struct bfd_link_info *info,
+ enum elf_ppc_reloc_type r_type)
+{
+ switch (r_type)
+ {
+ default:
+ return 1;
+
+ case R_PPC_REL24:
+ case R_PPC_REL14:
+ case R_PPC_REL14_BRTAKEN:
+ case R_PPC_REL14_BRNTAKEN:
+ case R_PPC_REL32:
+ return 0;
+
+ case R_PPC_TPREL32:
+ case R_PPC_TPREL16:
+ case R_PPC_TPREL16_LO:
+ case R_PPC_TPREL16_HI:
+ case R_PPC_TPREL16_HA:
+ return !info->executable;
+ }
+}
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
copying dynamic variables from a shared lib into an app's dynbss
/* The .got.plt section (VxWorks only)*/
asection *sgotplt;
- /* Shortcut to .__tls_get_addr. */
+ /* Shortcut to __tls_get_addr. */
struct elf_link_hash_entry *tls_get_addr;
/* The bfd that forced an old-style PLT. */
case R_PPC_GOT_TPREL16_LO:
case R_PPC_GOT_TPREL16_HI:
case R_PPC_GOT_TPREL16_HA:
- if (info->shared)
+ if (!info->executable)
info->flags |= DF_STATIC_TLS;
tls_type = TLS_TLS | TLS_TPREL;
goto dogottls;
/* We shouldn't really be seeing these. */
case R_PPC_TPREL32:
- if (info->shared)
+ case R_PPC_TPREL16:
+ case R_PPC_TPREL16_LO:
+ case R_PPC_TPREL16_HI:
+ case R_PPC_TPREL16_HA:
+ if (!info->executable)
info->flags |= DF_STATIC_TLS;
goto dodyn;
case R_PPC_DTPREL32:
goto dodyn;
- case R_PPC_TPREL16:
- case R_PPC_TPREL16_LO:
- case R_PPC_TPREL16_HI:
- case R_PPC_TPREL16_HA:
- if (info->shared)
- info->flags |= DF_STATIC_TLS;
- goto dodyn;
-
case R_PPC_REL32:
if (h == NULL
&& got2 != NULL
dynamic library if we manage to avoid copy relocs for the
symbol. */
if ((info->shared
- && (MUST_BE_DYN_RELOC (r_type)
+ && (must_be_dyn_reloc (info, r_type)
|| (h != NULL
&& (! info->symbolic
|| h->root.type == bfd_link_hash_defweak
#endif
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 (CONST_STRNEQ (name, ".rela")
- && strcmp (bfd_get_section_name (abfd, sec),
- name + 5) == 0);
-
if (htab->elf.dynobj == NULL)
htab->elf.dynobj = abfd;
- sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
+
+ sreloc = _bfd_elf_make_dynamic_reloc_section
+ (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
+
if (sreloc == NULL)
- {
- flagword flags;
-
- flags = (SEC_HAS_CONTENTS | SEC_READONLY
- | SEC_IN_MEMORY | SEC_LINKER_CREATED
- | SEC_ALLOC | SEC_LOAD);
- sreloc = bfd_make_section_with_flags (htab->elf.dynobj,
- name,
- flags);
- if (sreloc == NULL
- || ! bfd_set_section_alignment (htab->elf.dynobj,
- sreloc, 2))
- return FALSE;
- }
- elf_section_data (sec)->sreloc = sreloc;
+ return FALSE;
}
/* If this is a global symbol, we count the number of
}
p->count += 1;
- if (!MUST_BE_DYN_RELOC (r_type))
+ if (!must_be_dyn_reloc (info, r_type))
p->pc_count += 1;
}
else if (out_attr->i == 1 && in_attr->i == 2)
_bfd_error_handler
(_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd);
- else if (out_attr->i == 2 && in_attr->i == 1)
+ else if (out_attr->i == 1 && in_attr->i == 3)
+ _bfd_error_handler
+ (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
+ obfd, ibfd);
+ else if (out_attr->i == 3 && in_attr->i == 1)
+ _bfd_error_handler
+ (_("Warning: %B uses double-precision hard float, %B uses single-precision hard float"),
+ ibfd, obfd);
+ else if (out_attr->i == 3 && in_attr->i == 2)
+ _bfd_error_handler
+ (_("Warning: %B uses soft float, %B uses single-precision hard float"),
+ ibfd, obfd);
+ else if (out_attr->i == 2 && (in_attr->i == 1 || in_attr->i == 3))
_bfd_error_handler
(_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd);
- else if (in_attr->i > 2)
+ else if (in_attr->i > 3)
_bfd_error_handler
(_("Warning: %B uses unknown floating point ABI %d"), ibfd,
in_attr->i);
ibfd, obfd, in_abi, out_abi);
}
+ /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes
+ and merge non-conflicting ones. */
+ in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return];
+ out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return];
+ if (in_attr->i != out_attr->i)
+ {
+ out_attr->type = 1;
+ if (out_attr->i == 0)
+ out_attr->i = in_attr->i;
+ else if (in_attr->i == 0)
+ ;
+ else if (out_attr->i == 1 && in_attr->i == 2)
+ _bfd_error_handler
+ (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), obfd, ibfd);
+ else if (out_attr->i == 2 && in_attr->i == 1)
+ _bfd_error_handler
+ (_("Warning: %B uses r3/r4 for small structure returns, %B uses memory"), ibfd, obfd);
+ else if (in_attr->i > 2)
+ _bfd_error_handler
+ (_("Warning: %B uses unknown small structure return convention %d"), ibfd,
+ in_attr->i);
+ else
+ _bfd_error_handler
+ (_("Warning: %B uses unknown small structure return convention %d"), obfd,
+ out_attr->i);
+ }
+
/* Merge Tag_compatibility attributes and any common GNU ones. */
_bfd_elf_merge_object_attributes (ibfd, obfd);
struct ppc_elf_link_hash_table *htab;
int pass;
- if (info->relocatable || info->shared)
+ if (info->relocatable || !info->executable)
return TRUE;
htab = ppc_elf_hash_table (info);
eh = (struct ppc_elf_link_hash_entry *) h;
if (eh->elf.got.refcount > 0)
{
+ bfd_boolean dyn;
+ unsigned int need;
+
/* Make sure this symbol is output as a dynamic symbol. */
if (eh->elf.dynindx == -1
- && !eh->elf.forced_local)
+ && !eh->elf.forced_local
+ && htab->elf.dynamic_sections_created)
{
if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf))
return FALSE;
}
- if (eh->tls_mask == (TLS_TLS | TLS_LD)
- && !eh->elf.def_dynamic)
- {
- /* If just an LD reloc, we'll just use htab->tlsld_got.offset. */
- htab->tlsld_got.refcount += 1;
- eh->elf.got.offset = (bfd_vma) -1;
- }
- else
+ need = 0;
+ if ((eh->tls_mask & TLS_TLS) != 0)
{
- bfd_boolean dyn;
- unsigned int need = 0;
- if ((eh->tls_mask & TLS_TLS) != 0)
+ if ((eh->tls_mask & TLS_LD) != 0)
{
- if ((eh->tls_mask & TLS_LD) != 0)
- need += 8;
- if ((eh->tls_mask & TLS_GD) != 0)
+ if (!eh->elf.def_dynamic)
+ /* We'll just use htab->tlsld_got.offset. This should
+ always be the case. It's a little odd if we have
+ a local dynamic reloc against a non-local symbol. */
+ htab->tlsld_got.refcount += 1;
+ else
need += 8;
- if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
- need += 4;
- if ((eh->tls_mask & TLS_DTPREL) != 0)
- need += 4;
}
- else
+ if ((eh->tls_mask & TLS_GD) != 0)
+ need += 8;
+ if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0)
need += 4;
+ if ((eh->tls_mask & TLS_DTPREL) != 0)
+ need += 4;
+ }
+ else
+ need += 4;
+ if (need == 0)
+ eh->elf.got.offset = (bfd_vma) -1;
+ else
+ {
eh->elf.got.offset = allocate_got (htab, need);
dyn = htab->elf.dynamic_sections_created;
if ((info->shared
{
/* All the entries we allocated need relocs.
Except LD only needs one. */
- if ((eh->tls_mask & TLS_LD) != 0)
+ if ((eh->tls_mask & TLS_LD) != 0
+ && eh->elf.def_dynamic)
need -= 4;
htab->relgot->size += need * (sizeof (Elf32_External_Rela) / 4);
}
else
eh->elf.got.offset = (bfd_vma) -1;
- if (eh->dyn_relocs == NULL)
+ if (eh->dyn_relocs == NULL
+ || !htab->elf.dynamic_sections_created)
return TRUE;
/* In the shared -Bsymbolic case, discard space allocated for
if (info->shared)
{
/* Relocs that use pc_count are those that appear on a call insn,
- or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
+ or certain REL relocs (see must_be_dyn_reloc) that can be
generated via assembly. We want calls to protected symbols to
resolve directly to the function rather than going via the plt.
If people want function pointer comparisons to work as expected
for (; local_got < end_local_got; ++local_got, ++lgot_masks)
if (*local_got > 0)
{
- if (*lgot_masks == (TLS_TLS | TLS_LD))
+ unsigned int need = 0;
+ if ((*lgot_masks & TLS_TLS) != 0)
{
- /* If just an LD reloc, we'll just use
- htab->tlsld_got.offset. */
- htab->tlsld_got.refcount += 1;
- *local_got = (bfd_vma) -1;
+ if ((*lgot_masks & TLS_GD) != 0)
+ need += 8;
+ if ((*lgot_masks & TLS_LD) != 0)
+ htab->tlsld_got.refcount += 1;
+ if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
+ need += 4;
+ if ((*lgot_masks & TLS_DTPREL) != 0)
+ need += 4;
}
+ else
+ need += 4;
+ if (need == 0)
+ *local_got = (bfd_vma) -1;
else
{
- unsigned int need = 0;
- if ((*lgot_masks & TLS_TLS) != 0)
- {
- if ((*lgot_masks & TLS_GD) != 0)
- need += 8;
- if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0)
- need += 4;
- if ((*lgot_masks & TLS_DTPREL) != 0)
- need += 4;
- }
- else
- need += 4;
*local_got = allocate_got (htab, need);
if (info->shared)
htab->relgot->size += (need
Elf_Internal_Rela *internal_relocs = NULL;
Elf_Internal_Rela *irel, *irelend;
struct one_fixup *fixups = NULL;
- bfd_boolean changed;
+ unsigned changes = 0;
struct ppc_elf_link_hash_table *htab;
bfd_size_type trampoff;
asection *got2;
irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
stub_rtype);
irel->r_offset = trampoff + insn_offset;
+ if (r_type == R_PPC_PLTREL24)
+ irel->r_addend = 0;
/* Record the fixup so we don't do it again this section. */
f = bfd_malloc (sizeof (*f));
fixups = f;
trampoff += size;
+ changes++;
}
else
{
}
/* Write out the trampolines. */
- changed = fixups != NULL;
if (fixups != NULL)
{
const int *stub;
isec->size = (isec->size + 3) & (bfd_vma) -4;
/* Branch around the trampolines. */
- val = trampoff - isec->size + 0x48000000;
+ val = B + trampoff - isec->size;
dest = contents + isec->size;
isec->size = trampoff;
bfd_put_32 (abfd, val, dest);
if (contents != NULL
&& elf_section_data (isec)->this_hdr.contents != contents)
{
- if (!changed && !link_info->keep_memory)
+ if (!changes && !link_info->keep_memory)
free (contents);
else
{
}
}
- if (elf_section_data (isec)->relocs != internal_relocs)
+ if (changes != 0)
{
- if (!changed)
+ /* Append sufficient NOP relocs so we can write out relocation
+ information for the trampolines. */
+ Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count)
+ * sizeof (*new_relocs));
+ unsigned ix;
+
+ if (!new_relocs)
+ goto error_return;
+ memcpy (new_relocs, internal_relocs,
+ isec->reloc_count * sizeof (*new_relocs));
+ for (ix = changes; ix--;)
+ {
+ irel = new_relocs + ix + isec->reloc_count;
+
+ irel->r_info = ELF32_R_INFO (0, R_PPC_NONE);
+ }
+ if (internal_relocs != elf_section_data (isec)->relocs)
free (internal_relocs);
- else
- elf_section_data (isec)->relocs = internal_relocs;
+ elf_section_data (isec)->relocs = new_relocs;
+ isec->reloc_count += changes;
+ elf_section_data (isec)->rel_hdr.sh_size
+ += changes * elf_section_data (isec)->rel_hdr.sh_entsize;
}
+ else if (elf_section_data (isec)->relocs != internal_relocs)
+ free (internal_relocs);
- *again = changed;
+ *again = changes != 0;
return TRUE;
error_return:
if (tls_gd == 0)
{
/* Was an LD reloc. */
- r_symndx = 0;
+ for (r_symndx = 0;
+ r_symndx < symtab_hdr->sh_info;
+ r_symndx++)
+ if (local_sections[r_symndx] == sec)
+ break;
+ if (r_symndx >= symtab_hdr->sh_info)
+ r_symndx = 0;
rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
+ if (r_symndx != 0)
+ rel->r_addend -= (local_syms[r_symndx].st_value
+ + sec->output_offset
+ + sec->output_section->vma);
}
r_type = R_PPC_TPREL16_HA;
rel->r_info = ELF32_R_INFO (r_symndx, r_type);
/* Generate relocs for the dynamic linker. */
if ((info->shared || indx != 0)
- && (h == NULL
+ && (offp == &htab->tlsld_got.offset
+ || h == NULL
|| ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak))
{
outrel.r_info = ELF32_R_INFO (indx, R_PPC_RELATIVE);
else
outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT);
- if (indx == 0)
+ if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD))
{
outrel.r_addend += relocation;
if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL))
}
}
- relocation = htab->got->output_offset + off;
- relocation -= htab->elf.hgot->root.u.def.value;
+ relocation = (htab->got->output_section->vma
+ + htab->got->output_offset
+ + off
+ - SYM_VAL (htab->elf.hgot));
/* Addends on got relocations don't make much sense.
x+off@got is actually x@got+off, and since the got is
|| ELF_ST_VISIBILITY (h->other) == STV_INTERNAL))
|| (h->root.type == bfd_link_hash_undefweak
&& ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)))
- && (MUST_BE_DYN_RELOC (r_type)
+ && (must_be_dyn_reloc (info, r_type)
|| !SYMBOL_CALLS_LOCAL (info, h)))
|| (ELIMINATE_COPY_RELOCS
&& !info->shared
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)
+ sreloc = _bfd_elf_get_dynamic_reloc_section
+ (input_bfd, input_section, /*rela?*/ TRUE);
+ if (sreloc == NULL)
return FALSE;
-
- BFD_ASSERT (CONST_STRNEQ (name, ".rela")
- && strcmp (bfd_get_section_name (input_bfd,
- input_section),
- name + 5) == 0);
-
- sreloc = bfd_get_section_by_name (htab->elf.dynobj, name);
- BFD_ASSERT (sreloc != NULL);
}
skip = 0;
{
long indx = 0;
- if (bfd_is_abs_section (sec))
+ if (r_symndx == 0 || bfd_is_abs_section (sec))
;
else if (sec == NULL || sec->owner == NULL)
{
relocation = (htab->plt->output_section->vma
+ htab->plt->output_offset
+ ent->plt.offset);
- addend = 0;
}
if (r_type == R_PPC_RELAX32_PLT)
goto relax32;
bfd_put_32 (output_bfd, t0, contents + rel->r_offset);
bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4);
+
+ /* Rewrite the reloc and convert one of the trailing nop
+ relocs to describe this relocation. */
+ BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE);
+ /* The relocs are at the bottom 2 bytes */
+ rel[0].r_offset += 2;
+ memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel));
+ rel[0].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA);
+ rel[1].r_offset += 4;
+ rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO);
+ rel++;
}
continue;
an embedded ELF object, for which the .got section acts like the
AIX .toc section. */
case R_PPC_TOC16: /* phony GOT16 relocations */
- BFD_ASSERT (sec != NULL);
- BFD_ASSERT (bfd_is_und_section (sec)
- || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
+ if (sec == NULL || sec->output_section == NULL)
+ {
+ unresolved_reloc = TRUE;
+ break;
+ }
+ BFD_ASSERT (strcmp (bfd_get_section_name (abfd, sec), ".got") == 0
|| strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0);
- addend -= sec->output_section->vma + sec->output_offset + 0x8000;
+ addend -= sec->output_section->vma + sec->output_offset + 0x8000;
break;
case R_PPC_PLTREL24:
case R_PPC_SDAREL16:
{
const char *name;
- struct elf_link_hash_entry *sh;
- BFD_ASSERT (sec != NULL);
+ if (sec == NULL || sec->output_section == NULL)
+ {
+ unresolved_reloc = TRUE;
+ break;
+ }
+
name = bfd_get_section_name (abfd, sec->output_section);
if (! ((CONST_STRNEQ (name, ".sdata")
&& (name[6] == 0 || name[6] == '.'))
howto->name,
name);
}
- sh = htab->sdata[0].sym;
- addend -= (sh->root.u.def.value
- + sh->root.u.def.section->output_offset
- + sh->root.u.def.section->output_section->vma);
+ addend -= SYM_VAL (htab->sdata[0].sym);
}
break;
case R_PPC_EMB_SDA2REL:
{
const char *name;
- struct elf_link_hash_entry *sh;
- BFD_ASSERT (sec != NULL);
+ if (sec == NULL || sec->output_section == NULL)
+ {
+ unresolved_reloc = TRUE;
+ break;
+ }
+
name = bfd_get_section_name (abfd, sec->output_section);
if (! (CONST_STRNEQ (name, ".sdata2")
|| CONST_STRNEQ (name, ".sbss2")))
ret = FALSE;
continue;
}
- sh = htab->sdata[1].sym;
- addend -= (sh->root.u.def.value
- + sh->root.u.def.section->output_offset
- + sh->root.u.def.section->output_section->vma);
+ addend -= SYM_VAL (htab->sdata[1].sym);
}
break;
{
const char *name;
int reg;
- struct elf_link_hash_entry *sh;
- BFD_ASSERT (sec != NULL);
+ if (sec == NULL || sec->output_section == NULL)
+ {
+ unresolved_reloc = TRUE;
+ break;
+ }
+
name = bfd_get_section_name (abfd, sec->output_section);
if (((CONST_STRNEQ (name, ".sdata")
&& (name[6] == 0 || name[6] == '.'))
&& (name[5] == 0 || name[5] == '.'))))
{
reg = 13;
- sh = htab->sdata[0].sym;
- addend -= (sh->root.u.def.value
- + sh->root.u.def.section->output_offset
- + sh->root.u.def.section->output_section->vma);
+ addend -= SYM_VAL (htab->sdata[0].sym);
}
-
else if (CONST_STRNEQ (name, ".sdata2")
|| CONST_STRNEQ (name, ".sbss2"))
{
reg = 2;
- sh = htab->sdata[1].sym;
- addend -= (sh->root.u.def.value
- + sh->root.u.def.section->output_offset
- + sh->root.u.def.section->output_section->vma);
+ addend -= SYM_VAL (htab->sdata[1].sym);
}
-
else if (strcmp (name, ".PPC.EMB.sdata0") == 0
|| strcmp (name, ".PPC.EMB.sbss0") == 0)
{
reg = 0;
}
-
else
{
(*_bfd_error_handler)
case R_PPC_SECTOFF_LO:
case R_PPC_SECTOFF_HI:
case R_PPC_SECTOFF_HA:
- BFD_ASSERT (sec != NULL);
+ if (sec == NULL || sec->output_section == NULL)
+ {
+ unresolved_reloc = TRUE;
+ break;
+ }
addend -= sec->output_section->vma;
break;
/* Fill in the .plt on VxWorks. */
if (info->shared)
{
- bfd_vma got_offset_hi = (got_offset >> 16)
- + ((got_offset & 0x8000) >> 15);
-
bfd_put_32 (output_bfd,
- plt_entry[0] | (got_offset_hi & 0xffff),
+ plt_entry[0] | PPC_HA (got_offset),
htab->plt->contents + ent->plt.offset + 0);
bfd_put_32 (output_bfd,
- plt_entry[1] | (got_offset & 0xffff),
+ plt_entry[1] | PPC_LO (got_offset),
htab->plt->contents + ent->plt.offset + 4);
}
else
{
- bfd_vma got_loc
- = (got_offset
- + htab->elf.hgot->root.u.def.value
- + htab->elf.hgot->root.u.def.section->output_offset
- + htab->elf.hgot->root.u.def.section->output_section->vma);
- bfd_vma got_loc_hi = (got_loc >> 16)
- + ((got_loc & 0x8000) >> 15);
+ bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot);
bfd_put_32 (output_bfd,
- plt_entry[0] | (got_loc_hi & 0xffff),
+ plt_entry[0] | PPC_HA (got_loc),
htab->plt->contents + ent->plt.offset + 0);
bfd_put_32 (output_bfd,
- plt_entry[1] | (got_loc & 0xffff),
+ plt_entry[1] | PPC_LO (got_loc),
htab->plt->contents + ent->plt.offset + 4);
}
+ ent->sec->output_section->vma
+ ent->sec->output_offset);
else if (htab->elf.hgot != NULL)
- got = (htab->elf.hgot->root.u.def.value
- + htab->elf.hgot->root.u.def.section->output_section->vma
- + htab->elf.hgot->root.u.def.section->output_offset);
+ got = SYM_VAL (htab->elf.hgot);
plt -= got;
s = htab->relbss;
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);
+ rela.r_offset = SYM_VAL (h);
rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY);
rela.r_addend = 0;
loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
asection *splt;
struct ppc_elf_link_hash_table *htab;
bfd_vma got;
- bfd * dynobj;
+ bfd *dynobj;
+ bfd_boolean ret = TRUE;
#ifdef DEBUG
fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n");
got = 0;
if (htab->elf.hgot != NULL)
- got = (htab->elf.hgot->root.u.def.value
- + htab->elf.hgot->root.u.def.section->output_section->vma
- + htab->elf.hgot->root.u.def.section->output_offset);
+ got = SYM_VAL (htab->elf.hgot);
if (htab->elf.dynamic_sections_created)
{
}
}
- /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
- easily find the address of the _GLOBAL_OFFSET_TABLE_. */
if (htab->got != NULL)
{
- unsigned char *p = htab->got->contents;
- bfd_vma val;
+ if (htab->elf.hgot->root.u.def.section == htab->got
+ || htab->elf.hgot->root.u.def.section == htab->sgotplt)
+ {
+ unsigned char *p = htab->elf.hgot->root.u.def.section->contents;
- p += htab->elf.hgot->root.u.def.value;
- if (htab->plt_type == PLT_OLD)
- bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, p - 4);
+ p += htab->elf.hgot->root.u.def.value;
+ if (htab->plt_type == PLT_OLD)
+ {
+ /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4
+ so that a function can easily find the address of
+ _GLOBAL_OFFSET_TABLE_. */
+ BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4
+ < htab->elf.hgot->root.u.def.section->size);
+ bfd_put_32 (output_bfd, 0x4e800021, p - 4);
+ }
- val = 0;
- if (sdyn != NULL)
- val = sdyn->output_section->vma + sdyn->output_offset;
- bfd_put_32 (output_bfd, val, p);
+ if (sdyn != NULL)
+ {
+ bfd_vma val = sdyn->output_section->vma + sdyn->output_offset;
+ BFD_ASSERT (htab->elf.hgot->root.u.def.value
+ < htab->elf.hgot->root.u.def.section->size);
+ bfd_put_32 (output_bfd, val, p);
+ }
+ }
+ else
+ {
+ (*_bfd_error_handler) (_("%s not defined in linker created %s"),
+ htab->elf.hgot->root.root.string,
+ (htab->sgotplt != NULL
+ ? htab->sgotplt->name : htab->got->name));
+ bfd_set_error (bfd_error_bad_value);
+ ret = FALSE;
+ }
elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4;
}
if (!info->shared)
{
- bfd_vma got_value =
- (htab->elf.hgot->root.u.def.section->output_section->vma
- + htab->elf.hgot->root.u.def.section->output_offset
- + htab->elf.hgot->root.u.def.value);
- bfd_vma got_hi = (got_value >> 16) + ((got_value & 0x8000) >> 15);
+ bfd_vma got_value = SYM_VAL (htab->elf.hgot);
- bfd_put_32 (output_bfd, plt_entry[0] | (got_hi & 0xffff),
+ bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value),
splt->contents + 0);
- bfd_put_32 (output_bfd, plt_entry[1] | (got_value & 0xffff),
+ bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value),
splt->contents + 4);
}
else
}
}
- return TRUE;
+ return ret;
}
\f
#define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec
#define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup
#define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags
#define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create
+#define bfd_elf32_get_synthetic_symtab ppc_elf_get_synthetic_symtab
#define elf_backend_object_p ppc_elf_object_p
#define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook
#undef elf_backend_got_header_size
#define elf_backend_got_header_size 12
+#undef bfd_elf32_get_synthetic_symtab
+
#undef bfd_elf32_bfd_link_hash_table_create
#define bfd_elf32_bfd_link_hash_table_create \
ppc_elf_vxworks_link_hash_table_create
projects / deliverable / binutils-gdb.git / blobdiff