/* BFD back-end for HP PA-RISC ELF files.
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
Original code by
Center for Software Science
asection *id_sec;
};
+enum _tls_type
+ {
+ GOT_UNKNOWN = 0,
+ GOT_NORMAL = 1,
+ GOT_TLS_GD = 2,
+ GOT_TLS_LDM = 4,
+ GOT_TLS_IE = 8
+ };
+
struct elf32_hppa_link_hash_entry
{
struct elf_link_hash_entry eh;
#endif
} *dyn_relocs;
- enum
- {
- GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_GD = 2, GOT_TLS_LDM = 4, GOT_TLS_IE = 8
- } tls_type;
+ ENUM_BITFIELD (_tls_type) tls_type : 8;
/* Set if this symbol is used by a plabel reloc. */
unsigned int plabel:1;
asection **input_list;
Elf_Internal_Sym **all_local_syms;
- /* Short-cuts to get to dynamic linker sections. */
- asection *sgot;
- asection *srelgot;
- asection *splt;
- asection *srelplt;
- asection *sdynbss;
- asection *srelbss;
-
/* Used during a final link to store the base of the text and data
segments so that we can perform SEGREL relocations. */
bfd_vma text_segment_base;
off &= ~ (bfd_vma) 1;
sym_value = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma
- - elf_gp (htab->splt->output_section->owner));
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ - elf_gp (htab->etab.splt->output_section->owner));
insn = ADDIL_DP;
#if R19_STUBS
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
hsh->target_section->owner,
stub_sec,
- (long) hsh->stub_offset,
+ hsh->stub_offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
htab = hppa_link_hash_table (info);
if (htab == NULL)
return FALSE;
- if (htab->splt != NULL)
+ if (htab->etab.splt != NULL)
return TRUE;
/* Call the generic code to do most of the work. */
if (! _bfd_elf_create_dynamic_sections (abfd, info))
return FALSE;
- htab->splt = bfd_get_linker_section (abfd, ".plt");
- htab->srelplt = bfd_get_linker_section (abfd, ".rela.plt");
-
- htab->sgot = bfd_get_linker_section (abfd, ".got");
- htab->srelgot = bfd_get_linker_section (abfd, ".rela.got");
-
- htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
- htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
-
/* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
application, because __canonicalize_funcptr_for_compare needs it. */
eh = elf_hash_table (info)->hgot;
/* If called to transfer flags for a weakdef during processing
of elf_adjust_dynamic_symbol, don't copy non_got_ref.
We clear it ourselves for ELIMINATE_COPY_RELOCS. */
- eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
+ if (eh_dir->versioned != versioned_hidden)
+ eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
eh_dir->ref_regular |= eh_ind->ref_regular;
eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak;
eh_dir->needs_plt |= eh_ind->needs_plt;
}
else
{
- if (eh_ind->root.type == bfd_link_hash_indirect
- && eh_dir->got.refcount <= 0)
- {
- hh_dir->tls_type = hh_ind->tls_type;
- hh_ind->tls_type = GOT_UNKNOWN;
- }
+ if (eh_ind->root.type == bfd_link_hash_indirect)
+ {
+ hh_dir->plabel |= hh_ind->plabel;
+ hh_dir->tls_type |= hh_ind->tls_type;
+ hh_ind->tls_type = GOT_UNKNOWN;
+ }
_bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
}
const Elf_Internal_Rela *rela_end;
struct elf32_hppa_link_hash_table *htab;
asection *sreloc;
- int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
if (bfd_link_relocatable (info))
return TRUE;
/* PR15323, ref flags aren't set for references in the same
object. */
- hh->eh.root.non_ir_ref = 1;
+ hh->eh.root.non_ir_ref_regular = 1;
}
r_type = ELF32_R_TYPE (rela->r_info);
functions indirectly or to compare function pointers.
We avoid the mess by always pointing a PLABEL into the
.plt, even for local functions. */
- need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
+ need_entry = PLT_PLABEL | NEED_PLT;
+ if (bfd_link_pic (info))
+ need_entry |= NEED_DYNREL;
break;
case R_PARISC_PCREL12F:
case R_PARISC_TLS_IE21L:
case R_PARISC_TLS_IE14R:
- if (bfd_link_pic (info))
+ if (bfd_link_dll (info))
info->flags |= DF_STATIC_TLS;
need_entry = NEED_GOT;
break;
/* Now carry out our orders. */
if (need_entry & NEED_GOT)
{
+ int tls_type = GOT_NORMAL;
+
switch (r_type)
{
default:
- tls_type = GOT_NORMAL;
break;
case R_PARISC_TLS_GD21L:
case R_PARISC_TLS_GD14R:
- tls_type |= GOT_TLS_GD;
+ tls_type = GOT_TLS_GD;
break;
case R_PARISC_TLS_LDM21L:
case R_PARISC_TLS_LDM14R:
- tls_type |= GOT_TLS_LDM;
+ tls_type = GOT_TLS_LDM;
break;
case R_PARISC_TLS_IE21L:
case R_PARISC_TLS_IE14R:
- tls_type |= GOT_TLS_IE;
+ tls_type = GOT_TLS_IE;
break;
}
/* Allocate space for a GOT entry, as well as a dynamic
relocation for this entry. */
- if (htab->sgot == NULL)
+ if (htab->etab.sgot == NULL)
{
if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
return FALSE;
}
- if (r_type == R_PARISC_TLS_LDM21L
- || r_type == R_PARISC_TLS_LDM14R)
- htab->tls_ldm_got.refcount += 1;
- else
+ if (hh != NULL)
{
- if (hh != NULL)
- {
- hh->eh.got.refcount += 1;
- old_tls_type = hh->tls_type;
- }
+ if (tls_type == GOT_TLS_LDM)
+ htab->tls_ldm_got.refcount += 1;
else
- {
- bfd_signed_vma *local_got_refcounts;
-
- /* This is a global offset table entry for a local symbol. */
- local_got_refcounts = hppa32_elf_local_refcounts (abfd);
- if (local_got_refcounts == NULL)
- return FALSE;
- local_got_refcounts[r_symndx] += 1;
-
- old_tls_type = hppa_elf_local_got_tls_type (abfd) [r_symndx];
- }
-
- tls_type |= old_tls_type;
+ hh->eh.got.refcount += 1;
+ hh->tls_type |= tls_type;
+ }
+ else
+ {
+ bfd_signed_vma *local_got_refcounts;
- if (old_tls_type != tls_type)
- {
- if (hh != NULL)
- hh->tls_type = tls_type;
- else
- hppa_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
- }
+ /* This is a global offset table entry for a local symbol. */
+ local_got_refcounts = hppa32_elf_local_refcounts (abfd);
+ if (local_got_refcounts == NULL)
+ return FALSE;
+ if (tls_type == GOT_TLS_LDM)
+ htab->tls_ldm_got.refcount += 1;
+ else
+ local_got_refcounts[r_symndx] += 1;
+ hppa_elf_local_got_tls_type (abfd) [r_symndx] |= tls_type;
}
}
}
}
- if (need_entry & NEED_DYNREL)
+ if ((need_entry & NEED_DYNREL) != 0
+ && (sec->flags & SEC_ALLOC) != 0)
{
/* Flag this symbol as having a non-got, non-plt reference
so that we generate copy relocs if it turns out to be
dynamic library if we manage to avoid copy relocs for the
symbol. */
if ((bfd_link_pic (info)
- && (sec->flags & SEC_ALLOC) != 0
&& (IS_ABSOLUTE_RELOC (r_type)
|| (hh != NULL
&& (!SYMBOLIC_BIND (info, &hh->eh)
|| !hh->eh.def_regular))))
|| (ELIMINATE_COPY_RELOCS
&& !bfd_link_pic (info)
- && (sec->flags & SEC_ALLOC) != 0
&& hh != NULL
&& (hh->eh.root.type == bfd_link_hash_defweak
|| !hh->eh.def_regular)))
return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
}
-/* Update the got and plt entry reference counts for the section being
- removed. */
-
-static bfd_boolean
-elf32_hppa_gc_sweep_hook (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED,
- asection *sec,
- const Elf_Internal_Rela *relocs)
-{
- Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **eh_syms;
- bfd_signed_vma *local_got_refcounts;
- bfd_signed_vma *local_plt_refcounts;
- const Elf_Internal_Rela *rela, *relend;
- struct elf32_hppa_link_hash_table *htab;
-
- if (bfd_link_relocatable (info))
- return TRUE;
-
- htab = hppa_link_hash_table (info);
- if (htab == NULL)
- return FALSE;
-
- elf_section_data (sec)->local_dynrel = NULL;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- eh_syms = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
- local_plt_refcounts = local_got_refcounts;
- if (local_plt_refcounts != NULL)
- local_plt_refcounts += symtab_hdr->sh_info;
-
- relend = relocs + sec->reloc_count;
- for (rela = relocs; rela < relend; rela++)
- {
- unsigned long r_symndx;
- unsigned int r_type;
- struct elf_link_hash_entry *eh = NULL;
-
- r_symndx = ELF32_R_SYM (rela->r_info);
- if (r_symndx >= symtab_hdr->sh_info)
- {
- struct elf32_hppa_link_hash_entry *hh;
- struct elf32_hppa_dyn_reloc_entry **hdh_pp;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
-
- eh = eh_syms[r_symndx - symtab_hdr->sh_info];
- while (eh->root.type == bfd_link_hash_indirect
- || eh->root.type == bfd_link_hash_warning)
- eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
- hh = hppa_elf_hash_entry (eh);
-
- for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; hdh_pp = &hdh_p->hdh_next)
- if (hdh_p->sec == sec)
- {
- /* Everything must go for SEC. */
- *hdh_pp = hdh_p->hdh_next;
- break;
- }
- }
-
- r_type = ELF32_R_TYPE (rela->r_info);
- r_type = elf32_hppa_optimized_tls_reloc (info, r_type, eh != NULL);
-
- switch (r_type)
- {
- case R_PARISC_DLTIND14F:
- case R_PARISC_DLTIND14R:
- case R_PARISC_DLTIND21L:
- case R_PARISC_TLS_GD21L:
- case R_PARISC_TLS_GD14R:
- case R_PARISC_TLS_IE21L:
- case R_PARISC_TLS_IE14R:
- if (eh != NULL)
- {
- if (eh->got.refcount > 0)
- eh->got.refcount -= 1;
- }
- else if (local_got_refcounts != NULL)
- {
- if (local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- }
- break;
-
- case R_PARISC_TLS_LDM21L:
- case R_PARISC_TLS_LDM14R:
- htab->tls_ldm_got.refcount -= 1;
- break;
-
- case R_PARISC_PCREL12F:
- case R_PARISC_PCREL17C:
- case R_PARISC_PCREL17F:
- case R_PARISC_PCREL22F:
- if (eh != NULL)
- {
- if (eh->plt.refcount > 0)
- eh->plt.refcount -= 1;
- }
- break;
-
- case R_PARISC_PLABEL14R:
- case R_PARISC_PLABEL21L:
- case R_PARISC_PLABEL32:
- if (eh != NULL)
- {
- if (eh->plt.refcount > 0)
- eh->plt.refcount -= 1;
- }
- else if (local_plt_refcounts != NULL)
- {
- if (local_plt_refcounts[r_symndx] > 0)
- local_plt_refcounts[r_symndx] -= 1;
- }
- break;
-
- default:
- break;
- }
- }
-
- return TRUE;
-}
-
/* Support for core dump NOTE sections. */
static bfd_boolean
}
}
+/* Find any dynamic relocs that apply to read-only sections. */
+
+static asection *
+readonly_dynrelocs (struct elf_link_hash_entry *eh)
+{
+ struct elf32_hppa_link_hash_entry *hh;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
+
+ hh = hppa_elf_hash_entry (eh);
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+ {
+ asection *sec = hdh_p->sec->output_section;
+
+ if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
+ return hdh_p->sec;
+ }
+ return NULL;
+}
+
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
dynamic object, but we're not including those sections. We have to
struct elf_link_hash_entry *eh)
{
struct elf32_hppa_link_hash_table *htab;
- asection *sec;
+ asection *sec, *srel;
/* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later. */
if (eh->type == STT_FUNC
|| eh->needs_plt)
{
+ /* After adjust_dynamic_symbol, non_got_ref set in the non-pic
+ case means that dyn_relocs for this symbol should be
+ discarded; We either want the symbol to remain undefined, or
+ we have a local definition of some sort. The "local
+ definition" for non-function symbols may be due to creating a
+ local definition in .dynbss.
+ Unlike other targets, elf32-hppa.c does not define a function
+ symbol in a non-pic executable on PLT stub code, so we don't
+ have a local definition in that case. dyn_relocs therefore
+ should not be discarded for function symbols, generally.
+ However we should discard dyn_relocs if we've decided that an
+ undefined function symbol is local, for example due to
+ non-default visibility, or UNDEFWEAK_NO_DYNAMIC_RELOC is
+ true for an undefined weak symbol. */
+ bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
+ /* Prior to adjust_dynamic_symbol, non_got_ref set means that
+ check_relocs set up some dyn_relocs for this symbol.
+ The !non_got_ref term here is saying that if we didn't have
+ any dyn_relocs set up by check_relocs, then we don't want
+ relocate_section looking for them.
+ FIXME: Get rid of the inversion, so non_got_ref set after
+ dyn_relocs means we do have dyn_relocs. */
+ eh->non_got_ref = local || !eh->non_got_ref;
+
/* If the symbol is used by a plabel, we must allocate a PLT slot.
The refcounts are not reliable when it has been hidden since
hide_symbol can be called before the plabel flag is set. */
- if (hppa_elf_hash_entry (eh)->plabel
- && eh->plt.refcount <= 0)
+ if (hppa_elf_hash_entry (eh)->plabel)
eh->plt.refcount = 1;
- if (eh->plt.refcount <= 0
- || (eh->def_regular
- && eh->root.type != bfd_link_hash_defweak
- && ! hppa_elf_hash_entry (eh)->plabel
- && (!bfd_link_pic (info) || SYMBOLIC_BIND (info, eh))))
+ /* Note that unlike some other backends, the refcount is not
+ incremented for a non-call (and non-plabel) function reference. */
+ else if (eh->plt.refcount <= 0
+ || local)
{
/* The .plt entry is not needed when:
a) Garbage collection has removed all references to the
object, and it's not a weak definition, nor is the symbol
used by a plabel relocation. Either this object is the
application or we are doing a shared symbolic link. */
-
eh->plt.offset = (bfd_vma) -1;
eh->needs_plt = 0;
}
+ /* Function symbols can't have copy relocs. */
return TRUE;
}
else
/* If there are no references to this symbol that do not use the
GOT, we don't need to generate a copy reloc. */
if (!eh->non_got_ref)
- return TRUE;
-
- if (ELIMINATE_COPY_RELOCS)
{
- struct elf32_hppa_link_hash_entry *hh;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ eh->non_got_ref = 1;
+ return TRUE;
+ }
- hh = hppa_elf_hash_entry (eh);
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
- {
- sec = hdh_p->sec->output_section;
- if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
- break;
- }
+ /* If -z nocopyreloc was given, we won't generate them either. */
+ if (info->nocopyreloc)
+ {
+ eh->non_got_ref = 0;
+ return TRUE;
+ }
+ if (ELIMINATE_COPY_RELOCS
+ && !readonly_dynrelocs (eh))
+ {
/* If we didn't find any dynamic relocs in read-only sections, then
we'll be keeping the dynamic relocs and avoiding the copy reloc. */
- if (hdh_p == NULL)
- {
- eh->non_got_ref = 0;
- return TRUE;
- }
+ eh->non_got_ref = 0;
+ return TRUE;
}
/* We must allocate the symbol in our .dynbss section, which will
/* We must generate a COPY reloc to tell the dynamic linker to
copy the initial value out of the dynamic object and into the
runtime process image. */
+ if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
+ {
+ sec = htab->etab.sdynrelro;
+ srel = htab->etab.sreldynrelro;
+ }
+ else
+ {
+ sec = htab->etab.sdynbss;
+ srel = htab->etab.srelbss;
+ }
if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
{
- htab->srelbss->size += sizeof (Elf32_External_Rela);
+ srel->size += sizeof (Elf32_External_Rela);
eh->needs_copy = 1;
}
- sec = htab->sdynbss;
-
return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
}
+/* If EH is undefined, make it dynamic if that makes sense. */
+
+static bfd_boolean
+ensure_undef_dynamic (struct bfd_link_info *info,
+ struct elf_link_hash_entry *eh)
+{
+ struct elf_link_hash_table *htab = elf_hash_table (info);
+
+ if (htab->dynamic_sections_created
+ && (eh->root.type == bfd_link_hash_undefweak
+ || eh->root.type == bfd_link_hash_undefined)
+ && eh->dynindx == -1
+ && !eh->forced_local
+ && eh->type != STT_PARISC_MILLI
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
+ && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
+ return bfd_elf_link_record_dynamic_symbol (info, eh);
+ return TRUE;
+}
+
/* Allocate space in the .plt for entries that won't have relocations.
ie. plabel entries. */
if (htab->etab.dynamic_sections_created
&& eh->plt.refcount > 0)
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (eh->dynindx == -1
- && !eh->forced_local
- && eh->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, eh))
- return FALSE;
- }
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
{
{
/* Make an entry in the .plt section for plabel references
that won't have a .plt entry for other reasons. */
- sec = htab->splt;
+ sec = htab->etab.splt;
eh->plt.offset = sec->size;
sec->size += PLT_ENTRY_SIZE;
+ if (bfd_link_pic (info))
+ htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
}
else
{
return TRUE;
}
+/* Calculate size of GOT entries for symbol given its TLS_TYPE. */
+
+static inline unsigned int
+got_entries_needed (int tls_type)
+{
+ unsigned int need = 0;
+
+ if ((tls_type & GOT_NORMAL) != 0)
+ need += GOT_ENTRY_SIZE;
+ if ((tls_type & GOT_TLS_GD) != 0)
+ need += GOT_ENTRY_SIZE * 2;
+ if ((tls_type & GOT_TLS_IE) != 0)
+ need += GOT_ENTRY_SIZE;
+ return need;
+}
+
+/* Calculate size of relocs needed for symbol given its TLS_TYPE and
+ NEEDed GOT entries. KNOWN says a TPREL offset can be calculated
+ at link time. */
+
+static inline unsigned int
+got_relocs_needed (int tls_type, unsigned int need, bfd_boolean known)
+{
+ /* All the entries we allocated need relocs.
+ Except IE in executable with a local symbol. We could also omit
+ the DTPOFF reloc on the second word of a GD entry under the same
+ condition as that for IE, but ld.so might want to differentiate
+ LD and GD entries at some stage. */
+ if ((tls_type & GOT_TLS_IE) != 0 && known)
+ need -= GOT_ENTRY_SIZE;
+ return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
+}
+
/* Allocate space in .plt, .got and associated reloc sections for
global syms. */
&& eh->plt.refcount > 0)
{
/* Make an entry in the .plt section. */
- sec = htab->splt;
+ sec = htab->etab.splt;
eh->plt.offset = sec->size;
sec->size += PLT_ENTRY_SIZE;
/* We also need to make an entry in the .rela.plt section. */
- htab->srelplt->size += sizeof (Elf32_External_Rela);
+ htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
htab->need_plt_stub = 1;
}
if (eh->got.refcount > 0)
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (eh->dynindx == -1
- && !eh->forced_local
- && eh->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, eh))
- return FALSE;
- }
+ unsigned int need;
- sec = htab->sgot;
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
+
+ sec = htab->etab.sgot;
eh->got.offset = sec->size;
- sec->size += GOT_ENTRY_SIZE;
- /* R_PARISC_TLS_GD* needs two GOT entries */
- if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
- sec->size += GOT_ENTRY_SIZE * 2;
- else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
- sec->size += GOT_ENTRY_SIZE;
+ need = got_entries_needed (hh->tls_type);
+ sec->size += need;
if (htab->etab.dynamic_sections_created
&& (bfd_link_pic (info)
|| (eh->dynindx != -1
- && !eh->forced_local)))
+ && !SYMBOL_REFERENCES_LOCAL (info, eh)))
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- htab->srelgot->size += sizeof (Elf32_External_Rela);
- if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
- htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
- else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ bfd_boolean tprel_known = (bfd_link_executable (info)
+ && SYMBOL_REFERENCES_LOCAL (info, eh));
+ htab->etab.srelgot->size
+ += got_relocs_needed (hh->tls_type, need, tprel_known);
}
}
else
eh->got.offset = (bfd_vma) -1;
+ /* If no dynamic sections we can't have dynamic relocs. */
+ if (!htab->etab.dynamic_sections_created)
+ hh->dyn_relocs = NULL;
+
if (hh->dyn_relocs == NULL)
return TRUE;
changes. */
if (bfd_link_pic (info))
{
+ /* Discard relocs on undefined syms with non-default visibility. */
+ if ((eh->root.type == bfd_link_hash_undefined
+ && ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
+ hh->dyn_relocs = NULL;
+
#if RELATIVE_DYNRELOCS
- if (SYMBOL_CALLS_LOCAL (info, eh))
+ else if (SYMBOL_CALLS_LOCAL (info, eh))
{
struct elf32_hppa_dyn_reloc_entry **hdh_pp;
}
#endif
- /* Also discard relocs on undefined weak syms with non-default
- visibility. */
- if (hh->dyn_relocs != NULL
- && eh->root.type == bfd_link_hash_undefweak)
+ if (hh->dyn_relocs != NULL)
{
- if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
- hh->dyn_relocs = NULL;
-
- /* Make sure undefined weak symbols are output as a dynamic
- symbol in PIEs. */
- else if (eh->dynindx == -1
- && !eh->forced_local)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, eh))
- return FALSE;
- }
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
}
}
- else
+ else if (ELIMINATE_COPY_RELOCS)
{
/* For the non-shared case, discard space for relocs against
symbols which turn out to need copy relocs or are not
dynamic. */
if (!eh->non_got_ref
- && ((ELIMINATE_COPY_RELOCS
- && eh->def_dynamic
- && !eh->def_regular)
- || (htab->etab.dynamic_sections_created
- && (eh->root.type == bfd_link_hash_undefweak
- || eh->root.type == bfd_link_hash_undefined))))
+ && !eh->def_regular)
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (eh->dynindx == -1
- && !eh->forced_local
- && eh->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, eh))
- return FALSE;
- }
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
- /* If that succeeded, we know we'll be keeping all the
- relocs. */
- if (eh->dynindx != -1)
- goto keep;
+ if (eh->dynindx == -1)
+ hh->dyn_relocs = NULL;
}
-
- hh->dyn_relocs = NULL;
- return TRUE;
-
- keep: ;
+ else
+ hh->dyn_relocs = NULL;
}
/* Finally, allocate space. */
return TRUE;
}
-/* Find any dynamic relocs that apply to read-only sections. */
+/* Set DF_TEXTREL if we find any dynamic relocs that apply to
+ read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
+maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
{
- struct elf32_hppa_link_hash_entry *hh;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ asection *sec;
- hh = hppa_elf_hash_entry (eh);
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
- {
- asection *sec = hdh_p->sec->output_section;
+ if (eh->root.type == bfd_link_hash_indirect)
+ return TRUE;
- if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = inf;
+ sec = readonly_dynrelocs (eh);
+ if (sec != NULL)
+ {
+ struct bfd_link_info *info = (struct bfd_link_info *) inf;
- info->flags |= DF_TEXTREL;
+ info->flags |= DF_TEXTREL;
+ info->callbacks->minfo
+ (_("%B: dynamic relocation in read-only section `%A'\n"),
+ sec->owner, sec);
- /* Not an error, just cut short the traversal. */
- return FALSE;
- }
+ /* Not an error, just cut short the traversal. */
+ return FALSE;
}
return TRUE;
}
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
local_tls_type = hppa_elf_local_got_tls_type (ibfd);
- sec = htab->sgot;
- srel = htab->srelgot;
+ sec = htab->etab.sgot;
+ srel = htab->etab.srelgot;
for (; local_got < end_local_got; ++local_got)
{
if (*local_got > 0)
{
+ unsigned int need;
+
*local_got = sec->size;
- sec->size += GOT_ENTRY_SIZE;
- if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
- sec->size += 2 * GOT_ENTRY_SIZE;
- else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
- sec->size += GOT_ENTRY_SIZE;
+ need = got_entries_needed (*local_tls_type);
+ sec->size += need;
if (bfd_link_pic (info))
- {
- srel->size += sizeof (Elf32_External_Rela);
- if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
- srel->size += 2 * sizeof (Elf32_External_Rela);
- else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
- srel->size += sizeof (Elf32_External_Rela);
- }
+ {
+ bfd_boolean tprel_known = bfd_link_executable (info);
+ htab->etab.srelgot->size
+ += got_relocs_needed (*local_tls_type, need, tprel_known);
+ }
}
else
*local_got = (bfd_vma) -1;
}
else
{
- sec = htab->splt;
- srel = htab->srelplt;
+ sec = htab->etab.splt;
+ srel = htab->etab.srelplt;
for (; local_plt < end_local_plt; ++local_plt)
{
if (*local_plt > 0)
{
/* Allocate 2 got entries and 1 dynamic reloc for
R_PARISC_TLS_DTPMOD32 relocs. */
- htab->tls_ldm_got.offset = htab->sgot->size;
- htab->sgot->size += (GOT_ENTRY_SIZE * 2);
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ htab->tls_ldm_got.offset = htab->etab.sgot->size;
+ htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
+ htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
}
else
htab->tls_ldm_got.offset = -1;
if ((sec->flags & SEC_LINKER_CREATED) == 0)
continue;
- if (sec == htab->splt)
+ if (sec == htab->etab.splt)
{
if (htab->need_plt_stub)
{
/* Make space for the plt stub at the end of the .plt
section. We want this stub right at the end, up
against the .got section. */
- int gotalign = bfd_section_alignment (dynobj, htab->sgot);
+ int gotalign = bfd_section_alignment (dynobj, htab->etab.sgot);
int pltalign = bfd_section_alignment (dynobj, sec);
bfd_size_type mask;
sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
}
}
- else if (sec == htab->sgot
- || sec == htab->sdynbss)
+ else if (sec == htab->etab.sgot
+ || sec == htab->etab.sdynbss
+ || sec == htab->etab.sdynrelro)
;
else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
{
{
/* Remember whether there are any reloc sections other
than .rela.plt. */
- if (sec != htab->srelplt)
+ if (sec != htab->etab.srelplt)
relocs = TRUE;
/* We use the reloc_count field as a counter if we need
return FALSE;
}
- if (htab->srelplt->size != 0)
+ if (htab->etab.srelplt->size != 0)
{
if (!add_dynamic_entry (DT_PLTRELSZ, 0)
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
/* If any dynamic relocs apply to a read-only section,
then we need a DT_TEXTREL entry. */
if ((info->flags & DF_TEXTREL) == 0)
- elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info);
+ elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
struct bfd_link_hash_entry *h;
asection *sec = NULL;
bfd_vma gp_val = 0;
- struct elf32_hppa_link_hash_table *htab;
- htab = hppa_link_hash_table (info);
- if (htab == NULL)
- return FALSE;
-
- h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE);
+ h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
if (h != NULL
&& (h->type == bfd_link_hash_defined
}
}
- if (sec != NULL && sec->output_section != NULL)
- gp_val += sec->output_section->vma + sec->output_offset;
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ {
+ if (sec != NULL && sec->output_section != NULL)
+ gp_val += sec->output_section->vma + sec->output_offset;
- elf_gp (abfd) = gp_val;
+ elf_gp (abfd) = gp_val;
+ }
return TRUE;
}
error. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
+ (_("%B(%A+%#Lx): %s fixup for insn %#x is not supported in a non-shared link"),
input_bfd,
input_section,
- (long) offset,
+ offset,
howto->name,
insn);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
input_bfd,
input_section,
- (long) offset,
+ offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
case R_PARISC_DLTIND21L:
{
bfd_vma off;
- bfd_boolean do_got = 0;
+ bfd_boolean do_got = FALSE;
+ bfd_boolean reloc = bfd_link_pic (info);
/* Relocation is to the entry for this symbol in the
global offset table. */
off = hh->eh.got.offset;
dyn = htab->etab.dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
- bfd_link_pic (info),
- &hh->eh))
+ reloc = (!UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)
+ && (reloc
+ || (hh->eh.dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))));
+ if (!reloc
+ || !WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ &hh->eh))
{
/* If we aren't going to call finish_dynamic_symbol,
then we need to handle initialisation of the .got
else
{
hh->eh.got.offset |= 1;
- do_got = 1;
+ do_got = TRUE;
}
}
}
else
{
local_got_offsets[r_symndx] |= 1;
- do_got = 1;
+ do_got = TRUE;
}
}
if (do_got)
{
- if (bfd_link_pic (info))
+ if (reloc)
{
/* Output a dynamic relocation for this GOT entry.
In this case it is relative to the base of the
object because the symbol index is zero. */
Elf_Internal_Rela outrel;
bfd_byte *loc;
- asection *sec = htab->srelgot;
+ asection *sec = htab->etab.srelgot;
outrel.r_offset = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
outrel.r_addend = relocation;
loc = sec->contents;
}
else
bfd_put_32 (output_bfd, relocation,
- htab->sgot->contents + off);
+ htab->etab.sgot->contents + off);
}
if (off >= (bfd_vma) -2)
/* Add the base of the GOT to the relocation value. */
relocation = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
}
break;
PLT entry. */
Elf_Internal_Rela outrel;
bfd_byte *loc;
- asection *s = htab->srelplt;
+ asection *s = htab->etab.srelplt;
outrel.r_offset = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma);
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma);
outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
outrel.r_addend = relocation;
loc = s->contents;
{
bfd_put_32 (output_bfd,
relocation,
- htab->splt->contents + off);
+ htab->etab.splt->contents + off);
bfd_put_32 (output_bfd,
- elf_gp (htab->splt->output_section->owner),
- htab->splt->contents + off + 4);
+ elf_gp (htab->etab.splt->output_section->owner),
+ htab->etab.splt->contents + off + 4);
}
}
&& hh->eh.root.type != bfd_link_hash_undefined))
{
relocation = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ 2);
}
plabel = 1;
allocate_dynrelocs. ie. We need exactly the same condition
as in ..check_relocs, with some extra conditions (dynindx
test in this case) to cater for relocs removed by
- allocate_dynrelocs. If you squint, the non-shared test
- here does indeed match the one in ..check_relocs, the
- difference being that here we test DEF_DYNAMIC as well as
- !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
- which is why we can't use just that test here.
- Conversely, DEF_DYNAMIC can't be used in check_relocs as
- there all files have not been loaded. */
+ allocate_dynrelocs. */
if ((bfd_link_pic (info)
- && (hh == NULL
- || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
- || hh->eh.root.type != bfd_link_hash_undefweak)
+ && !(hh != NULL
+ && ((hh->eh.root.type == bfd_link_hash_undefined
+ && ELF_ST_VISIBILITY (hh->eh.other) != STV_DEFAULT)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)))
&& (IS_ABSOLUTE_RELOC (r_type)
|| !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
- || (!bfd_link_pic (info)
+ || (ELIMINATE_COPY_RELOCS
+ && !bfd_link_pic (info)
&& hh != NULL
&& hh->eh.dynindx != -1
&& !hh->eh.non_got_ref
- && ((ELIMINATE_COPY_RELOCS
- && hh->eh.def_dynamic
- && !hh->eh.def_regular)
- || hh->eh.root.type == bfd_link_hash_undefweak
- || hh->eh.root.type == bfd_link_hash_undefined)))
+ && !hh->eh.def_regular))
{
Elf_Internal_Rela outrel;
bfd_boolean skip;
bfd_byte *loc;
outrel.r_offset = (off
- + htab->sgot->output_section->vma
- + htab->sgot->output_offset);
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
outrel.r_addend = 0;
outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
- loc = htab->srelgot->contents;
- loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
+ loc = htab->etab.srelgot->contents;
+ loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
htab->tls_ldm_got.offset |= 1;
/* Add the base of the GOT to the relocation value. */
relocation = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
break;
}
indx = 0;
if (hh != NULL)
{
- bfd_boolean dyn;
- dyn = htab->etab.dynamic_sections_created;
-
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
- bfd_link_pic (info),
- &hh->eh)
- && (!bfd_link_pic (info)
- || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
- {
- indx = hh->eh.dynindx;
- }
+ if (!htab->etab.dynamic_sections_created
+ || hh->eh.dynindx == -1
+ || SYMBOL_REFERENCES_LOCAL (info, &hh->eh)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))
+ /* This is actually a static link, or it is a
+ -Bsymbolic link and the symbol is defined
+ locally, or the symbol was forced to be local
+ because of a version file. */
+ ;
+ else
+ indx = hh->eh.dynindx;
off = hh->eh.got.offset;
tls_type = hh->tls_type;
}
now, and emit any relocations. If both an IE GOT and a
GD GOT are necessary, we emit the GD first. */
- if ((bfd_link_pic (info) || indx != 0)
- && (hh == NULL
- || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
- || hh->eh.root.type != bfd_link_hash_undefweak))
+ if (indx != 0
+ || (bfd_link_pic (info)
+ && (hh == NULL
+ || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
{
need_relocs = TRUE;
- loc = htab->srelgot->contents;
- /* FIXME (CAO): Should this be reloc_count++ ? */
- loc += htab->srelgot->reloc_count * sizeof (Elf32_External_Rela);
+ loc = htab->etab.srelgot->contents;
+ loc += (htab->etab.srelgot->reloc_count
+ * sizeof (Elf32_External_Rela));
}
if (tls_type & GOT_TLS_GD)
{
if (need_relocs)
{
- outrel.r_offset = (cur_off
- + htab->sgot->output_section->vma
- + htab->sgot->output_offset);
- outrel.r_info = ELF32_R_INFO (indx,R_PARISC_TLS_DTPMOD32);
+ outrel.r_offset
+ = (cur_off
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
+ outrel.r_info
+ = ELF32_R_INFO (indx, R_PARISC_TLS_DTPMOD32);
outrel.r_addend = 0;
- bfd_put_32 (output_bfd, 0, htab->sgot->contents + cur_off);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
- htab->srelgot->reloc_count++;
+ htab->etab.srelgot->reloc_count++;
loc += sizeof (Elf32_External_Rela);
-
- if (indx == 0)
- bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
- htab->sgot->contents + cur_off + 4);
- else
- {
- bfd_put_32 (output_bfd, 0,
- htab->sgot->contents + cur_off + 4);
- outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
- outrel.r_offset += 4;
- bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
- htab->srelgot->reloc_count++;
- loc += sizeof (Elf32_External_Rela);
- }
+ outrel.r_info
+ = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
+ outrel.r_offset += 4;
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+ htab->etab.srelgot->reloc_count++;
+ loc += sizeof (Elf32_External_Rela);
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + cur_off);
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + cur_off + 4);
}
else
{
symbol binding locally. Mark it as belonging
to module 1, the executable. */
bfd_put_32 (output_bfd, 1,
- htab->sgot->contents + cur_off);
- bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
- htab->sgot->contents + cur_off + 4);
+ htab->etab.sgot->contents + cur_off);
+ bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
+ htab->etab.sgot->contents + cur_off + 4);
}
-
-
cur_off += 8;
}
if (tls_type & GOT_TLS_IE)
{
- if (need_relocs)
+ if (need_relocs
+ && !(bfd_link_executable (info)
+ && SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
{
- outrel.r_offset = (cur_off
- + htab->sgot->output_section->vma
- + htab->sgot->output_offset);
- outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_TPREL32);
-
+ outrel.r_offset
+ = (cur_off
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
+ outrel.r_info = ELF32_R_INFO (indx,
+ R_PARISC_TLS_TPREL32);
if (indx == 0)
outrel.r_addend = relocation - dtpoff_base (info);
else
outrel.r_addend = 0;
-
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
- htab->srelgot->reloc_count++;
+ htab->etab.srelgot->reloc_count++;
loc += sizeof (Elf32_External_Rela);
}
else
bfd_put_32 (output_bfd, tpoff (info, relocation),
- htab->sgot->contents + cur_off);
-
+ htab->etab.sgot->contents + cur_off);
cur_off += 4;
}
local_got_offsets[r_symndx] |= 1;
}
+ if ((tls_type & GOT_NORMAL) != 0
+ && (tls_type & (GOT_TLS_GD | GOT_TLS_LDM | GOT_TLS_IE)) != 0)
+ {
+ if (hh != NULL)
+ _bfd_error_handler (_("%s has both normal and TLS relocs"),
+ hh_name (hh));
+ else
+ {
+ Elf_Internal_Sym *isym
+ = bfd_sym_from_r_symndx (&htab->sym_cache,
+ input_bfd, r_symndx);
+ if (isym == NULL)
+ return FALSE;
+ sym_name
+ = bfd_elf_string_from_elf_section (input_bfd,
+ symtab_hdr->sh_link,
+ isym->st_name);
+ if (sym_name == NULL)
+ return FALSE;
+ if (*sym_name == '\0')
+ sym_name = bfd_section_name (input_bfd, sym_sec);
+ _bfd_error_handler
+ (_("%B:%s has both normal and TLS relocs"),
+ input_bfd, sym_name);
+ }
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
if ((tls_type & GOT_TLS_GD)
&& r_type != R_PARISC_TLS_GD21L
&& r_type != R_PARISC_TLS_GD14R)
/* Add the base of the GOT to the relocation value. */
relocation = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
break;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+0x%lx): cannot handle %s for %s"),
+ (_("%B(%A+%#Lx): cannot handle %s for %s"),
input_bfd,
input_section,
- (long) rela->r_offset,
+ rela->r_offset,
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
/* Create a dynamic IPLT relocation for this entry. */
rela.r_offset = (eh->plt.offset
- + htab->splt->output_offset
- + htab->splt->output_section->vma);
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma);
if (eh->dynindx != -1)
{
rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
rela.r_addend = value;
}
- loc = htab->srelplt->contents;
- loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rela, loc);
+ loc = htab->etab.srelplt->contents;
+ loc += htab->etab.srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
+ bfd_elf32_swap_reloca_out (htab->etab.splt->output_section->owner, &rela, loc);
if (!eh->def_regular)
{
}
if (eh->got.offset != (bfd_vma) -1
- && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
- && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
+ && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- /* This symbol has an entry in the global offset table. Set it
- up. */
-
- rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
-
- /* If this is a -Bsymbolic link and the symbol is defined
- locally or was forced to be local because of a version file,
- we just want to emit a RELATIVE reloc. The entry in the
- global offset table will already have been initialized in the
- relocate_section function. */
- if (bfd_link_pic (info)
- && (SYMBOLIC_BIND (info, eh) || eh->dynindx == -1)
- && eh->def_regular)
- {
- rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
- rela.r_addend = (eh->root.u.def.value
- + eh->root.u.def.section->output_offset
- + eh->root.u.def.section->output_section->vma);
- }
- else
+ bfd_boolean is_dyn = (eh->dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, eh));
+
+ if (is_dyn || bfd_link_pic (info))
{
- if ((eh->got.offset & 1) != 0)
- abort ();
+ /* This symbol has an entry in the global offset table. Set
+ it up. */
+
+ rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
+
+ /* If this is a -Bsymbolic link and the symbol is defined
+ locally or was forced to be local because of a version
+ file, we just want to emit a RELATIVE reloc. The entry
+ in the global offset table will already have been
+ initialized in the relocate_section function. */
+ if (!is_dyn)
+ {
+ rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
+ rela.r_addend = (eh->root.u.def.value
+ + eh->root.u.def.section->output_offset
+ + eh->root.u.def.section->output_section->vma);
+ }
+ else
+ {
+ if ((eh->got.offset & 1) != 0)
+ abort ();
- bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1));
- rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
- rela.r_addend = 0;
- }
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + (eh->got.offset & ~1));
+ rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
+ rela.r_addend = 0;
+ }
- loc = htab->srelgot->contents;
- loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
+ loc = htab->etab.srelgot->contents;
+ loc += (htab->etab.srelgot->reloc_count++
+ * sizeof (Elf32_External_Rela));
+ bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
+ }
}
if (eh->needs_copy)
|| eh->root.type == bfd_link_hash_defweak)))
abort ();
- sec = htab->srelbss;
-
rela.r_offset = (eh->root.u.def.value
+ eh->root.u.def.section->output_offset
+ eh->root.u.def.section->output_section->vma);
rela.r_addend = 0;
rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
+ if (eh->root.u.def.section == htab->etab.sdynrelro)
+ sec = htab->etab.sreldynrelro;
+ else
+ sec = htab->etab.srelbss;
loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
}
dynobj = htab->etab.dynobj;
- sgot = htab->sgot;
+ sgot = htab->etab.sgot;
/* A broken linker script might have discarded the dynamic sections.
Catch this here so that we do not seg-fault later on. */
if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
break;
case DT_JMPREL:
- s = htab->srelplt;
+ s = htab->etab.srelplt;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
break;
case DT_PLTRELSZ:
- s = htab->srelplt;
+ s = htab->etab.srelplt;
dyn.d_un.d_val = s->size;
break;
-
- case DT_RELASZ:
- /* Don't count procedure linkage table relocs in the
- overall reloc count. */
- s = htab->srelplt;
- if (s == NULL)
- continue;
- dyn.d_un.d_val -= s->size;
- break;
-
- case DT_RELA:
- /* We may not be using the standard ELF linker script.
- If .rela.plt is the first .rela section, we adjust
- DT_RELA to not include it. */
- s = htab->srelplt;
- if (s == NULL)
- continue;
- if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
- continue;
- dyn.d_un.d_ptr += s->size;
- break;
}
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
}
- if (htab->splt != NULL && htab->splt->size != 0)
+ if (htab->etab.splt != NULL && htab->etab.splt->size != 0)
{
/* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
plt stubs and as such the section does not hold a table of fixed-size
entries. */
- elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize = 0;
+ elf_section_data (htab->etab.splt->output_section)->this_hdr.sh_entsize = 0;
if (htab->need_plt_stub)
{
/* Set up the .plt stub. */
- memcpy (htab->splt->contents
- + htab->splt->size - sizeof (plt_stub),
+ memcpy (htab->etab.splt->contents
+ + htab->etab.splt->size - sizeof (plt_stub),
plt_stub, sizeof (plt_stub));
- if ((htab->splt->output_offset
- + htab->splt->output_section->vma
- + htab->splt->size)
+ if ((htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ + htab->etab.splt->size)
!= (sgot->output_offset
+ sgot->output_section->vma))
{
#define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
#define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
#define elf_backend_check_relocs elf32_hppa_check_relocs
+#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
#define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
#define elf_backend_fake_sections elf_hppa_fake_sections
#define elf_backend_relocate_section elf32_hppa_relocate_section
#define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
#define elf_backend_init_index_section _bfd_elf_init_1_index_section
#define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
-#define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
#define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
#define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
#define elf_backend_object_p elf32_hppa_object_p
#define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 8
+#define elf_backend_want_dynrelro 1
#define elf_backend_rela_normal 1
+#define elf_backend_dtrel_excludes_plt 1
+#define elf_backend_no_page_alias 1
#define TARGET_BIG_SYM hppa_elf32_vec
#define TARGET_BIG_NAME "elf32-hppa"