/* BFD back-end for HP PA-RISC ELF files.
- Copyright (C) 1990-2017 Free Software Foundation, Inc.
+ Copyright (C) 1990-2018 Free Software Foundation, Inc.
Original code by
Center for Software Science
/* Variable names follow a coding style.
Please follow this (Apps Hungarian) style:
- Structure/Variable Prefix
+ Structure/Variable Prefix
elf_link_hash_table "etab"
elf_link_hash_entry "eh"
bfd_hash_table containing stubs "bstab"
elf32_hppa_stub_hash_entry "hsh"
- elf32_hppa_dyn_reloc_entry "hdh"
-
Always remember to use GNU Coding Style. */
#define PLT_ENTRY_SIZE 8
/* Used to count relocations for delayed sizing of relocation
sections. */
- struct elf32_hppa_dyn_reloc_entry
- {
- /* Next relocation in the chain. */
- struct elf32_hppa_dyn_reloc_entry *hdh_next;
-
- /* The input section of the reloc. */
- asection *sec;
-
- /* Number of relocs copied in this section. */
- bfd_size_type count;
-
-#if RELATIVE_DYNRELOCS
- /* Number of relative relocs copied for the input section. */
- bfd_size_type relative_count;
-#endif
- } *dyn_relocs;
+ struct elf_dyn_relocs *dyn_relocs;
ENUM_BITFIELD (_tls_type) tls_type : 8;
if (hsh == NULL)
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: cannot create stub entry %s"),
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
section->owner, stub_name);
return NULL;
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot reach %s, recompile with -ffunction-sections"),
hsh->target_section->owner,
stub_sec,
- hsh->stub_offset,
+ (uint64_t) hsh->stub_offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
bfd_put_32 (stub_bfd, insn, loc);
- bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
+ bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8);
bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
{
if (hh_dir->dyn_relocs != NULL)
{
- struct elf32_hppa_dyn_reloc_entry **hdh_pp;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ struct elf_dyn_relocs **hdh_pp;
+ struct elf_dyn_relocs *hdh_p;
/* Add reloc counts against the indirect sym to the direct sym
list. Merge any entries against the same section. */
for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
- struct elf32_hppa_dyn_reloc_entry *hdh_q;
+ struct elf_dyn_relocs *hdh_q;
for (hdh_q = hh_dir->dyn_relocs;
hdh_q != NULL;
- hdh_q = hdh_q->hdh_next)
+ hdh_q = hdh_q->next)
if (hdh_q->sec == hdh_p->sec)
{
#if RELATIVE_DYNRELOCS
- hdh_q->relative_count += hdh_p->relative_count;
+ hdh_q->pc_count += hdh_p->pc_count;
#endif
hdh_q->count += hdh_p->count;
- *hdh_pp = hdh_p->hdh_next;
+ *hdh_pp = hdh_p->next;
break;
}
if (hdh_q == NULL)
- hdh_pp = &hdh_p->hdh_next;
+ hdh_pp = &hdh_p->next;
}
*hdh_pp = hh_dir->dyn_relocs;
}
hh_ind->dyn_relocs = NULL;
}
- if (ELIMINATE_COPY_RELOCS
- && eh_ind->root.type != bfd_link_hash_indirect
- && eh_dir->dynamic_adjusted)
+ if (eh_ind->root.type == bfd_link_hash_indirect)
{
- /* 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. */
- 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;
+ hh_dir->plabel |= hh_ind->plabel;
+ hh_dir->tls_type |= hh_ind->tls_type;
+ hh_ind->tls_type = GOT_UNKNOWN;
}
- else
- {
- 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);
- }
+ _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
}
static int
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+ (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
abfd,
elf_hppa_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
case R_PARISC_TLS_IE21L:
case R_PARISC_TLS_IE14R:
if (bfd_link_dll (info))
- info->flags |= DF_STATIC_TLS;
+ info->flags |= DF_STATIC_TLS;
need_entry = NEED_GOT;
break;
/* Flag this symbol as having a non-got, non-plt reference
so that we generate copy relocs if it turns out to be
dynamic. */
- if (hh != NULL && !bfd_link_pic (info))
+ if (hh != NULL)
hh->eh.non_got_ref = 1;
/* If we are creating a shared library then we need to copy
&& (hh->eh.root.type == bfd_link_hash_defweak
|| !hh->eh.def_regular)))
{
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
- struct elf32_hppa_dyn_reloc_entry **hdh_head;
+ struct elf_dyn_relocs *hdh_p;
+ struct elf_dyn_relocs **hdh_head;
/* Create a reloc section in dynobj and make room for
this reloc. */
sr = sec;
vpp = &elf_section_data (sr)->local_dynrel;
- hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
+ hdh_head = (struct elf_dyn_relocs **) vpp;
}
hdh_p = *hdh_head;
hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
if (hdh_p == NULL)
return FALSE;
- hdh_p->hdh_next = *hdh_head;
+ hdh_p->next = *hdh_head;
*hdh_head = hdh_p;
hdh_p->sec = sec;
hdh_p->count = 0;
#if RELATIVE_DYNRELOCS
- hdh_p->relative_count = 0;
+ hdh_p->pc_count = 0;
#endif
}
hdh_p->count += 1;
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (rtype))
- hdh_p->relative_count += 1;
+ hdh_p->pc_count += 1;
#endif
}
}
readonly_dynrelocs (struct elf_link_hash_entry *eh)
{
struct elf32_hppa_link_hash_entry *hh;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ struct elf_dyn_relocs *hdh_p;
hh = hppa_elf_hash_entry (eh);
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
asection *sec = hdh_p->sec->output_section;
else
eh->plt.offset = (bfd_vma) -1;
+ htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
/* 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. */
BFD_ASSERT (def->root.type == bfd_link_hash_defined);
eh->root.u.def.section = def->root.u.def.section;
eh->root.u.def.value = def->root.u.def.value;
- if (ELIMINATE_COPY_RELOCS)
- eh->non_got_ref = def->non_got_ref;
+ if (def->root.u.def.section == htab->etab.sdynbss
+ || def->root.u.def.section == htab->etab.sdynrelro)
+ hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
return TRUE;
}
if (info->nocopyreloc)
return TRUE;
+ /* If we don't find any dynamic relocs in read-only sections, then
+ we'll be keeping the dynamic relocs and avoiding the copy reloc. */
if (ELIMINATE_COPY_RELOCS
&& !alias_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. */
- return TRUE;
- }
+ return TRUE;
/* We must allocate the symbol in our .dynbss section, which will
become part of the .bss section of the executable. There will be
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 = hppa_link_hash_table (info);
- if (htab == NULL)
- return FALSE;
-
- /* 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;
}
if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
{
+ /* 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. */
srel->size += sizeof (Elf32_External_Rela);
eh->needs_copy = 1;
}
struct elf32_hppa_link_hash_table *htab;
asection *sec;
struct elf32_hppa_link_hash_entry *hh;
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ struct elf_dyn_relocs *hdh_p;
if (eh->root.type == bfd_link_hash_indirect)
return TRUE;
#if RELATIVE_DYNRELOCS
if (SYMBOL_CALLS_LOCAL (info, eh))
{
- struct elf32_hppa_dyn_reloc_entry **hdh_pp;
+ struct elf_dyn_relocs **hdh_pp;
for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
- hdh_p->count -= hdh_p->relative_count;
- hdh_p->relative_count = 0;
+ hdh_p->count -= hdh_p->pc_count;
+ hdh_p->pc_count = 0;
if (hdh_p->count == 0)
- *hdh_pp = hdh_p->hdh_next;
+ *hdh_pp = hdh_p->next;
else
- hdh_pp = &hdh_p->hdh_next;
+ hdh_pp = &hdh_p->next;
}
}
#endif
}
/* Finally, allocate space. */
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
info->flags |= DF_TEXTREL;
info->callbacks->minfo
- (_("%B: dynamic relocation in read-only section `%A'\n"),
- sec->owner, sec);
+ (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
+ sec->owner, eh->root.root.string, sec);
/* Not an error, just cut short the traversal. */
return FALSE;
for (sec = ibfd->sections; sec != NULL; sec = sec->next)
{
- struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ struct elf_dyn_relocs *hdh_p;
- for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *)
+ for (hdh_p = ((struct elf_dyn_relocs *)
elf_section_data (sec)->local_dynrel);
hdh_p != NULL;
- hdh_p = hdh_p->hdh_next)
+ hdh_p = hdh_p->next)
{
if (!bfd_is_abs_section (hdh_p->sec)
&& bfd_is_abs_section (hdh_p->sec->output_section))
if (htab->tls_ldm_got.refcount > 0)
{
/* Allocate 2 got entries and 1 dynamic reloc for
- R_PARISC_TLS_DTPMOD32 relocs. */
+ R_PARISC_TLS_DTPMOD32 relocs. */
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
{
/* xgettext:c-format */
- _bfd_error_handler (_("%B: duplicate export stub %s"),
+ _bfd_error_handler (_("%pB: duplicate export stub %s"),
input_bfd, stub_name);
}
}
{
if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
{
- /* We know we don't have a .plt. If .got is large,
+ /* We know we don't have a .plt. If .got is large,
offset our LTP. */
- if (sec->size > 0x2000)
+ if (sec->size > 0x2000)
gp_val = 0x2000;
}
}
error. */
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): %s fixup for insn %#x is not supported in a non-shared link"),
+ (_("%pB(%pA+%#" PRIx64 "): %s fixup for insn %#x "
+ "is not supported in a non-shared link"),
input_bfd,
input_section,
- offset,
+ (uint64_t) offset,
howto->name,
insn);
}
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+ (_("%pB(%pA+%#" PRIx64 "): cannot reach %s, "
+ "recompile with -ffunction-sections"),
input_bfd,
input_section,
- offset,
+ (uint64_t) offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
bfd_link_pic (info),
&hh->eh))
{
- /* In a non-shared link, adjust_dynamic_symbols
+ /* In a non-shared link, adjust_dynamic_symbol
isn't called for symbols forced local. We
need to write out the plt entry here. */
if ((off & 1) != 0)
bfd_byte *loc = NULL;
int cur_off = off;
- /* The GOT entries have not been initialized yet. Do it
- now, and emit any relocations. If both an IE GOT and a
- GD GOT are necessary, we emit the GD first. */
+ /* The GOT entries have not been initialized yet. Do it
+ now, and emit any relocations. If both an IE GOT and a
+ GD GOT are necessary, we emit the GD first. */
if (indx != 0
|| (bfd_link_pic (info)
}
else
{
- /* If we are not emitting relocations for a
- general dynamic reference, then we must be in a
- static link or an executable link with the
- symbol binding locally. Mark it as belonging
- to module 1, the executable. */
- bfd_put_32 (output_bfd, 1,
+ /* If we are not emitting relocations for a
+ general dynamic reference, then we must be in a
+ static link or an executable link with the
+ symbol binding locally. Mark it as belonging
+ to module 1, the executable. */
+ bfd_put_32 (output_bfd, 1,
htab->etab.sgot->contents + cur_off);
bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
htab->etab.sgot->contents + cur_off + 4);
if (*sym_name == '\0')
sym_name = bfd_section_name (input_bfd, sym_sec);
_bfd_error_handler
- (_("%B:%s has both normal and TLS relocs"),
+ (_("%pB:%s has both normal and TLS relocs"),
input_bfd, sym_name);
}
bfd_set_error (bfd_error_bad_value);
}
if ((tls_type & GOT_TLS_GD)
- && r_type != R_PARISC_TLS_GD21L
- && r_type != R_PARISC_TLS_GD14R)
+ && r_type != R_PARISC_TLS_GD21L
+ && r_type != R_PARISC_TLS_GD14R)
off += 2 * GOT_ENTRY_SIZE;
/* Add the base of the GOT to the relocation value. */
{
_bfd_error_handler
/* xgettext:c-format */
- (_("%B(%A+%#Lx): cannot handle %s for %s"),
+ (_("%pB(%pA+%#" PRIx64 "): cannot handle %s for %s"),
input_bfd,
input_section,
- rela->r_offset,
+ (uint64_t) rela->r_offset,
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
case R_PARISC_TLS_DTPMOD32:
case R_PARISC_TLS_DTPOFF32:
case R_PARISC_TLS_TPREL32:
- return reloc_class_normal;
+ return reloc_class_normal;
}
if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
projects / deliverable / binutils-gdb.git / blobdiff