/* Support for HPPA 64-bit ELF
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+ 2010, 2011, 2012
Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
MA 02110-1301, USA. */
#include "sysdep.h"
+#include "alloca-conf.h"
#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "libhppa.h"
#include "elf64-hppa.h"
-/* This is the code recommended in the autoconf documentation, almost
- verbatim. */
-#ifndef __GNUC__
-# if HAVE_ALLOCA_H
-# include <alloca.h>
-# else
-# ifdef _AIX
-/* Indented so that pre-ansi C compilers will ignore it, rather than
- choke on it. Some versions of AIX require this to be the first
- thing in the file. */
- #pragma alloca
-# else
-# ifndef alloca /* predefined by HP cc +Olibcalls */
-# if !defined (__STDC__) && !defined (__hpux)
-extern char *alloca ();
-# else
-extern void *alloca ();
-# endif /* __STDC__, __hpux */
-# endif /* alloca */
-# endif /* _AIX */
-# endif /* HAVE_ALLOCA_H */
-#else
-extern void *alloca (size_t);
-#endif /* __GNUC__ */
-
#define ARCH_SIZE 64
};
#define hppa_link_hash_table(p) \
- ((struct elf64_hppa_link_hash_table *) ((p)->hash))
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == HPPA64_ELF_DATA ? ((struct elf64_hppa_link_hash_table *) ((p)->hash)) : NULL)
#define hppa_elf_hash_entry(ent) \
((struct elf64_hppa_link_hash_entry *)(ent))
static bfd_boolean elf64_hppa_size_dynamic_sections
(bfd *, struct bfd_link_info *);
-static bfd_boolean elf64_hppa_link_output_symbol_hook
+static int elf64_hppa_link_output_symbol_hook
(struct bfd_link_info *, const char *, Elf_Internal_Sym *,
asection *, struct elf_link_hash_entry *);
if (!_bfd_elf_link_hash_table_init (&htab->root, abfd,
hppa64_link_hash_newfunc,
- sizeof (struct elf64_hppa_link_hash_entry)))
+ sizeof (struct elf64_hppa_link_hash_entry),
+ HPPA64_ELF_DATA))
{
bfd_release (abfd, htab);
return NULL;
i_ehdrp = elf_elfheader (abfd);
if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
{
- /* GCC on hppa-linux produces binaries with OSABI=Linux,
+ /* GCC on hppa-linux produces binaries with OSABI=GNU,
but the kernel produces corefiles with OSABI=SysV. */
- if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX
+ if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU
&& i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
return FALSE;
}
const char *name,
int shindex)
{
- asection *newsect;
-
switch (hdr->sh_type)
{
case SHT_PARISC_EXT:
if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
return FALSE;
- newsect = hdr->bfd_section;
return TRUE;
}
srel_name = (bfd_elf_string_from_elf_section
(abfd, elf_elfheader(abfd)->e_shstrndx,
- elf_section_data(sec)->rel_hdr.sh_name));
+ _bfd_elf_single_rel_hdr(sec)->sh_name));
if (srel_name == NULL)
return FALSE;
- BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")
- && strcmp (bfd_get_section_name (abfd, sec),
- srel_name + 5) == 0)
- || (CONST_STRNEQ (srel_name, ".rel")
- && strcmp (bfd_get_section_name (abfd, sec),
- srel_name + 4) == 0));
-
dynobj = hppa_info->root.dynobj;
if (!dynobj)
hppa_info->root.dynobj = dynobj = abfd;
const Elf_Internal_Rela *relend;
Elf_Internal_Shdr *symtab_hdr;
const Elf_Internal_Rela *rel;
- asection *dlt, *plt, *stubs;
- char *buf;
- size_t buf_len;
unsigned int sec_symndx;
if (info->relocatable)
}
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
/* If necessary, build a new table holding section symbols indices
else
sec_symndx = 0;
- dlt = plt = stubs = NULL;
- buf = NULL;
- buf_len = 0;
-
relend = relocs + sec->reloc_count;
for (rel = relocs; rel < relend; ++rel)
{
}
}
- if (buf)
- free (buf);
return TRUE;
err_out:
- if (buf)
- free (buf);
return FALSE;
}
struct elf64_hppa_link_hash_table *hppa_info;
hppa_info = hppa_link_hash_table (info);
-
- if (eh->root.type == bfd_link_hash_warning)
- eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
+ if (hppa_info == NULL)
+ return FALSE;
if (eh
&& (eh->root.type == bfd_link_hash_defined
allocate_global_data_plt (struct elf_link_hash_entry *eh, void *data)
{
struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
- struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
+ struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *) data;
if (hh->want_plt
&& elf64_hppa_dynamic_symbol_p (eh, x->info)
hh->plt_offset = x->ofs;
x->ofs += PLT_ENTRY_SIZE;
if (hh->plt_offset < 0x2000)
- hppa_link_hash_table (x->info)->gp_offset = hh->plt_offset;
+ {
+ struct elf64_hppa_link_hash_table *hppa_info;
+
+ hppa_info = hppa_link_hash_table (x->info);
+ if (hppa_info == NULL)
+ return FALSE;
+
+ hppa_info->gp_offset = hh->plt_offset;
+ }
}
else
hh->want_plt = 0;
if (hh && hh->want_opd)
{
- while (hh->eh.root.type == bfd_link_hash_indirect
- || hh->eh.root.type == bfd_link_hash_warning)
- hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
-
/* We never need an opd entry for a symbol which is not
defined by this output file. */
if (hh && (hh->eh.root.type == bfd_link_hash_undefined
struct bfd_link_info *info)
{
asection *s;
+ struct elf64_hppa_link_hash_table *hppa_info;
+
+ hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
- if (! get_stub (abfd, info, hppa_link_hash_table (info)))
+ if (! get_stub (abfd, info, hppa_info))
return FALSE;
- if (! get_dlt (abfd, info, hppa_link_hash_table (info)))
+ if (! get_dlt (abfd, info, hppa_info))
return FALSE;
- if (! get_plt (abfd, info, hppa_link_hash_table (info)))
+ if (! get_plt (abfd, info, hppa_info))
return FALSE;
- if (! get_opd (abfd, info, hppa_link_hash_table (info)))
+ if (! get_opd (abfd, info, hppa_info))
return FALSE;
s = bfd_make_section_with_flags (abfd, ".rela.dlt",
if (s == NULL
|| !bfd_set_section_alignment (abfd, s, 3))
return FALSE;
- hppa_link_hash_table (info)->dlt_rel_sec = s;
+ hppa_info->dlt_rel_sec = s;
s = bfd_make_section_with_flags (abfd, ".rela.plt",
(SEC_ALLOC | SEC_LOAD
if (s == NULL
|| !bfd_set_section_alignment (abfd, s, 3))
return FALSE;
- hppa_link_hash_table (info)->plt_rel_sec = s;
+ hppa_info->plt_rel_sec = s;
s = bfd_make_section_with_flags (abfd, ".rela.data",
(SEC_ALLOC | SEC_LOAD
if (s == NULL
|| !bfd_set_section_alignment (abfd, s, 3))
return FALSE;
- hppa_link_hash_table (info)->other_rel_sec = s;
+ hppa_info->other_rel_sec = s;
s = bfd_make_section_with_flags (abfd, ".rela.opd",
(SEC_ALLOC | SEC_LOAD
if (s == NULL
|| !bfd_set_section_alignment (abfd, s, 3))
return FALSE;
- hppa_link_hash_table (info)->opd_rel_sec = s;
+ hppa_info->opd_rel_sec = s;
return TRUE;
}
bfd_boolean dynamic_symbol, shared;
hppa_info = hppa_link_hash_table (x->info);
+ if (hppa_info == NULL)
+ return FALSE;
+
dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info);
shared = x->info->shared;
elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh,
void *data)
{
- struct elf_link_hash_entry *elf = eh;
- struct bfd_link_info *info = (struct bfd_link_info *)data;
-
- if (elf->root.type == bfd_link_hash_warning)
- elf = (struct elf_link_hash_entry *) elf->root.u.i.link;
+ struct bfd_link_info *info = (struct bfd_link_info *) data;
- if (elf->type == STT_PARISC_MILLI)
+ if (eh->type == STT_PARISC_MILLI)
{
- if (elf->dynindx != -1)
+ if (eh->dynindx != -1)
{
- elf->dynindx = -1;
+ eh->dynindx = -1;
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
- elf->dynstr_index);
+ eh->dynstr_index);
}
return TRUE;
}
bfd_boolean reltext;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
dynobj = elf_hash_table (info)->dynobj;
BFD_ASSERT (dynobj != NULL);
the symbols have their expected value in the normal symbol
table. Ick. */
-static bfd_boolean
+static int
elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
const char *name,
Elf_Internal_Sym *sym,
/* We may be called with the file symbol or section symbols.
They never need munging, so it is safe to ignore them. */
if (!name || !eh)
- return TRUE;
+ return 1;
/* Function symbols for which we created .opd entries *may* have been
munged by finish_dynamic_symbol and have to be un-munged here.
sym->st_shndx = hh->st_shndx;
}
- return TRUE;
+ return 1;
}
/* Finish up dynamic symbol handling. We set the contents of various
Elf_Internal_Sym *sym)
{
struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
- asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel;
+ asection *stub, *splt, *sopd, *spltrel;
struct elf64_hppa_link_hash_table *hppa_info;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
stub = hppa_info->stub_sec;
splt = hppa_info->plt_sec;
- sdlt = hppa_info->dlt_sec;
sopd = hppa_info->opd_sec;
spltrel = hppa_info->plt_rel_sec;
- sdltrel = hppa_info->dlt_rel_sec;
/* Incredible. It is actually necessary to NOT use the symbol's real
value when building the dynamic symbol table for a shared library.
asection *sopdrel;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
+
sopd = hppa_info->opd_sec;
sopdrel = hppa_info->opd_rel_sec;
asection *sdlt, *sdltrel;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
sdlt = hppa_info->dlt_sec;
sdltrel = hppa_info->dlt_rel_sec;
int dynindx;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
/* We may need to do a relocation against a local symbol, in
which case we have to look up it's dynamic symbol index off
static enum elf_reloc_type_class
elf64_hppa_reloc_type_class (const Elf_Internal_Rela *rela)
{
- if (ELF64_R_SYM (rela->r_info) == 0)
+ if (ELF64_R_SYM (rela->r_info) == STN_UNDEF)
return reloc_class_relative;
switch ((int) ELF64_R_TYPE (rela->r_info))
struct elf64_hppa_link_hash_table *hppa_info;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
/* Finalize the contents of the .opd section. */
elf_link_hash_traverse (elf_hash_table (info),
elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
/* pr_pid */
- elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
+ elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 32);
/* pr_reg */
offset = 112;
}
/* Support HP specific sections for core files. */
+
static bfd_boolean
-elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index,
+elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int sec_index,
const char *typename)
{
if (hdr->p_type == PT_HP_CORE_KERNEL)
{
asection *sect;
- if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))
+ if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
return FALSE;
sect = bfd_make_section_anyway (abfd, ".kernel");
elf_tdata (abfd)->core_signal = sig;
- if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))
+ if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
return FALSE;
/* GDB uses the ".reg" section to read register contents. */
|| hdr->p_type == PT_HP_CORE_MMF)
hdr->p_type = PT_LOAD;
- return _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename);
+ return _bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename);
}
/* Hook called by the linker routine which adds symbols from an object
asection **secp,
bfd_vma *valp)
{
- unsigned int index = sym->st_shndx;
+ unsigned int sec_index = sym->st_shndx;
- switch (index)
+ switch (sec_index)
{
case SHN_PARISC_ANSI_COMMON:
*secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
{
struct bfd_link_info *info = data;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
/* If we are not creating a shared library, and this symbol is
referenced by a shared library but is not defined anywhere, then
the generic code will warn that it is undefined.
{
struct bfd_link_info *info = data;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
/* If we are not creating a shared library, and this symbol is
referenced by a shared library but is not defined anywhere, then
the generic code will warn that it is undefined.
bfd_boolean retval;
struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
+
if (! info->relocatable)
{
struct elf_link_hash_entry *gp;
/* If we're producing a final executable, sort the contents of the
unwind section. */
- if (retval)
+ if (retval && !info->relocatable)
retval = elf_hppa_sort_unwind (abfd);
return retval;
unsigned int r_type = howto->type;
bfd_byte *hit_data = contents + offset;
+ if (hppa_info == NULL)
+ return bfd_reloc_notsupported;
+
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
local_offsets = elf_local_got_offsets (input_bfd);
insn = bfd_get_32 (input_bfd, hit_data);
&& value + addend + max_branch_offset >= 2*max_branch_offset)
{
(*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot reach %s"),
+ (_("%B(%A+0x" BFD_VMA_FMT "x): cannot reach %s"),
input_bfd,
input_section,
offset,
- eh->root.root.string);
+ eh ? eh->root.root.string : "unknown");
bfd_set_error (bfd_error_bad_value);
- return bfd_reloc_notsupported;
+ return bfd_reloc_overflow;
}
/* Adjust for any field selectors. */
struct elf64_hppa_link_hash_table *hppa_info;
hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
+
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
rel = relocs;
asection *sym_sec;
bfd_vma relocation;
bfd_reloc_status_type r;
- bfd_boolean warned_undef;
r_type = ELF_R_TYPE (rel->r_info);
if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
eh = NULL;
sym = NULL;
sym_sec = NULL;
- warned_undef = FALSE;
if (r_symndx < symtab_hdr->sh_info)
{
/* This is a local symbol, hh defaults to NULL. */
else
{
/* This is not a local symbol. */
- bfd_boolean unresolved_reloc;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
/* It seems this can happen with erroneous or unsupported
|| eh->root.type == bfd_link_hash_warning)
eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
- warned_undef = FALSE;
- unresolved_reloc = FALSE;
relocation = 0;
if (eh->root.type == bfd_link_hash_defined
|| eh->root.type == bfd_link_hash_defweak)
{
sym_sec = eh->root.u.def.section;
- if (sym_sec == NULL
- || sym_sec->output_section == NULL)
- /* Set a flag that will be cleared later if we find a
- relocation value for this symbol. output_section
- is typically NULL for symbols satisfied by a shared
- library. */
- unresolved_reloc = TRUE;
- else
+ if (sym_sec != NULL
+ && sym_sec->output_section != NULL)
relocation = (eh->root.u.def.value
+ sym_sec->output_section->vma
+ sym_sec->output_offset);
input_section,
rel->r_offset, err))
return FALSE;
- warned_undef = TRUE;
}
if (!info->relocatable
(info, eh_name (eh), input_bfd,
input_section, rel->r_offset, FALSE))
return FALSE;
- warned_undef = TRUE;
}
}
}
- if (sym_sec != NULL && elf_discarded_section (sym_sec))
- {
- /* For relocs against symbols from removed linkonce sections,
- or sections discarded by a linker script, we just want the
- section contents zeroed. Avoid any special processing. */
- _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
- rel->r_info = 0;
- rel->r_addend = 0;
- continue;
- }
+ if (sym_sec != NULL && discarded_section (sym_sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rel, 1, relend, howto, 0, contents);
if (info->relocatable)
continue;
#define TARGET_BIG_SYM bfd_elf64_hppa_vec
#define TARGET_BIG_NAME "elf64-hppa"
#define ELF_ARCH bfd_arch_hppa
+#define ELF_TARGET_ID HPPA64_ELF_DATA
#define ELF_MACHINE_CODE EM_PARISC
/* This is not strictly correct. The maximum page size for PA2.0 is
64M. But everything still uses 4k. */
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf64-hppa-linux"
#undef ELF_OSABI
-#define ELF_OSABI ELFOSABI_LINUX
+#define ELF_OSABI ELFOSABI_GNU
#undef elf_backend_post_process_headers
#define elf_backend_post_process_headers _bfd_elf_set_osabi
#undef elf64_bed
projects / deliverable / binutils-gdb.git / blobdiff