/* BFD back-end for HP PA-RISC ELF files.
- Copyright (C) 1990-2018 Free Software Foundation, Inc.
+ Copyright (C) 1990-2023 Free Software Foundation, Inc.
Original code by
Center for Software Science
Import stub to call shared library routine from normal object file
(single sub-space version)
- : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
- : ldw RR'lt_ptr+ltoff(%r1),%r21
+ : addil LR'lt_ptr+ltoff,%dp ; get PLT address
+ : ldo RR'lt_ptr+ltoff(%r1),%r22 ;
+ : ldw 0(%r22),%r21 ; get procedure entry point
: bv %r0(%r21)
- : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
+ : ldw 4(%r22),%r19 ; get new dlt value.
Import stub to call shared library routine from shared library
(single sub-space version)
- : addil LR'ltoff,%r19 ; get procedure entry point
- : ldw RR'ltoff(%r1),%r21
+ : addil LR'ltoff,%r19 ; get PLT address
+ : ldo RR'ltoff(%r1),%r22
+ : ldw 0(%r22),%r21 ; get procedure entry point
: bv %r0(%r21)
- : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
+ : ldw 4(%r22),%r19 ; get new dlt value.
Import stub to call shared library routine from normal object file
(multiple sub-space support)
- : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
- : ldw RR'lt_ptr+ltoff(%r1),%r21
- : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
- : ldsid (%r21),%r1
+ : addil LR'lt_ptr+ltoff,%dp ; get PLT address
+ : ldo RR'lt_ptr+ltoff(%r1),%r22 ;
+ : ldw 0(%r22),%r21 ; get procedure entry point
+ : ldsid (%r21),%r1 ; get target sid
+ : ldw 4(%r22),%r19 ; get new dlt value.
: mtsp %r1,%sr0
: be 0(%sr0,%r21) ; branch to target
: stw %rp,-24(%sp) ; save rp
Import stub to call shared library routine from shared library
(multiple sub-space support)
- : addil LR'ltoff,%r19 ; get procedure entry point
- : ldw RR'ltoff(%r1),%r21
- : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
- : ldsid (%r21),%r1
+ : addil LR'ltoff,%r19 ; get PLT address
+ : ldo RR'ltoff(%r1),%r22
+ : ldw 0(%r22),%r21 ; get procedure entry point
+ : ldsid (%r21),%r1 ; get target sid
+ : ldw 4(%r22),%r19 ; get new dlt value.
: mtsp %r1,%sr0
: be 0(%sr0,%r21) ; branch to target
: stw %rp,-24(%sp) ; save rp
#define PLT_ENTRY_SIZE 8
#define GOT_ENTRY_SIZE 4
+#define LONG_BRANCH_STUB_SIZE 8
+#define LONG_BRANCH_SHARED_STUB_SIZE 12
+#define IMPORT_STUB_SIZE 20
+#define IMPORT_SHARED_STUB_SIZE 32
+#define EXPORT_STUB_SIZE 24
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
static const bfd_byte plt_stub[] =
{
- 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
- 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
+ 0x0e, 0x80, 0x10, 0x95, /* 1: ldw 0(%r20),%r21 */
+ 0xea, 0xa0, 0xc0, 0x00, /* bv %r0(%r21) */
0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
#define PLT_STUB_ENTRY (3*4)
0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
symbol. */
struct elf32_hppa_stub_hash_entry *hsh_cache;
- /* Used to count relocations for delayed sizing of relocation
- sections. */
- struct elf_dyn_relocs *dyn_relocs;
-
ENUM_BITFIELD (_tls_type) tls_type : 8;
/* Set if this symbol is used by a plabel reloc. */
/* Set if we need a .plt stub to support lazy dynamic linking. */
unsigned int need_plt_stub:1;
- /* Small local sym cache. */
- struct sym_cache sym_cache;
-
/* Data for LDM relocations. */
union
{
/* Various hash macros and functions. */
#define hppa_link_hash_table(p) \
- (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
- == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
+ ((is_elf_hash_table ((p)->hash) \
+ && elf_hash_table_id (elf_hash_table (p)) == HPPA32_ELF_DATA) \
+ ? (struct elf32_hppa_link_hash_table *) (p)->hash : NULL)
#define hppa_elf_hash_entry(ent) \
((struct elf32_hppa_link_hash_entry *)(ent))
/* Initialize the local fields. */
hh = hppa_elf_hash_entry (entry);
hh->hsh_cache = NULL;
- hh->dyn_relocs = NULL;
hh->plabel = 0;
hh->tls_type = GOT_UNKNOWN;
}
elf32_hppa_link_hash_table_create (bfd *abfd)
{
struct elf32_hppa_link_hash_table *htab;
- bfd_size_type amt = sizeof (*htab);
+ size_t amt = sizeof (*htab);
htab = bfd_zmalloc (amt);
if (htab == NULL)
return NULL;
}
htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;
+ htab->etab.dt_pltgot_required = true;
htab->text_segment_base = (bfd_vma) -1;
htab->data_segment_base = (bfd_vma) -1;
return NULL;
hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
- stub_name, FALSE, FALSE);
+ stub_name, false, false);
if (hh != NULL)
hh->hsh_cache = hsh_entry;
/* Enter this entry into the linker stub hash table. */
hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
- TRUE, FALSE);
+ true, false);
if (hsh == NULL)
{
/* xgettext:c-format */
#define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
#define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
+#define LDO_R1_R22 0x34360000 /* ldo RR'XXX(%r1),%r22 */
+#define LDW_R22_R21 0x0ec01095 /* ldw 0(%r22),%r21 */
+#define LDW_R22_R19 0x0ec81093 /* ldw 4(%r22),%r19 */
+
#define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
#define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
#define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
#define LDW_R1_DLT LDW_R1_DP
#endif
-static bfd_boolean
+static bool
hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
{
struct elf32_hppa_stub_hash_entry *hsh;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
stub_sec = hsh->stub_sec;
switch (hsh->stub_type)
{
case hppa_stub_long_branch:
+ /* Fail if the target section could not be assigned to an output
+ section. The user should fix his linker script. */
+ if (hsh->target_section->output_section == NULL
+ && info->non_contiguous_regions)
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
+ "section. Retry without "
+ "--enable-non-contiguous-regions.\n"),
+ hsh->target_section);
+
/* Create the long branch. A long branch is formed with "ldil"
loading the upper bits of the target address into a register,
then branching with "be" which adds in the lower bits.
insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
bfd_put_32 (stub_bfd, insn, loc + 4);
- size = 8;
+ size = LONG_BRANCH_STUB_SIZE;
break;
case hppa_stub_long_branch_shared:
+ /* Fail if the target section could not be assigned to an output
+ section. The user should fix his linker script. */
+ if (hsh->target_section->output_section == NULL
+ && info->non_contiguous_regions)
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
+ "section. Retry without "
+ "--enable-non-contiguous-regions.\n"),
+ hsh->target_section);
+
/* Branches are relative. This is where we are going to. */
sym_value = (hsh->target_value
+ hsh->target_section->output_offset
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
bfd_put_32 (stub_bfd, insn, loc + 8);
- size = 12;
+ size = LONG_BRANCH_SHARED_STUB_SIZE;
break;
case hppa_stub_import:
if (hsh->stub_type == hppa_stub_import_shared)
insn = ADDIL_R19;
#endif
+
+ /* Load function descriptor address into register %r22. It is
+ sometimes needed for lazy binding. */
val = hppa_field_adjust (sym_value, 0, e_lrsel),
insn = hppa_rebuild_insn ((int) insn, val, 21);
bfd_put_32 (stub_bfd, insn, loc);
- /* It is critical to use lrsel/rrsel here because we are using
- two different offsets (+0 and +4) from sym_value. If we use
- lsel/rsel then with unfortunate sym_values we will round
- sym_value+4 up to the next 2k block leading to a mis-match
- between the lsel and rsel value. */
val = hppa_field_adjust (sym_value, 0, e_rrsel);
- insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
+ insn = hppa_rebuild_insn ((int) LDO_R1_R22, val, 14);
bfd_put_32 (stub_bfd, insn, loc + 4);
+ bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R21, loc + 8);
+
if (htab->multi_subspace)
{
- val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
- insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
- bfd_put_32 (stub_bfd, insn, loc + 8);
-
bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
- bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
- bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 20);
- bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 24);
+ bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19, loc + 16);
+ bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 20);
+ bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 24);
+ bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 28);
- size = 28;
+ size = IMPORT_SHARED_STUB_SIZE;
}
else
{
- bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
- val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
- insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
- bfd_put_32 (stub_bfd, insn, loc + 12);
+ bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 12);
+ bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19, loc + 16);
- size = 16;
+ size = IMPORT_STUB_SIZE;
}
break;
case hppa_stub_export:
+ /* Fail if the target section could not be assigned to an output
+ section. The user should fix his linker script. */
+ if (hsh->target_section->output_section == NULL
+ && info->non_contiguous_regions)
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
+ "section. Retry without "
+ "--enable-non-contiguous-regions.\n"),
+ hsh->target_section);
+
/* Branches are relative. This is where we are going to. */
sym_value = (hsh->target_value
+ hsh->target_section->output_offset
(uint64_t) hsh->stub_offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
hsh->hh->eh.root.u.def.section = stub_sec;
hsh->hh->eh.root.u.def.value = stub_sec->size;
- size = 24;
+ size = EXPORT_STUB_SIZE;
break;
default:
BFD_FAIL ();
- return FALSE;
+ return false;
}
stub_sec->size += size;
- return TRUE;
+ return true;
}
#undef LDIL_R1
/* As above, but don't actually build the stub. Just bump offset so
we know stub section sizes. */
-static bfd_boolean
+static bool
hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
{
struct elf32_hppa_stub_hash_entry *hsh;
htab = in_arg;
if (hsh->stub_type == hppa_stub_long_branch)
- size = 8;
+ size = LONG_BRANCH_STUB_SIZE;
else if (hsh->stub_type == hppa_stub_long_branch_shared)
- size = 12;
+ size = LONG_BRANCH_SHARED_STUB_SIZE;
else if (hsh->stub_type == hppa_stub_export)
- size = 24;
+ size = EXPORT_STUB_SIZE;
else /* hppa_stub_import or hppa_stub_import_shared. */
{
if (htab->multi_subspace)
- size = 28;
+ size = IMPORT_SHARED_STUB_SIZE;
else
- size = 16;
+ size = IMPORT_STUB_SIZE;
}
hsh->stub_sec->size += size;
- return TRUE;
+ return true;
}
/* Return nonzero if ABFD represents an HPPA ELF32 file.
Additionally we set the default architecture and machine. */
-static bfd_boolean
+static bool
elf32_hppa_object_p (bfd *abfd)
{
Elf_Internal_Ehdr * i_ehdrp;
but the kernel produces corefiles with OSABI=SysV. */
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU &&
i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
- return FALSE;
+ return false;
}
else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
{
but the kernel produces corefiles with OSABI=SysV. */
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
- return FALSE;
+ return false;
}
else
{
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
- return FALSE;
+ return false;
}
flags = i_ehdrp->e_flags;
case EFA_PARISC_2_0 | EF_PARISC_WIDE:
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
}
- return TRUE;
+ return true;
}
/* Create the .plt and .got sections, and set up our hash table
short-cuts to various dynamic sections. */
-static bfd_boolean
+static bool
elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
{
struct elf32_hppa_link_hash_table *htab;
/* Don't try to create the .plt and .got twice. */
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
if (htab->etab.splt != NULL)
- return TRUE;
+ return true;
/* Call the generic code to do most of the work. */
if (! _bfd_elf_create_dynamic_sections (abfd, info))
- return FALSE;
+ return false;
/* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
application, because __canonicalize_funcptr_for_compare needs it. */
hh_dir = hppa_elf_hash_entry (eh_dir);
hh_ind = hppa_elf_hash_entry (eh_ind);
- if (hh_ind->dyn_relocs != NULL
- && eh_ind->root.type == bfd_link_hash_indirect)
- {
- if (hh_dir->dyn_relocs != NULL)
- {
- 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 elf_dyn_relocs *hdh_q;
-
- for (hdh_q = hh_dir->dyn_relocs;
- hdh_q != NULL;
- hdh_q = hdh_q->next)
- if (hdh_q->sec == hdh_p->sec)
- {
-#if RELATIVE_DYNRELOCS
- hdh_q->pc_count += hdh_p->pc_count;
-#endif
- hdh_q->count += hdh_p->count;
- *hdh_pp = hdh_p->next;
- break;
- }
- if (hdh_q == NULL)
- hdh_pp = &hdh_p->next;
- }
- *hdh_pp = hh_dir->dyn_relocs;
- }
-
- hh_dir->dyn_relocs = hh_ind->dyn_relocs;
- hh_ind->dyn_relocs = NULL;
- }
-
if (eh_ind->root.type == bfd_link_hash_indirect)
{
hh_dir->plabel |= hh_ind->plabel;
table, and dynamic reloc sections. At this point we haven't
necessarily read all the input files. */
-static bfd_boolean
+static bool
elf32_hppa_check_relocs (bfd *abfd,
struct bfd_link_info *info,
asection *sec,
asection *sreloc;
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
eh_syms = elf_sym_hashes (abfd);
sreloc = NULL;
abfd,
elf_hppa_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
/* Fall through. */
Reconstruct it for later use during GC. */
case R_PARISC_GNU_VTINHERIT:
if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
- return FALSE;
+ return false;
continue;
/* This relocation describes which C++ vtable entries are actually
used. Record for later use during GC. */
case R_PARISC_GNU_VTENTRY:
- BFD_ASSERT (hh != NULL);
- if (hh != NULL
- && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
- return FALSE;
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
+ return false;
continue;
case R_PARISC_TLS_GD21L:
if (htab->etab.sgot == NULL)
{
if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
- return FALSE;
+ return false;
}
if (hh != NULL)
/* 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;
+ return false;
if (tls_type == GOT_TLS_LDM)
htab->tls_ldm_got.refcount += 1;
else
local_got_refcounts = hppa32_elf_local_refcounts (abfd);
if (local_got_refcounts == NULL)
- return FALSE;
+ return false;
local_plt_refcounts = (local_got_refcounts
+ symtab_hdr->sh_info);
local_plt_refcounts[r_symndx] += 1;
if (sreloc == NULL)
{
sreloc = _bfd_elf_make_dynamic_reloc_section
- (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
+ (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ true);
if (sreloc == NULL)
{
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
relocations we need for this symbol. */
if (hh != NULL)
{
- hdh_head = &hh->dyn_relocs;
+ hdh_head = &hh->eh.dyn_relocs;
}
else
{
void *vpp;
Elf_Internal_Sym *isym;
- isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ isym = bfd_sym_from_r_symndx (&htab->etab.sym_cache,
abfd, r_symndx);
if (isym == NULL)
- return FALSE;
+ return false;
sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
if (sr == NULL)
{
hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
if (hdh_p == NULL)
- return FALSE;
+ return false;
hdh_p->next = *hdh_head;
*hdh_head = hdh_p;
hdh_p->sec = sec;
}
}
- return TRUE;
+ return true;
}
/* Return the section that should be marked against garbage collection
/* Support for core dump NOTE sections. */
-static bfd_boolean
+static bool
elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 396: /* Linux/hppa */
/* pr_cursig */
size, note->descpos + offset);
}
-static bfd_boolean
+static bool
elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
switch (note->descsz)
{
default:
- return FALSE;
+ return false;
case 124: /* Linux/hppa elf_prpsinfo. */
elf_tdata (abfd)->core->program
command[n - 1] = '\0';
}
- return TRUE;
+ return true;
}
/* Our own version of hide_symbol, so that we can keep plt entries for
static void
elf32_hppa_hide_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *eh,
- bfd_boolean force_local)
+ bool force_local)
{
if (force_local)
{
}
}
-/* 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 elf_dyn_relocs *hdh_p;
-
- hh = hppa_elf_hash_entry (eh);
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
- {
- asection *sec = hdh_p->sec->output_section;
-
- if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
- return hdh_p->sec;
- }
- return NULL;
-}
-
/* Return true if we have dynamic relocs against H or any of its weak
aliases, that apply to read-only sections. Cannot be used after
size_dynamic_sections. */
-static bfd_boolean
+static bool
alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
{
struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
do
{
- if (readonly_dynrelocs (&hh->eh))
- return TRUE;
+ if (_bfd_elf_readonly_dynrelocs (&hh->eh))
+ return true;
hh = hppa_elf_hash_entry (hh->eh.u.alias);
} while (hh != NULL && &hh->eh != eh);
- return FALSE;
+ return false;
}
/* Adjust a symbol defined by a dynamic object and referenced by a
change the definition to something the rest of the link can
understand. */
-static bfd_boolean
+static bool
elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
struct elf_link_hash_entry *eh)
{
if (eh->type == STT_FUNC
|| eh->needs_plt)
{
- bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
- || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
+ bool local = (SYMBOL_CALLS_LOCAL (info, eh)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
/* Discard dyn_relocs when non-pic if we've decided that a
function symbol is local. */
if (!bfd_link_pic (info) && local)
- hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
/* 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
be discarded. */
/* Function symbols can't have copy relocs. */
- return TRUE;
+ return true;
}
else
eh->plt.offset = (bfd_vma) -1;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ 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
eh->root.u.def.value = def->root.u.def.value;
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;
+ eh->dyn_relocs = NULL;
+ return true;
}
/* This is a reference to a symbol defined by a dynamic object which
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
if (bfd_link_pic (info))
- return TRUE;
+ 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 (!eh->non_got_ref)
- return TRUE;
+ return true;
/* If -z nocopyreloc was given, we won't generate them either. */
if (info->nocopyreloc)
- return TRUE;
+ 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))
- 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
}
/* We no longer want dyn_relocs. */
- hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
}
/* If EH is undefined, make it dynamic if that makes sense. */
-static bfd_boolean
+static bool
ensure_undef_dynamic (struct bfd_link_info *info,
struct elf_link_hash_entry *eh)
{
&& !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
&& ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
return bfd_elf_link_record_dynamic_symbol (info, eh);
- return TRUE;
+ return true;
}
/* Allocate space in the .plt for entries that won't have relocations.
ie. plabel entries. */
-static bfd_boolean
+static bool
allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
{
struct bfd_link_info *info;
asection *sec;
if (eh->root.type == bfd_link_hash_indirect)
- return TRUE;
+ return true;
info = (struct bfd_link_info *) inf;
hh = hppa_elf_hash_entry (eh);
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
if (htab->etab.dynamic_sections_created
&& eh->plt.refcount > 0)
{
if (!ensure_undef_dynamic (info, eh))
- return FALSE;
+ return false;
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
{
eh->needs_plt = 0;
}
- return TRUE;
+ return true;
}
/* Calculate size of GOT entries for symbol given its TLS_TYPE. */
static inline unsigned int
got_relocs_needed (int tls_type, unsigned int need,
- bfd_boolean dtprel_known, bfd_boolean tprel_known)
+ bool dtprel_known, bool tprel_known)
{
/* All the entries we allocated need relocs.
Except for GD and IE with local symbols. */
/* Allocate space in .plt, .got and associated reloc sections for
global syms. */
-static bfd_boolean
+static bool
allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
{
struct bfd_link_info *info;
struct elf_dyn_relocs *hdh_p;
if (eh->root.type == bfd_link_hash_indirect)
- return TRUE;
+ return true;
info = inf;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
hh = hppa_elf_hash_entry (eh);
unsigned int need;
if (!ensure_undef_dynamic (info, eh))
- return FALSE;
+ return false;
sec = htab->etab.sgot;
eh->got.offset = sec->size;
&& !SYMBOL_REFERENCES_LOCAL (info, eh)))
&& !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);
+ bool local = SYMBOL_REFERENCES_LOCAL (info, eh);
htab->etab.srelgot->size
+= got_relocs_needed (hh->tls_type, need, local,
local && bfd_link_executable (info));
/* If no dynamic sections we can't have dynamic relocs. */
if (!htab->etab.dynamic_sections_created)
- hh->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
/* Discard relocs on undefined syms with non-default visibility. */
else 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;
+ eh->dyn_relocs = NULL;
- if (hh->dyn_relocs == NULL)
- return TRUE;
+ if (eh->dyn_relocs == NULL)
+ return true;
/* If this is a -Bsymbolic shared link, then we need to discard all
space allocated for dynamic pc-relative relocs against symbols
{
struct elf_dyn_relocs **hdh_pp;
- for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
+ for (hdh_pp = &eh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
hdh_p->count -= hdh_p->pc_count;
hdh_p->pc_count = 0;
}
#endif
- if (hh->dyn_relocs != NULL)
+ if (eh->dyn_relocs != NULL)
{
if (!ensure_undef_dynamic (info, eh))
- return FALSE;
+ return false;
}
}
else if (ELIMINATE_COPY_RELOCS)
&& !ELF_COMMON_DEF_P (eh))
{
if (!ensure_undef_dynamic (info, eh))
- return FALSE;
+ return false;
if (eh->dynindx == -1)
- hh->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
}
else
- hh->dyn_relocs = NULL;
+ eh->dyn_relocs = NULL;
}
/* Finally, allocate space. */
- for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
+ for (hdh_p = eh->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);
}
- return TRUE;
+ return true;
}
/* This function is called via elf_link_hash_traverse to force
for all dynamic symbols. Arguably, this is a bug in
elf_adjust_dynamic_symbol. */
-static bfd_boolean
+static bool
clobber_millicode_symbols (struct elf_link_hash_entry *eh,
- struct bfd_link_info *info)
+ void *info)
{
if (eh->type == STT_PARISC_MILLI
&& !eh->forced_local)
- {
- elf32_hppa_hide_symbol (info, eh, TRUE);
- }
- return TRUE;
-}
-
-/* Set DF_TEXTREL if we find any dynamic relocs that apply to
- read-only sections. */
-
-static bfd_boolean
-maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
-{
- asection *sec;
-
- if (eh->root.type == bfd_link_hash_indirect)
- return TRUE;
-
- sec = readonly_dynrelocs (eh);
- if (sec != NULL)
- {
- struct bfd_link_info *info = (struct bfd_link_info *) inf;
-
- info->flags |= DF_TEXTREL;
- info->callbacks->minfo
- (_("%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;
- }
- return TRUE;
+ elf32_hppa_hide_symbol ((struct bfd_link_info *) info, eh, true);
+ return true;
}
/* Set the sizes of the dynamic sections. */
-static bfd_boolean
+static bool
elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info)
{
bfd *dynobj;
bfd *ibfd;
asection *sec;
- bfd_boolean relocs;
+ bool relocs;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
dynobj = htab->etab.dynobj;
if (dynobj == NULL)
|| (bfd_link_pic (info)
&& (*local_tls_type & GOT_NORMAL) != 0))
htab->etab.srelgot->size
- += got_relocs_needed (*local_tls_type, need, TRUE,
+ += got_relocs_needed (*local_tls_type, need, true,
bfd_link_executable (info));
}
else
/* The check_relocs and adjust_dynamic_symbol entry points have
determined the sizes of the various dynamic sections. Allocate
memory for them. */
- relocs = FALSE;
+ relocs = false;
for (sec = dynobj->sections; sec != NULL; sec = sec->next)
{
if ((sec->flags & SEC_LINKER_CREATED) == 0)
/* 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->etab.sgot);
- int pltalign = bfd_section_alignment (dynobj, sec);
+ int gotalign = bfd_section_alignment (htab->etab.sgot);
+ int pltalign = bfd_section_alignment (sec);
+ int align = gotalign > 3 ? gotalign : 3;
bfd_size_type mask;
- if (gotalign > pltalign)
- (void) bfd_set_section_alignment (dynobj, sec, gotalign);
+ if (align > pltalign)
+ bfd_set_section_alignment (sec, align);
mask = ((bfd_size_type) 1 << gotalign) - 1;
sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
}
|| sec == htab->etab.sdynbss
|| sec == htab->etab.sdynrelro)
;
- else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
+ else if (startswith (bfd_section_name (sec), ".rela"))
{
if (sec->size != 0)
{
/* Remember whether there are any reloc sections other
than .rela.plt. */
if (sec != htab->etab.srelplt)
- relocs = TRUE;
+ relocs = true;
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
we may not fill in all the reloc sections. */
sec->contents = bfd_zalloc (dynobj, sec->size);
if (sec->contents == NULL)
- return FALSE;
+ return false;
}
- if (htab->etab.dynamic_sections_created)
- {
- /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
- actually has nothing to do with the PLT, it is how we
- communicate the LTP value of a load module to the dynamic
- linker. */
-#define add_dynamic_entry(TAG, VAL) \
- _bfd_elf_add_dynamic_entry (info, TAG, VAL)
-
- if (!add_dynamic_entry (DT_PLTGOT, 0))
- return FALSE;
-
- /* Add some entries to the .dynamic section. We fill in the
- values later, in elf32_hppa_finish_dynamic_sections, but we
- must add the entries now so that we get the correct size for
- the .dynamic section. The DT_DEBUG entry is filled in by the
- dynamic linker and used by the debugger. */
- if (bfd_link_executable (info))
- {
- if (!add_dynamic_entry (DT_DEBUG, 0))
- return FALSE;
- }
-
- if (htab->etab.srelplt->size != 0)
- {
- if (!add_dynamic_entry (DT_PLTRELSZ, 0)
- || !add_dynamic_entry (DT_PLTREL, DT_RELA)
- || !add_dynamic_entry (DT_JMPREL, 0))
- return FALSE;
- }
-
- if (relocs)
- {
- if (!add_dynamic_entry (DT_RELA, 0)
- || !add_dynamic_entry (DT_RELASZ, 0)
- || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
- return FALSE;
-
- /* 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, maybe_set_textrel, info);
-
- if ((info->flags & DF_TEXTREL) != 0)
- {
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- }
- }
- }
-#undef add_dynamic_entry
-
- return TRUE;
+ return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);
}
/* External entry points for sizing and building linker stubs. */
unsigned int top_id, top_index;
asection *section;
asection **input_list, **list;
- bfd_size_type amt;
+ size_t amt;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
if (htab == NULL)
static void
group_sections (struct elf32_hppa_link_hash_table *htab,
bfd_size_type stub_group_size,
- bfd_boolean stubs_always_before_branch)
+ bool stubs_always_before_branch)
{
asection **list = htab->input_list + htab->top_index;
do
asection *curr;
asection *prev;
bfd_size_type total;
- bfd_boolean big_sec;
+ bool big_sec;
curr = tail;
total = tail->size;
/* We want to read in symbol extension records only once. To do this
we need to read in the local symbols in parallel and save them for
later use; so hold pointers to the local symbols in an array. */
- bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
+ size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
all_local_syms = bfd_zmalloc (amt);
htab->all_local_syms = all_local_syms;
if (all_local_syms == NULL)
stub_name = hh_name (hh);
hsh = hppa_stub_hash_lookup (&htab->bstab,
stub_name,
- FALSE, FALSE);
+ false, false);
if (hsh == NULL)
{
hsh = hppa_add_stub (stub_name, sec, htab);
PC-relative calls to a target that is unreachable with a "bl"
instruction. */
-bfd_boolean
+bool
elf32_hppa_size_stubs
(bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
- bfd_boolean multi_subspace, bfd_signed_vma group_size,
+ bool multi_subspace, bfd_signed_vma group_size,
asection * (*add_stub_section) (const char *, asection *),
void (*layout_sections_again) (void))
{
bfd_size_type stub_group_size;
- bfd_boolean stubs_always_before_branch;
- bfd_boolean stub_changed;
+ bool stubs_always_before_branch;
+ bool stub_changed;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
/* Stash our params away. */
htab->stub_bfd = stub_bfd;
default:
if (htab->all_local_syms)
goto error_ret_free_local;
- return FALSE;
+ return false;
case 0:
- stub_changed = FALSE;
+ stub_changed = false;
break;
case 1:
- stub_changed = TRUE;
+ stub_changed = true;
break;
}
hsh = hppa_stub_hash_lookup (&htab->bstab,
stub_name,
- FALSE, FALSE);
+ false, false);
if (hsh != NULL)
{
/* The proper stub has already been created. */
hsh->stub_type = hppa_stub_long_branch_shared;
}
hsh->hh = hh;
- stub_changed = TRUE;
+ stub_changed = true;
}
/* We're done with the internal relocs, free them. */
/* Ask the linker to do its stuff. */
(*htab->layout_sections_again) ();
- stub_changed = FALSE;
+ stub_changed = false;
}
free (htab->all_local_syms);
- return TRUE;
+ return true;
error_ret_free_local:
free (htab->all_local_syms);
- return FALSE;
+ return false;
}
/* For a final link, this function is called after we have sized the
stubs to provide a value for __gp. */
-bfd_boolean
+bool
elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
{
struct bfd_link_hash_entry *h;
asection *sec = NULL;
bfd_vma gp_val = 0;
- h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
+ h = bfd_link_hash_lookup (info->hash, "$global$", false, false, false);
if (h != NULL
&& (h->type == bfd_link_hash_defined
elf_gp (abfd) = gp_val;
}
- return TRUE;
+ return true;
}
/* Build all the stubs associated with the current output file. The
functions here. This function is called via hppaelf_finish in the
linker. */
-bfd_boolean
+bool
elf32_hppa_build_stubs (struct bfd_link_info *info)
{
asection *stub_sec;
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
/* Allocate memory to hold the linker stubs. */
stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
if (stub_sec->contents == NULL)
- return FALSE;
+ return false;
stub_sec->size = 0;
}
table = &htab->bstab;
bfd_hash_traverse (table, hppa_build_one_stub, info);
- return TRUE;
+ return true;
}
/* Return the base vma address which should be subtracted from the real
/* Perform a final link. */
-static bfd_boolean
+static bool
elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
{
struct stat buf;
/* Invoke the regular ELF linker to do all the work. */
if (!bfd_elf_final_link (abfd, info))
- return FALSE;
+ return false;
/* If we're producing a final executable, sort the contents of the
unwind section. */
if (bfd_link_relocatable (info))
- return TRUE;
+ return true;
/* Do not attempt to sort non-regular files. This is here
especially for configure scripts and kernel builds which run
tests with "ld [...] -o /dev/null". */
- if (stat (abfd->filename, &buf) != 0
+ if (stat (bfd_get_filename (abfd), &buf) != 0
|| !S_ISREG(buf.st_mode))
- return TRUE;
+ return true;
return elf_hppa_sort_unwind (abfd);
}
struct elf32_hppa_link_hash_entry *hh,
struct bfd_link_info *info)
{
- int insn;
+ unsigned int insn;
unsigned int r_type = ELF32_R_TYPE (rela->r_info);
unsigned int orig_r_type = r_type;
reloc_howto_type *howto = elf_hppa_howto_table + r_type;
/* GCC sometimes uses a register other than r19 for the
operation, so we must convert any addil instruction
that uses this relocation. */
- if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26))
+ if ((insn & 0xfc000000) == OP_ADDIL << 26)
insn = ADDIL_DP;
else
/* We must have a ldil instruction. It's too hard to find
instance: "extern int foo" with foo defined as "const int foo". */
if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
{
- if ((insn & ((0x3f << 26) | (0x1f << 21)))
- == (((int) OP_ADDIL << 26) | (27 << 21)))
+ if ((insn & ((0x3fu << 26) | (0x1f << 21)))
+ == ((OP_ADDIL << 26) | (27 << 21)))
{
insn &= ~ (0x1f << 21);
}
/* Relocate an HPPA ELF section. */
-static bfd_boolean
+static int
elf32_hppa_relocate_section (bfd *output_bfd,
struct bfd_link_info *info,
bfd *input_bfd,
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
local_got_offsets = elf_local_got_offsets (input_bfd);
bfd_vma relocation;
bfd_reloc_status_type rstatus;
const char *sym_name;
- bfd_boolean plabel;
- bfd_boolean warned_undef;
+ bool plabel;
+ bool warned_undef;
r_type = ELF32_R_TYPE (rela->r_info);
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
{
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
|| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
hh = NULL;
sym = NULL;
sym_sec = NULL;
- warned_undef = FALSE;
+ warned_undef = false;
if (r_symndx < symtab_hdr->sh_info)
{
/* This is a local symbol, h defaults to NULL. */
else
{
struct elf_link_hash_entry *eh;
- bfd_boolean unresolved_reloc, ignored;
+ bool unresolved_reloc, ignored;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
{
(*info->callbacks->undefined_symbol)
(info, eh_name (eh), input_bfd,
- input_section, rela->r_offset, FALSE);
- warned_undef = TRUE;
+ input_section, rela->r_offset, false);
+ warned_undef = true;
}
}
hh = hppa_elf_hash_entry (eh);
case R_PARISC_DLTIND21L:
{
bfd_vma off;
- bfd_boolean do_got = FALSE;
- bfd_boolean reloc = bfd_link_pic (info);
+ bool do_got = false;
+ bool reloc = bfd_link_pic (info);
/* Relocation is to the entry for this symbol in the
global offset table. */
if (hh != NULL)
{
- bfd_boolean dyn;
+ bool dyn;
off = hh->eh.got.offset;
dyn = htab->etab.dynamic_sections_created;
else
{
hh->eh.got.offset |= 1;
- do_got = TRUE;
+ do_got = true;
}
}
}
else
{
local_got_offsets[r_symndx] |= 1;
- do_got = TRUE;
+ do_got = true;
}
}
if (htab->etab.dynamic_sections_created)
{
bfd_vma off;
- bfd_boolean do_plt = 0;
+ bool do_plt = 0;
/* If we have a global symbol with a PLT slot, then
redirect this relocation to it. */
if (hh != NULL)
if (bfd_link_pic (info)
? ((hh == NULL
- || hh->dyn_relocs != NULL)
+ || hh->eh.dyn_relocs != NULL)
&& ((hh != NULL && pc_dynrelocs (hh))
|| IS_ABSOLUTE_RELOC (r_type)))
: (hh != NULL
- && hh->dyn_relocs != NULL))
+ && hh->eh.dyn_relocs != NULL))
{
Elf_Internal_Rela outrel;
- bfd_boolean skip;
+ bool skip;
asection *sreloc;
bfd_byte *loc;
off &= ~1;
else
{
- bfd_boolean need_relocs = FALSE;
+ bool need_relocs = false;
Elf_Internal_Rela outrel;
bfd_byte *loc = NULL;
int cur_off = off;
&& (hh == NULL
|| !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
{
- need_relocs = TRUE;
+ need_relocs = true;
loc = htab->etab.srelgot->contents;
loc += (htab->etab.srelgot->reloc_count
* sizeof (Elf32_External_Rela));
else
{
Elf_Internal_Sym *isym
- = bfd_sym_from_r_symndx (&htab->sym_cache,
+ = bfd_sym_from_r_symndx (&htab->etab.sym_cache,
input_bfd, r_symndx);
if (isym == NULL)
- return FALSE;
+ 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;
+ return false;
if (*sym_name == '\0')
- sym_name = bfd_section_name (input_bfd, sym_sec);
+ sym_name = bfd_section_name (sym_sec);
_bfd_error_handler
(_("%pB:%s has both normal and TLS relocs"),
input_bfd, sym_name);
}
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
if ((tls_type & GOT_TLS_GD)
symtab_hdr->sh_link,
sym->st_name);
if (sym_name == NULL)
- return FALSE;
+ return false;
if (*sym_name == '\0')
- sym_name = bfd_section_name (input_bfd, sym_sec);
+ sym_name = bfd_section_name (sym_sec);
}
howto = elf_hppa_howto_table + r_type;
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
else
(bfd_vma) 0, input_bfd, input_section, rela->r_offset);
}
- return TRUE;
+ return true;
}
/* Finish up dynamic symbol handling. We set the contents of various
dynamic sections here. */
-static bfd_boolean
+static bool
elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
struct bfd_link_info *info,
struct elf_link_hash_entry *eh,
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
if (eh->plt.offset != (bfd_vma) -1)
{
&& (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
&& !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- bfd_boolean is_dyn = (eh->dynindx != -1
- && !SYMBOL_REFERENCES_LOCAL (info, eh));
+ bool is_dyn = (eh->dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, eh));
if (is_dyn || bfd_link_pic (info))
{
sym->st_shndx = SHN_ABS;
}
- return TRUE;
+ return true;
}
/* Used to decide how to sort relocs in an optimal manner for the
/* Finish up the dynamic sections. */
-static bfd_boolean
+static bool
elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
struct bfd_link_info *info)
{
htab = hppa_link_hash_table (info);
if (htab == NULL)
- return FALSE;
+ return false;
dynobj = htab->etab.dynobj;
/* 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))
- return FALSE;
+ return false;
sdyn = bfd_get_linker_section (dynobj, ".dynamic");
{
_bfd_error_handler
(_(".got section not immediately after .plt section"));
- return FALSE;
+ return false;
}
}
}
- return TRUE;
+ return true;
}
/* Called when writing out an object file to decide the type of a
projects / thirdparty / binutils-gdb.git / blobdiff