/* BFD back-end for HP PA-RISC ELF files.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Original code by
Center for Software Science
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/hppa.h"
/* Set if we need a .plt stub to support lazy dynamic linking. */
unsigned int need_plt_stub:1;
- /* Small local sym to section mapping cache. */
- struct sym_sec_cache sym_sec;
+ /* 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) \
- ((struct elf32_hppa_link_hash_table *) ((p)->hash))
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == 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;
if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
- sizeof (struct elf32_hppa_link_hash_entry)))
+ sizeof (struct elf32_hppa_link_hash_entry),
+ HPPA32_ELF_DATA))
{
free (htab);
return NULL;
htab->has_17bit_branch = 0;
htab->has_22bit_branch = 0;
htab->need_plt_stub = 0;
- htab->sym_sec.abfd = NULL;
+ htab->sym_cache.abfd = NULL;
htab->tls_ldm_got.refcount = 0;
return &htab->etab.root;
info = (struct bfd_link_info *)in_arg;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
stub_sec = hsh->stub_sec;
/* Make a note of the offset within the stubs for this entry. */
/* Don't try to create the .plt and .got twice. */
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
if (htab->splt != NULL)
return TRUE;
htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
htab->sgot = bfd_get_section_by_name (abfd, ".got");
- htab->srelgot = bfd_make_section_with_flags (abfd, ".rela.got",
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY));
- if (htab->srelgot == NULL
- || ! bfd_set_section_alignment (abfd, htab->srelgot, 2))
- return FALSE;
+ htab->srelgot = bfd_get_section_by_name (abfd, ".rela.got");
htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
return r_type;
}
+/* Return a pointer to the local GOT, PLT and TLS reference counts
+ for ABFD. Returns NULL if the storage allocation fails. */
+
+static bfd_signed_vma *
+hppa32_elf_local_refcounts (bfd *abfd)
+{
+ Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+ bfd_signed_vma *local_refcounts;
+
+ local_refcounts = elf_local_got_refcounts (abfd);
+ if (local_refcounts == NULL)
+ {
+ bfd_size_type size;
+
+ /* Allocate space for local GOT and PLT reference
+ counts. Done this way to save polluting elf_obj_tdata
+ with another target specific pointer. */
+ size = symtab_hdr->sh_info;
+ size *= 2 * sizeof (bfd_signed_vma);
+ /* Add in space to store the local GOT TLS types. */
+ size += symtab_hdr->sh_info;
+ local_refcounts = bfd_zalloc (abfd, size);
+ if (local_refcounts == NULL)
+ return NULL;
+ elf_local_got_refcounts (abfd) = local_refcounts;
+ memset (hppa_elf_local_got_tls_type (abfd), GOT_UNKNOWN,
+ symtab_hdr->sh_info);
+ }
+ return local_refcounts;
+}
+
+
/* Look through the relocs for a section during the first phase, and
calculate needed space in the global offset table, procedure linkage
table, and dynamic reloc sections. At this point we haven't
const Elf_Internal_Rela *rela_end;
struct elf32_hppa_link_hash_table *htab;
asection *sreloc;
- asection *stubreloc;
int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
if (info->relocatable)
return TRUE;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
eh_syms = elf_sym_hashes (abfd);
sreloc = NULL;
- stubreloc = NULL;
rela_end = relocs + sec->reloc_count;
for (rela = relocs; rela < rela_end; rela++)
/* 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))
+ BFD_ASSERT (hh != NULL);
+ if (hh != NULL
+ && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
return FALSE;
continue;
if (r_type == R_PARISC_TLS_LDM21L
|| r_type == R_PARISC_TLS_LDM14R)
- hppa_link_hash_table (info)->tls_ldm_got.refcount += 1;
+ htab->tls_ldm_got.refcount += 1;
else
{
if (hh != NULL)
bfd_signed_vma *local_got_refcounts;
/* This is a global offset table entry for a local symbol. */
- local_got_refcounts = elf_local_got_refcounts (abfd);
+ local_got_refcounts = hppa32_elf_local_refcounts (abfd);
if (local_got_refcounts == NULL)
- {
- bfd_size_type size;
-
- /* Allocate space for local got offsets and local
- plt offsets. Done this way to save polluting
- elf_obj_tdata with another target specific
- pointer. */
- size = symtab_hdr->sh_info;
- size *= 2 * sizeof (bfd_signed_vma);
- /* Add in space to store the local GOT TLS types. */
- size += symtab_hdr->sh_info;
- local_got_refcounts = bfd_zalloc (abfd, size);
- if (local_got_refcounts == NULL)
- return FALSE;
- elf_local_got_refcounts (abfd) = local_got_refcounts;
- memset (hppa_elf_local_got_tls_type (abfd),
- GOT_UNKNOWN, symtab_hdr->sh_info);
- }
+ return FALSE;
local_got_refcounts[r_symndx] += 1;
old_tls_type = hppa_elf_local_got_tls_type (abfd) [r_symndx];
bfd_signed_vma *local_got_refcounts;
bfd_signed_vma *local_plt_refcounts;
- local_got_refcounts = elf_local_got_refcounts (abfd);
+ local_got_refcounts = hppa32_elf_local_refcounts (abfd);
if (local_got_refcounts == NULL)
- {
- bfd_size_type size;
-
- /* Allocate space for local got offsets and local
- plt offsets. */
- size = symtab_hdr->sh_info;
- size *= 2 * sizeof (bfd_signed_vma);
- /* Add in space to store the local GOT TLS types. */
- size += symtab_hdr->sh_info;
- local_got_refcounts = bfd_zalloc (abfd, size);
- if (local_got_refcounts == NULL)
- return FALSE;
- elf_local_got_refcounts (abfd) = local_got_refcounts;
- }
+ return FALSE;
local_plt_refcounts = (local_got_refcounts
+ symtab_hdr->sh_info);
local_plt_refcounts[r_symndx] += 1;
this reloc. */
if (sreloc == NULL)
{
- char *name;
- bfd *dynobj;
-
- name = (bfd_elf_string_from_elf_section
- (abfd,
- elf_elfheader (abfd)->e_shstrndx,
- elf_section_data (sec)->rel_hdr.sh_name));
- if (name == NULL)
- {
- (*_bfd_error_handler)
- (_("Could not find relocation section for %s"),
- sec->name);
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
-
if (htab->etab.dynobj == NULL)
htab->etab.dynobj = abfd;
- dynobj = htab->etab.dynobj;
- sreloc = bfd_get_section_by_name (dynobj, name);
+ sreloc = _bfd_elf_make_dynamic_reloc_section
+ (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
+
if (sreloc == NULL)
{
- flagword flags;
-
- flags = (SEC_HAS_CONTENTS | SEC_READONLY
- | SEC_IN_MEMORY | SEC_LINKER_CREATED);
- if ((sec->flags & SEC_ALLOC) != 0)
- flags |= SEC_ALLOC | SEC_LOAD;
- sreloc = bfd_make_section_with_flags (dynobj,
- name,
- flags);
- if (sreloc == NULL
- || !bfd_set_section_alignment (dynobj, sreloc, 2))
- return FALSE;
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
}
-
- elf_section_data (sec)->sreloc = sreloc;
}
/* If this is a global symbol, we count the number of
/* Track dynamic relocs needed for local syms too.
We really need local syms available to do this
easily. Oh well. */
-
asection *sr;
void *vpp;
+ Elf_Internal_Sym *isym;
- sr = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
- sec, r_symndx);
- if (sr == NULL)
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ abfd, r_symndx);
+ if (isym == NULL)
return FALSE;
+ sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
+ if (sr == NULL)
+ sr = sec;
+
vpp = &elf_section_data (sr)->local_dynrel;
hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
}
bfd_signed_vma *local_got_refcounts;
bfd_signed_vma *local_plt_refcounts;
const Elf_Internal_Rela *rela, *relend;
+ struct elf32_hppa_link_hash_table *htab;
+
+ if (info->relocatable)
+ return TRUE;
+
+ htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
elf_section_data (sec)->local_dynrel = NULL;
case R_PARISC_TLS_LDM21L:
case R_PARISC_TLS_LDM14R:
- hppa_link_hash_table (info)->tls_ldm_got.refcount -= 1;
+ htab->tls_ldm_got.refcount -= 1;
break;
case R_PARISC_PCREL12F:
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 + 24);
+ elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
/* pr_reg */
offset = 72;
{
struct elf32_hppa_link_hash_table *htab;
asection *sec;
- unsigned int power_of_two;
/* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later. */
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
eh->needs_copy = 1;
}
- /* We need to figure out the alignment required for this symbol. I
- have no idea how other ELF linkers handle this. */
-
- power_of_two = bfd_log2 (eh->size);
- if (power_of_two > 3)
- power_of_two = 3;
-
- /* Apply the required alignment. */
sec = htab->sdynbss;
- sec->size = BFD_ALIGN (sec->size, (bfd_size_type) (1 << power_of_two));
- if (power_of_two > bfd_get_section_alignment (htab->etab.dynobj, sec))
- {
- if (! bfd_set_section_alignment (htab->etab.dynobj, sec, power_of_two))
- return FALSE;
- }
- /* Define the symbol as being at this point in the section. */
- eh->root.u.def.section = sec;
- eh->root.u.def.value = sec->size;
-
- /* Increment the section size to make room for the symbol. */
- sec->size += eh->size;
-
- return TRUE;
+ return _bfd_elf_adjust_dynamic_copy (eh, sec);
}
/* Allocate space in the .plt for entries that won't have relocations.
info = (struct bfd_link_info *) inf;
hh = hppa_elf_hash_entry (eh);
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
if (htab->etab.dynamic_sections_created
&& eh->plt.refcount > 0)
{
info = inf;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
hh = hppa_elf_hash_entry (eh);
if (htab->etab.dynamic_sections_created
bfd_boolean relocs;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
dynobj = htab->etab.dynobj;
if (dynobj == NULL)
abort ();
bfd_size_type amt;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return -1;
+
/* Count the number of input BFDs and find the top input section id. */
for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
input_bfd != NULL;
{
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return;
+
if (isec->output_section->index <= htab->top_index)
{
asection **list = htab->input_list + isec->output_section->index;
int stub_changed = 0;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return -1;
+
/* 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_boolean stub_changed;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
/* Stash our params away. */
htab->stub_bfd = stub_bfd;
htab->multi_subspace = multi_subspace;
/* It's a local symbol. */
Elf_Internal_Sym *sym;
Elf_Internal_Shdr *hdr;
+ unsigned int shndx;
sym = local_syms + r_indx;
- hdr = elf_elfsections (input_bfd)[sym->st_shndx];
- sym_sec = hdr->bfd_section;
if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
sym_value = sym->st_value;
- destination = (sym_value + irela->r_addend
- + sym_sec->output_offset
- + sym_sec->output_section->vma);
+ shndx = sym->st_shndx;
+ if (shndx < elf_numsections (input_bfd))
+ {
+ hdr = elf_elfsections (input_bfd)[shndx];
+ sym_sec = hdr->bfd_section;
+ destination = (sym_value + irela->r_addend
+ + sym_sec->output_offset
+ + sym_sec->output_section->vma);
+ }
}
else
{
struct elf32_hppa_link_hash_table *htab;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE);
if (h != NULL
struct elf32_hppa_link_hash_table *htab;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
/* If we're producing a final executable, sort the contents of the
unwind section. */
+ if (info->relocatable)
+ return TRUE;
+
return elf_hppa_sort_unwind (abfd);
}
/* Record the lowest address for the data and text segments. */
static void
-hppa_record_segment_addr (bfd *abfd ATTRIBUTE_UNUSED,
- asection *section,
- void *data)
+hppa_record_segment_addr (bfd *abfd, asection *section, void *data)
{
struct elf32_hppa_link_hash_table *htab;
htab = (struct elf32_hppa_link_hash_table*) data;
+ if (htab == NULL)
+ return;
if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
- bfd_vma value = section->vma - section->filepos;
+ bfd_vma value;
+ Elf_Internal_Phdr *p;
+
+ p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
+ BFD_ASSERT (p != NULL);
+ value = p->p_vaddr;
if ((section->flags & SEC_READONLY) != 0)
{
case R_PARISC_DPREL21L:
case R_PARISC_DPREL14R:
case R_PARISC_DPREL14F:
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_IE21L:
/* Convert instructions that use the linkage table pointer (r19) to
instructions that use the global data pointer (dp). This is the
most efficient way of using PIC code in an incomplete executable,
but the user must follow the standard runtime conventions for
accessing data for this to work. */
- if (orig_r_type == R_PARISC_DLTIND21L)
+ if (orig_r_type == R_PARISC_DLTIND21L
+ || (!info->shared
+ && (r_type == R_PARISC_TLS_GD21L
+ || r_type == R_PARISC_TLS_LDM21L
+ || r_type == R_PARISC_TLS_IE21L)))
{
/* Convert addil instructions if the original reloc was a
DLTIND21L. GCC sometimes uses a register other than r19 for
(_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
input_bfd,
input_section,
- offset,
+ (long) offset,
howto->name,
insn);
}
case R_PARISC_DLTIND21L:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND14F:
- case R_PARISC_TLS_GD21L:
case R_PARISC_TLS_GD14R:
- case R_PARISC_TLS_LDM21L:
case R_PARISC_TLS_LDM14R:
- case R_PARISC_TLS_IE21L:
case R_PARISC_TLS_IE14R:
value -= elf_gp (input_section->output_section->owner);
break;
(_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
input_bfd,
input_section,
- offset,
+ (long) offset,
hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
local_got_offsets = elf_local_got_offsets (input_bfd);
rela = relocs;
}
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 (elf_hppa_howto_table + r_type, input_bfd,
- contents + rela->r_offset);
- rela->r_info = 0;
- rela->r_addend = 0;
- continue;
- }
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rela, relend,
+ elf_hppa_howto_table + r_type,
+ contents);
if (info->relocatable)
continue;
bfd_byte *loc;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
if (eh->plt.offset != (bfd_vma) -1)
{
elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela)
{
/* Handle TLS relocs first; we don't want them to be marked
- relative by the "if (ELF32_R_SYM (rela->r_info) == 0)"
+ relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
check below. */
switch ((int) ELF32_R_TYPE (rela->r_info))
{
return reloc_class_normal;
}
- if (ELF32_R_SYM (rela->r_info) == 0)
+ if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
return reloc_class_relative;
switch ((int) ELF32_R_TYPE (rela->r_info))
asection *sdyn;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
+
dynobj = htab->etab.dynobj;
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
/* Misc BFD support code. */
#define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
+#define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
#define elf_info_to_howto elf_hppa_info_to_howto
#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
#define TARGET_BIG_SYM bfd_elf32_hppa_vec
#define TARGET_BIG_NAME "elf32-hppa"
#define ELF_ARCH bfd_arch_hppa
+#define ELF_TARGET_ID HPPA32_ELF_DATA
#define ELF_MACHINE_CODE EM_PARISC
#define ELF_MAXPAGESIZE 0x1000
#define ELF_OSABI ELFOSABI_HPUX
projects / deliverable / binutils-gdb.git / blobdiff