/* BFD back-end for HP PA-RISC ELF files.
- Copyright (C) 1990-2020 Free Software Foundation, Inc.
+ Copyright (C) 1990-2023 Free Software Foundation, Inc.
Original code by
Center for Software Science
/* 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))
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 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;
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 "
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
"section. Retry without "
"--enable-non-contiguous-regions.\n"),
hsh->target_section);
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 "
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
"section. Retry without "
"--enable-non-contiguous-regions.\n"),
hsh->target_section);
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 "
+ info->callbacks->einfo (_("%F%P: Could not assign `%pA' to an output "
"section. Retry without "
"--enable-non-contiguous-regions.\n"),
hsh->target_section);
(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;
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;
}
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. */
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:
if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
- return FALSE;
+ 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;
}
}
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)
{
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 (_bfd_elf_readonly_dynrelocs (&hh->eh))
- return TRUE;
+ 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)
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
if (def->root.u.def.section == htab->etab.sdynbss
|| def->root.u.def.section == htab->etab.sdynrelro)
eh->dyn_relocs = NULL;
- return TRUE;
+ 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
/* 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));
eh->dyn_relocs = NULL;
if (eh->dyn_relocs == NULL)
- return TRUE;
+ return true;
/* If this is a -Bsymbolic shared link, then we need to discard all
space allocated for dynamic pc-relative relocs against symbols
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)
eh->dyn_relocs = NULL;
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;
+ 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)
|| sec == htab->etab.sdynbss
|| sec == htab->etab.sdynrelro)
;
- else if (CONST_STRNEQ (bfd_section_name (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;
- }
-
- 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,
- _bfd_elf_maybe_set_textrel, info);
-
- if ((info->flags & DF_TEXTREL) != 0)
- {
- if (!add_dynamic_entry (DT_TEXTREL, 0))
- return FALSE;
- }
- }
+ 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. */
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;
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 (bfd_get_filename (abfd), &buf) != 0
|| !S_ISREG(buf.st_mode))
- return TRUE;
+ return true;
return elf_hppa_sort_unwind (abfd);
}
/* 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)
&& 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 (sym_sec);
_bfd_error_handler
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 (sym_sec);
}
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