/* BFD back-end for HP PA-RISC ELF files.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
- 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1990-2019 Free Software Foundation, Inc.
Original code by
Center for Software Science
Department of Computer Science
University of Utah
Largely rewritten by Alan Modra <alan@linuxcare.com.au>
+ Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
+ TLS support written by Randolph Chung <tausq@debian.org>
This file is part of BFD, the Binary File Descriptor library.
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., 59 Temple Place - Suite 330, 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"
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
: mtsp %r1,%sr0
: be,n 0(%sr0,%rp) ; inter-space return. */
+
+/* Variable names follow a coding style.
+ Please follow this (Apps Hungarian) style:
+
+ Structure/Variable Prefix
+ elf_link_hash_table "etab"
+ elf_link_hash_entry "eh"
+
+ elf32_hppa_link_hash_table "htab"
+ elf32_hppa_link_hash_entry "hh"
+
+ bfd_hash_table "btab"
+ bfd_hash_entry "bh"
+
+ bfd_hash_table containing stubs "bstab"
+ elf32_hppa_stub_hash_entry "hsh"
+
+ Always remember to use GNU Coding Style. */
+
#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 */
#ifndef RELATIVE_DYNRELOCS
#define RELATIVE_DYNRELOCS 0
#define IS_ABSOLUTE_RELOC(r_type) 1
+#define pc_dynrelocs(hh) 0
#endif
/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
shared lib. */
#define ELIMINATE_COPY_RELOCS 1
-enum elf32_hppa_stub_type {
+enum elf32_hppa_stub_type
+{
hppa_stub_long_branch,
hppa_stub_long_branch_shared,
hppa_stub_import,
hppa_stub_none
};
-struct elf32_hppa_stub_hash_entry {
-
+struct elf32_hppa_stub_hash_entry
+{
/* Base hash table entry structure. */
- struct bfd_hash_entry root;
+ struct bfd_hash_entry bh_root;
/* The stub section. */
asection *stub_sec;
enum elf32_hppa_stub_type stub_type;
/* The symbol table entry, if any, that this was derived from. */
- struct elf32_hppa_link_hash_entry *h;
+ struct elf32_hppa_link_hash_entry *hh;
/* Where this stub is being called from, or, in the case of combined
stub sections, the first input section in the group. */
asection *id_sec;
};
-struct elf32_hppa_link_hash_entry {
-
- struct elf_link_hash_entry elf;
+enum _tls_type
+ {
+ GOT_UNKNOWN = 0,
+ GOT_NORMAL = 1,
+ GOT_TLS_GD = 2,
+ GOT_TLS_LDM = 4,
+ GOT_TLS_IE = 8
+ };
+
+struct elf32_hppa_link_hash_entry
+{
+ struct elf_link_hash_entry eh;
/* A pointer to the most recently used stub hash entry against this
symbol. */
- struct elf32_hppa_stub_hash_entry *stub_cache;
+ struct elf32_hppa_stub_hash_entry *hsh_cache;
/* Used to count relocations for delayed sizing of relocation
sections. */
- struct elf32_hppa_dyn_reloc_entry {
-
- /* Next relocation in the chain. */
- struct elf32_hppa_dyn_reloc_entry *next;
+ struct elf_dyn_relocs *dyn_relocs;
- /* The input section of the reloc. */
- asection *sec;
-
- /* Number of relocs copied in this section. */
- bfd_size_type count;
-
-#if RELATIVE_DYNRELOCS
- /* Number of relative relocs copied for the input section. */
- bfd_size_type relative_count;
-#endif
- } *dyn_relocs;
+ ENUM_BITFIELD (_tls_type) tls_type : 8;
/* Set if this symbol is used by a plabel reloc. */
unsigned int plabel:1;
};
-struct elf32_hppa_link_hash_table {
-
+struct elf32_hppa_link_hash_table
+{
/* The main hash table. */
- struct elf_link_hash_table elf;
+ struct elf_link_hash_table etab;
/* The stub hash table. */
- struct bfd_hash_table stub_hash_table;
+ struct bfd_hash_table bstab;
/* Linker stub bfd. */
bfd *stub_bfd;
/* Array to keep track of which stub sections have been created, and
information on stub grouping. */
- struct map_stub {
+ struct map_stub
+ {
/* This is the section to which stubs in the group will be
attached. */
asection *link_sec;
/* Assorted information used by elf32_hppa_size_stubs. */
unsigned int bfd_count;
- int top_index;
+ unsigned int top_index;
asection **input_list;
Elf_Internal_Sym **all_local_syms;
- /* Short-cuts to get to dynamic linker sections. */
- asection *sgot;
- asection *srelgot;
- asection *splt;
- asection *srelplt;
- asection *sdynbss;
- asection *srelbss;
-
/* Used during a final link to store the base of the text and data
segments so that we can perform SEGREL relocations. */
bfd_vma text_segment_base;
/* 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
+ {
+ bfd_signed_vma refcount;
+ bfd_vma offset;
+ } tls_ldm_got;
};
/* 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))
+
+#define hppa_stub_hash_entry(ent) \
+ ((struct elf32_hppa_stub_hash_entry *)(ent))
#define hppa_stub_hash_lookup(table, string, create, copy) \
((struct elf32_hppa_stub_hash_entry *) \
bfd_hash_lookup ((table), (string), (create), (copy)))
+#define hppa_elf_local_got_tls_type(abfd) \
+ ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
+
+#define hh_name(hh) \
+ (hh ? hh->eh.root.root.string : "<undef>")
+
+#define eh_name(eh) \
+ (eh ? eh->root.root.string : "<undef>")
+
/* Assorted hash table functions. */
/* Initialize an entry in the stub hash table. */
entry = bfd_hash_newfunc (entry, table, string);
if (entry != NULL)
{
- struct elf32_hppa_stub_hash_entry *eh;
+ struct elf32_hppa_stub_hash_entry *hsh;
/* Initialize the local fields. */
- eh = (struct elf32_hppa_stub_hash_entry *) entry;
- eh->stub_sec = NULL;
- eh->stub_offset = 0;
- eh->target_value = 0;
- eh->target_section = NULL;
- eh->stub_type = hppa_stub_long_branch;
- eh->h = NULL;
- eh->id_sec = NULL;
+ hsh = hppa_stub_hash_entry (entry);
+ hsh->stub_sec = NULL;
+ hsh->stub_offset = 0;
+ hsh->target_value = 0;
+ hsh->target_section = NULL;
+ hsh->stub_type = hppa_stub_long_branch;
+ hsh->hh = NULL;
+ hsh->id_sec = NULL;
}
return entry;
entry = _bfd_elf_link_hash_newfunc (entry, table, string);
if (entry != NULL)
{
- struct elf32_hppa_link_hash_entry *eh;
+ struct elf32_hppa_link_hash_entry *hh;
/* Initialize the local fields. */
- eh = (struct elf32_hppa_link_hash_entry *) entry;
- eh->stub_cache = NULL;
- eh->dyn_relocs = NULL;
- eh->plabel = 0;
+ hh = hppa_elf_hash_entry (entry);
+ hh->hsh_cache = NULL;
+ hh->dyn_relocs = NULL;
+ hh->plabel = 0;
+ hh->tls_type = GOT_UNKNOWN;
}
return entry;
}
+/* Free the derived linker hash table. */
+
+static void
+elf32_hppa_link_hash_table_free (bfd *obfd)
+{
+ struct elf32_hppa_link_hash_table *htab
+ = (struct elf32_hppa_link_hash_table *) obfd->link.hash;
+
+ bfd_hash_table_free (&htab->bstab);
+ _bfd_elf_link_hash_table_free (obfd);
+}
+
/* Create the derived linker hash table. The PA ELF port uses the derived
hash table to keep information specific to the PA ELF linker (without
using static variables). */
static struct bfd_link_hash_table *
elf32_hppa_link_hash_table_create (bfd *abfd)
{
- struct elf32_hppa_link_hash_table *ret;
- bfd_size_type amt = sizeof (*ret);
+ struct elf32_hppa_link_hash_table *htab;
+ bfd_size_type amt = sizeof (*htab);
- ret = bfd_malloc (amt);
- if (ret == NULL)
+ htab = bfd_zmalloc (amt);
+ if (htab == NULL)
return NULL;
- if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, hppa_link_hash_newfunc))
+ if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
+ sizeof (struct elf32_hppa_link_hash_entry),
+ HPPA32_ELF_DATA))
{
- free (ret);
+ free (htab);
return NULL;
}
/* Init the stub hash table too. */
- if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc))
- return NULL;
+ if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
+ sizeof (struct elf32_hppa_stub_hash_entry)))
+ {
+ _bfd_elf_link_hash_table_free (abfd);
+ return NULL;
+ }
+ htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;
- ret->stub_bfd = NULL;
- ret->add_stub_section = NULL;
- ret->layout_sections_again = NULL;
- ret->stub_group = NULL;
- ret->sgot = NULL;
- ret->srelgot = NULL;
- ret->splt = NULL;
- ret->srelplt = NULL;
- ret->sdynbss = NULL;
- ret->srelbss = NULL;
- ret->text_segment_base = (bfd_vma) -1;
- ret->data_segment_base = (bfd_vma) -1;
- ret->multi_subspace = 0;
- ret->has_12bit_branch = 0;
- ret->has_17bit_branch = 0;
- ret->has_22bit_branch = 0;
- ret->need_plt_stub = 0;
- ret->sym_sec.abfd = NULL;
-
- return &ret->elf.root;
+ htab->text_segment_base = (bfd_vma) -1;
+ htab->data_segment_base = (bfd_vma) -1;
+ return &htab->etab.root;
}
-/* Free the derived linker hash table. */
+/* Initialize the linker stubs BFD so that we can use it for linker
+ created dynamic sections. */
-static void
-elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *hash)
+void
+elf32_hppa_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
{
- struct elf32_hppa_link_hash_table *ret
- = (struct elf32_hppa_link_hash_table *) hash;
+ struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
- bfd_hash_table_free (&ret->stub_hash_table);
- _bfd_generic_link_hash_table_free (hash);
+ elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS32;
+ htab->etab.dynobj = abfd;
}
/* Build a name for an entry in the stub hash table. */
static char *
hppa_stub_name (const asection *input_section,
const asection *sym_sec,
- const struct elf32_hppa_link_hash_entry *hash,
- const Elf_Internal_Rela *rel)
+ const struct elf32_hppa_link_hash_entry *hh,
+ const Elf_Internal_Rela *rela)
{
char *stub_name;
bfd_size_type len;
- if (hash)
+ if (hh)
{
- len = 8 + 1 + strlen (hash->elf.root.root.string) + 1 + 8 + 1;
+ len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1;
stub_name = bfd_malloc (len);
if (stub_name != NULL)
- {
- sprintf (stub_name, "%08x_%s+%x",
- input_section->id & 0xffffffff,
- hash->elf.root.root.string,
- (int) rel->r_addend & 0xffffffff);
- }
+ sprintf (stub_name, "%08x_%s+%x",
+ input_section->id & 0xffffffff,
+ hh_name (hh),
+ (int) rela->r_addend & 0xffffffff);
}
else
{
len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
stub_name = bfd_malloc (len);
if (stub_name != NULL)
- {
- sprintf (stub_name, "%08x_%x:%x+%x",
- input_section->id & 0xffffffff,
- sym_sec->id & 0xffffffff,
- (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
- (int) rel->r_addend & 0xffffffff);
- }
+ sprintf (stub_name, "%08x_%x:%x+%x",
+ input_section->id & 0xffffffff,
+ sym_sec->id & 0xffffffff,
+ (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
+ (int) rela->r_addend & 0xffffffff);
}
return stub_name;
}
static struct elf32_hppa_stub_hash_entry *
hppa_get_stub_entry (const asection *input_section,
const asection *sym_sec,
- struct elf32_hppa_link_hash_entry *hash,
- const Elf_Internal_Rela *rel,
+ struct elf32_hppa_link_hash_entry *hh,
+ const Elf_Internal_Rela *rela,
struct elf32_hppa_link_hash_table *htab)
{
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh_entry;
const asection *id_sec;
/* If this input section is part of a group of sections sharing one
more than one stub used to reach say, printf, and we need to
distinguish between them. */
id_sec = htab->stub_group[input_section->id].link_sec;
+ if (id_sec == NULL)
+ return NULL;
- if (hash != NULL && hash->stub_cache != NULL
- && hash->stub_cache->h == hash
- && hash->stub_cache->id_sec == id_sec)
+ if (hh != NULL && hh->hsh_cache != NULL
+ && hh->hsh_cache->hh == hh
+ && hh->hsh_cache->id_sec == id_sec)
{
- stub_entry = hash->stub_cache;
+ hsh_entry = hh->hsh_cache;
}
else
{
char *stub_name;
- stub_name = hppa_stub_name (id_sec, sym_sec, hash, rel);
+ stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela);
if (stub_name == NULL)
return NULL;
- stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
+ hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
stub_name, FALSE, FALSE);
- if (hash != NULL)
- hash->stub_cache = stub_entry;
+ if (hh != NULL)
+ hh->hsh_cache = hsh_entry;
free (stub_name);
}
- return stub_entry;
+ return hsh_entry;
}
/* Add a new stub entry to the stub hash. Not all fields of the new
{
asection *link_sec;
asection *stub_sec;
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh;
link_sec = htab->stub_group[section->id].link_sec;
stub_sec = htab->stub_group[section->id].stub_sec;
}
/* Enter this entry into the linker stub hash table. */
- stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table, stub_name,
+ hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
TRUE, FALSE);
- if (stub_entry == NULL)
+ if (hsh == NULL)
{
- (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
- section->owner,
- stub_name);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: cannot create stub entry %s"),
+ section->owner, stub_name);
return NULL;
}
- stub_entry->stub_sec = stub_sec;
- stub_entry->stub_offset = 0;
- stub_entry->id_sec = link_sec;
- return stub_entry;
+ hsh->stub_sec = stub_sec;
+ hsh->stub_offset = 0;
+ hsh->id_sec = link_sec;
+ return hsh;
}
/* Determine the type of stub needed, if any, for a call. */
static enum elf32_hppa_stub_type
hppa_type_of_stub (asection *input_sec,
- const Elf_Internal_Rela *rel,
- struct elf32_hppa_link_hash_entry *hash,
+ const Elf_Internal_Rela *rela,
+ struct elf32_hppa_link_hash_entry *hh,
bfd_vma destination,
struct bfd_link_info *info)
{
bfd_vma max_branch_offset;
unsigned int r_type;
- if (hash != NULL
- && hash->elf.plt.offset != (bfd_vma) -1
- && hash->elf.dynindx != -1
- && !hash->plabel
- && (info->shared
- || !hash->elf.def_regular
- || hash->elf.root.type == bfd_link_hash_defweak))
+ if (hh != NULL
+ && hh->eh.plt.offset != (bfd_vma) -1
+ && hh->eh.dynindx != -1
+ && !hh->plabel
+ && (bfd_link_pic (info)
+ || !hh->eh.def_regular
+ || hh->eh.root.type == bfd_link_hash_defweak))
{
/* We need an import stub. Decide between hppa_stub_import
and hppa_stub_import_shared later. */
return hppa_stub_import;
}
+ if (destination == (bfd_vma) -1)
+ return hppa_stub_none;
+
/* Determine where the call point is. */
location = (input_sec->output_offset
+ input_sec->output_section->vma
- + rel->r_offset);
+ + rela->r_offset);
branch_offset = destination - location - 8;
- r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rela->r_info);
/* Determine if a long branch stub is needed. parisc branch offsets
are relative to the second instruction past the branch, ie. +8
bytes on from the branch instruction location. The offset is
signed and counts in units of 4 bytes. */
if (r_type == (unsigned int) R_PARISC_PCREL17F)
- {
- max_branch_offset = (1 << (17-1)) << 2;
- }
+ max_branch_offset = (1 << (17 - 1)) << 2;
+
else if (r_type == (unsigned int) R_PARISC_PCREL12F)
- {
- max_branch_offset = (1 << (12-1)) << 2;
- }
+ max_branch_offset = (1 << (12 - 1)) << 2;
+
else /* R_PARISC_PCREL22F. */
- {
- max_branch_offset = (1 << (22-1)) << 2;
- }
+ max_branch_offset = (1 << (22 - 1)) << 2;
if (branch_offset + max_branch_offset >= 2*max_branch_offset)
return hppa_stub_long_branch;
#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) */
#endif
static bfd_boolean
-hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
+hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
{
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh;
struct bfd_link_info *info;
struct elf32_hppa_link_hash_table *htab;
asection *stub_sec;
int size;
/* Massage our args to the form they really have. */
- stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
- info = in_arg;
+ hsh = hppa_stub_hash_entry (bh);
+ info = (struct bfd_link_info *)in_arg;
htab = hppa_link_hash_table (info);
- stub_sec = stub_entry->stub_sec;
+ if (htab == NULL)
+ return FALSE;
+
+ stub_sec = hsh->stub_sec;
/* Make a note of the offset within the stubs for this entry. */
- stub_entry->stub_offset = stub_sec->size;
- loc = stub_sec->contents + stub_entry->stub_offset;
+ hsh->stub_offset = stub_sec->size;
+ loc = stub_sec->contents + hsh->stub_offset;
stub_bfd = stub_sec->owner;
- switch (stub_entry->stub_type)
+ switch (hsh->stub_type)
{
case hppa_stub_long_branch:
/* 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.
The "be" has its delay slot nullified. */
- sym_value = (stub_entry->target_value
- + stub_entry->target_section->output_offset
- + stub_entry->target_section->output_section->vma);
+ sym_value = (hsh->target_value
+ + hsh->target_section->output_offset
+ + hsh->target_section->output_section->vma);
val = hppa_field_adjust (sym_value, 0, e_lrsel);
insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
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:
/* Branches are relative. This is where we are going to. */
- sym_value = (stub_entry->target_value
- + stub_entry->target_section->output_offset
- + stub_entry->target_section->output_section->vma);
+ sym_value = (hsh->target_value
+ + hsh->target_section->output_offset
+ + hsh->target_section->output_section->vma);
/* And this is where we are coming from, more or less. */
- sym_value -= (stub_entry->stub_offset
+ sym_value -= (hsh->stub_offset
+ stub_sec->output_offset
+ stub_sec->output_section->vma);
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:
case hppa_stub_import_shared:
- off = stub_entry->h->elf.plt.offset;
+ off = hsh->hh->eh.plt.offset;
if (off >= (bfd_vma) -2)
abort ();
off &= ~ (bfd_vma) 1;
sym_value = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma
- - elf_gp (htab->splt->output_section->owner));
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ - elf_gp (htab->etab.splt->output_section->owner));
insn = ADDIL_DP;
#if R19_STUBS
- if (stub_entry->stub_type == hppa_stub_import_shared)
+ 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:
/* Branches are relative. This is where we are going to. */
- sym_value = (stub_entry->target_value
- + stub_entry->target_section->output_offset
- + stub_entry->target_section->output_section->vma);
+ sym_value = (hsh->target_value
+ + hsh->target_section->output_offset
+ + hsh->target_section->output_section->vma);
/* And this is where we are coming from. */
- sym_value -= (stub_entry->stub_offset
+ sym_value -= (hsh->stub_offset
+ stub_sec->output_offset
+ stub_sec->output_section->vma);
&& (!htab->has_22bit_branch
|| sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
- stub_entry->target_section->owner,
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): "
+ "cannot reach %s, recompile with -ffunction-sections"),
+ hsh->target_section->owner,
stub_sec,
- (long) stub_entry->stub_offset,
- stub_entry->root.string);
+ (uint64_t) hsh->stub_offset,
+ hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
bfd_put_32 (stub_bfd, insn, loc);
- bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
+ bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8);
bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP, loc + 20);
/* Point the function symbol at the stub. */
- stub_entry->h->elf.root.u.def.section = stub_sec;
- stub_entry->h->elf.root.u.def.value = stub_sec->size;
+ 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:
we know stub section sizes. */
static bfd_boolean
-hppa_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
+hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
{
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh;
struct elf32_hppa_link_hash_table *htab;
int size;
/* Massage our args to the form they really have. */
- stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
+ hsh = hppa_stub_hash_entry (bh);
htab = in_arg;
- if (stub_entry->stub_type == hppa_stub_long_branch)
- size = 8;
- else if (stub_entry->stub_type == hppa_stub_long_branch_shared)
- size = 12;
- else if (stub_entry->stub_type == hppa_stub_export)
- size = 24;
+ if (hsh->stub_type == hppa_stub_long_branch)
+ size = LONG_BRANCH_STUB_SIZE;
+ else if (hsh->stub_type == hppa_stub_long_branch_shared)
+ size = LONG_BRANCH_SHARED_STUB_SIZE;
+ else if (hsh->stub_type == hppa_stub_export)
+ 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;
}
- stub_entry->stub_sec->size += size;
+ hsh->stub_sec->size += size;
return TRUE;
}
i_ehdrp = elf_elfheader (abfd);
if (strcmp (bfd_get_target (abfd), "elf32-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;
}
elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
{
struct elf32_hppa_link_hash_table *htab;
- struct elf_link_hash_entry *h;
+ struct elf_link_hash_entry *eh;
/* Don't try to create the .plt and .got twice. */
htab = hppa_link_hash_table (info);
- if (htab->splt != NULL)
+ if (htab == NULL)
+ return FALSE;
+ if (htab->etab.splt != NULL)
return TRUE;
/* Call the generic code to do most of the work. */
if (! _bfd_elf_create_dynamic_sections (abfd, info))
return FALSE;
- htab->splt = bfd_get_section_by_name (abfd, ".plt");
- htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
-
- htab->sgot = bfd_get_section_by_name (abfd, ".got");
- htab->srelgot = bfd_make_section (abfd, ".rela.got");
- if (htab->srelgot == NULL
- || ! bfd_set_section_flags (abfd, htab->srelgot,
- (SEC_ALLOC
- | SEC_LOAD
- | SEC_HAS_CONTENTS
- | SEC_IN_MEMORY
- | SEC_LINKER_CREATED
- | SEC_READONLY))
- || ! bfd_set_section_alignment (abfd, htab->srelgot, 2))
- return FALSE;
-
- htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
- htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
-
/* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
application, because __canonicalize_funcptr_for_compare needs it. */
- h = elf_hash_table (info)->hgot;
- h->forced_local = 0;
- h->other = STV_DEFAULT;
- return bfd_elf_link_record_dynamic_symbol (info, h);
+ eh = elf_hash_table (info)->hgot;
+ eh->forced_local = 0;
+ eh->other = STV_DEFAULT;
+ return bfd_elf_link_record_dynamic_symbol (info, eh);
}
/* Copy the extra info we tack onto an elf_link_hash_entry. */
static void
-elf32_hppa_copy_indirect_symbol (const struct elf_backend_data *bed,
- struct elf_link_hash_entry *dir,
- struct elf_link_hash_entry *ind)
+elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
+ struct elf_link_hash_entry *eh_dir,
+ struct elf_link_hash_entry *eh_ind)
{
- struct elf32_hppa_link_hash_entry *edir, *eind;
+ struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind;
- edir = (struct elf32_hppa_link_hash_entry *) dir;
- eind = (struct elf32_hppa_link_hash_entry *) ind;
+ hh_dir = hppa_elf_hash_entry (eh_dir);
+ hh_ind = hppa_elf_hash_entry (eh_ind);
- if (eind->dyn_relocs != NULL)
+ if (hh_ind->dyn_relocs != NULL
+ && eh_ind->root.type == bfd_link_hash_indirect)
{
- if (edir->dyn_relocs != NULL)
+ if (hh_dir->dyn_relocs != NULL)
{
- struct elf32_hppa_dyn_reloc_entry **pp;
- struct elf32_hppa_dyn_reloc_entry *p;
-
- if (ind->root.type == bfd_link_hash_indirect)
- abort ();
+ struct elf_dyn_relocs **hdh_pp;
+ struct elf_dyn_relocs *hdh_p;
- /* Add reloc counts against the weak sym to the strong sym
+ /* Add reloc counts against the indirect sym to the direct sym
list. Merge any entries against the same section. */
- for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
+ for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
- struct elf32_hppa_dyn_reloc_entry *q;
+ struct elf_dyn_relocs *hdh_q;
- for (q = edir->dyn_relocs; q != NULL; q = q->next)
- if (q->sec == p->sec)
+ 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
- q->relative_count += p->relative_count;
+ hdh_q->pc_count += hdh_p->pc_count;
#endif
- q->count += p->count;
- *pp = p->next;
+ hdh_q->count += hdh_p->count;
+ *hdh_pp = hdh_p->next;
break;
}
- if (q == NULL)
- pp = &p->next;
+ if (hdh_q == NULL)
+ hdh_pp = &hdh_p->next;
}
- *pp = edir->dyn_relocs;
+ *hdh_pp = hh_dir->dyn_relocs;
}
- edir->dyn_relocs = eind->dyn_relocs;
- eind->dyn_relocs = NULL;
+ hh_dir->dyn_relocs = hh_ind->dyn_relocs;
+ hh_ind->dyn_relocs = NULL;
}
- if (ELIMINATE_COPY_RELOCS
- && ind->root.type != bfd_link_hash_indirect
- && dir->dynamic_adjusted)
+ if (eh_ind->root.type == bfd_link_hash_indirect)
{
- /* If called to transfer flags for a weakdef during processing
- of elf_adjust_dynamic_symbol, don't copy non_got_ref.
- We clear it ourselves for ELIMINATE_COPY_RELOCS. */
- dir->ref_dynamic |= ind->ref_dynamic;
- dir->ref_regular |= ind->ref_regular;
- dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
- dir->needs_plt |= ind->needs_plt;
+ hh_dir->plabel |= hh_ind->plabel;
+ hh_dir->tls_type |= hh_ind->tls_type;
+ hh_ind->tls_type = GOT_UNKNOWN;
}
- else
- _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+
+ _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
}
+static int
+elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ int r_type, int is_local ATTRIBUTE_UNUSED)
+{
+ /* For now we don't support linker optimizations. */
+ 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 *relocs)
{
Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
- const Elf_Internal_Rela *rel;
- const Elf_Internal_Rela *rel_end;
+ struct elf_link_hash_entry **eh_syms;
+ const Elf_Internal_Rela *rela;
+ const Elf_Internal_Rela *rela_end;
struct elf32_hppa_link_hash_table *htab;
asection *sreloc;
- asection *stubreloc;
- if (info->relocatable)
+ if (bfd_link_relocatable (info))
return TRUE;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
+ eh_syms = elf_sym_hashes (abfd);
sreloc = NULL;
- stubreloc = NULL;
- rel_end = relocs + sec->reloc_count;
- for (rel = relocs; rel < rel_end; rel++)
+ rela_end = relocs + sec->reloc_count;
+ for (rela = relocs; rela < rela_end; rela++)
{
enum {
NEED_GOT = 1,
};
unsigned int r_symndx, r_type;
- struct elf32_hppa_link_hash_entry *h;
- int need_entry;
+ struct elf32_hppa_link_hash_entry *hh;
+ int need_entry = 0;
- r_symndx = ELF32_R_SYM (rel->r_info);
+ r_symndx = ELF32_R_SYM (rela->r_info);
if (r_symndx < symtab_hdr->sh_info)
- h = NULL;
+ hh = NULL;
else
- h = ((struct elf32_hppa_link_hash_entry *)
- sym_hashes[r_symndx - symtab_hdr->sh_info]);
+ {
+ hh = hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
+ 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);
+ }
- r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rela->r_info);
+ r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL);
switch (r_type)
{
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
/* If the addend is non-zero, we break badly. */
- if (rel->r_addend != 0)
+ if (rela->r_addend != 0)
abort ();
/* If we are creating a shared library, then we need to
local symbols may be passed via a pointer to another
object. Additionally, output a dynamic relocation
pointing to the PLT entry.
+
For executables, the original 32-bit ABI allowed two
different styles of PLABELs (function pointers): For
global functions, the PLABEL word points into the .plt
functions indirectly or to compare function pointers.
We avoid the mess by always pointing a PLABEL into the
.plt, even for local functions. */
- need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
+ need_entry = PLT_PLABEL | NEED_PLT;
+ if (bfd_link_pic (info))
+ need_entry |= NEED_DYNREL;
break;
case R_PARISC_PCREL12F:
branch_common:
/* Function calls might need to go through the .plt, and
might require long branch stubs. */
- if (h == NULL)
+ if (hh == NULL)
{
/* We know local syms won't need a .plt entry, and if
they need a long branch stub we can't guarantee that
where a symbol is forced local by versioning, or due
to symbolic linking, and we lose the .plt entry. */
need_entry = NEED_PLT;
- if (h->elf.type == STT_PARISC_MILLI)
+ if (hh->eh.type == STT_PARISC_MILLI)
need_entry = 0;
}
break;
case R_PARISC_DPREL14F: /* Used for gp rel data load/store. */
case R_PARISC_DPREL14R:
case R_PARISC_DPREL21L:
- if (info->shared)
+ if (bfd_link_pic (info))
{
- (*_bfd_error_handler)
- (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
abfd,
elf_hppa_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
/* This relocation describes the C++ object vtable hierarchy.
Reconstruct it for later use during GC. */
case R_PARISC_GNU_VTINHERIT:
- if (!bfd_elf_gc_record_vtinherit (abfd, sec, &h->elf, rel->r_offset))
+ if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
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, &h->elf, rel->r_addend))
+ if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
return FALSE;
continue;
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_GD14R:
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_LDM14R:
+ need_entry = NEED_GOT;
+ break;
+
+ case R_PARISC_TLS_IE21L:
+ case R_PARISC_TLS_IE14R:
+ if (bfd_link_dll (info))
+ info->flags |= DF_STATIC_TLS;
+ need_entry = NEED_GOT;
+ break;
+
default:
continue;
}
/* Now carry out our orders. */
if (need_entry & NEED_GOT)
{
+ int tls_type = GOT_NORMAL;
+
+ switch (r_type)
+ {
+ default:
+ break;
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_GD14R:
+ tls_type = GOT_TLS_GD;
+ break;
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_LDM14R:
+ tls_type = GOT_TLS_LDM;
+ break;
+ case R_PARISC_TLS_IE21L:
+ case R_PARISC_TLS_IE14R:
+ tls_type = GOT_TLS_IE;
+ break;
+ }
+
/* Allocate space for a GOT entry, as well as a dynamic
relocation for this entry. */
- if (htab->sgot == NULL)
+ if (htab->etab.sgot == NULL)
{
- if (htab->elf.dynobj == NULL)
- htab->elf.dynobj = abfd;
- if (!elf32_hppa_create_dynamic_sections (htab->elf.dynobj, info))
+ if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
return FALSE;
}
- if (h != NULL)
+ if (hh != NULL)
{
- h->elf.got.refcount += 1;
+ if (tls_type == GOT_TLS_LDM)
+ htab->tls_ldm_got.refcount += 1;
+ else
+ hh->eh.got.refcount += 1;
+ hh->tls_type |= tls_type;
}
else
{
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);
- local_got_refcounts = bfd_zalloc (abfd, size);
- if (local_got_refcounts == NULL)
- return FALSE;
- elf_local_got_refcounts (abfd) = local_got_refcounts;
- }
- local_got_refcounts[r_symndx] += 1;
+ return FALSE;
+ if (tls_type == GOT_TLS_LDM)
+ htab->tls_ldm_got.refcount += 1;
+ else
+ local_got_refcounts[r_symndx] += 1;
+
+ hppa_elf_local_got_tls_type (abfd) [r_symndx] |= tls_type;
}
}
clean up later in adjust_dynamic_symbol. */
if ((sec->flags & SEC_ALLOC) != 0)
{
- if (h != NULL)
+ if (hh != NULL)
{
- h->elf.needs_plt = 1;
- h->elf.plt.refcount += 1;
+ hh->eh.needs_plt = 1;
+ hh->eh.plt.refcount += 1;
/* If this .plt entry is for a plabel, mark it so
that adjust_dynamic_symbol will keep the entry
even if it appears to be local. */
if (need_entry & PLT_PLABEL)
- h->plabel = 1;
+ hh->plabel = 1;
}
else if (need_entry & PLT_PLABEL)
{
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);
- 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;
}
}
- if (need_entry & NEED_DYNREL)
+ if ((need_entry & NEED_DYNREL) != 0
+ && (sec->flags & SEC_ALLOC) != 0)
{
/* Flag this symbol as having a non-got, non-plt reference
so that we generate copy relocs if it turns out to be
dynamic. */
- if (h != NULL && !info->shared)
- h->elf.non_got_ref = 1;
+ if (hh != NULL)
+ hh->eh.non_got_ref = 1;
/* If we are creating a shared library then we need to copy
the reloc into the shared library. However, if we are
may need to keep relocations for symbols satisfied by a
dynamic library if we manage to avoid copy relocs for the
symbol. */
- if ((info->shared
- && (sec->flags & SEC_ALLOC) != 0
+ if ((bfd_link_pic (info)
&& (IS_ABSOLUTE_RELOC (r_type)
- || (h != NULL
- && (!info->symbolic
- || h->elf.root.type == bfd_link_hash_defweak
- || !h->elf.def_regular))))
+ || (hh != NULL
+ && (!SYMBOLIC_BIND (info, &hh->eh)
+ || hh->eh.root.type == bfd_link_hash_defweak
+ || !hh->eh.def_regular))))
|| (ELIMINATE_COPY_RELOCS
- && !info->shared
- && (sec->flags & SEC_ALLOC) != 0
- && h != NULL
- && (h->elf.root.type == bfd_link_hash_defweak
- || !h->elf.def_regular)))
+ && !bfd_link_pic (info)
+ && hh != NULL
+ && (hh->eh.root.type == bfd_link_hash_defweak
+ || !hh->eh.def_regular)))
{
- struct elf32_hppa_dyn_reloc_entry *p;
- struct elf32_hppa_dyn_reloc_entry **head;
+ struct elf_dyn_relocs *hdh_p;
+ struct elf_dyn_relocs **hdh_head;
/* Create a reloc section in dynobj and make room for
this reloc. */
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->elf.dynobj == NULL)
- htab->elf.dynobj = abfd;
+ sreloc = _bfd_elf_make_dynamic_reloc_section
+ (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
- dynobj = htab->elf.dynobj;
- sreloc = bfd_get_section_by_name (dynobj, name);
if (sreloc == NULL)
{
- flagword flags;
-
- sreloc = bfd_make_section (dynobj, name);
- flags = (SEC_HAS_CONTENTS | SEC_READONLY
- | SEC_IN_MEMORY | SEC_LINKER_CREATED);
- if ((sec->flags & SEC_ALLOC) != 0)
- flags |= SEC_ALLOC | SEC_LOAD;
- if (sreloc == NULL
- || !bfd_set_section_flags (dynobj, sreloc, flags)
- || !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
relocations we need for this symbol. */
- if (h != NULL)
+ if (hh != NULL)
{
- head = &h->dyn_relocs;
+ hdh_head = &hh->dyn_relocs;
}
else
{
/* 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;
- asection *s;
- s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
- sec, r_symndx);
- if (s == NULL)
+ isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+ abfd, r_symndx);
+ if (isym == NULL)
return FALSE;
- head = ((struct elf32_hppa_dyn_reloc_entry **)
- &elf_section_data (s)->local_dynrel);
+ 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 elf_dyn_relocs **) vpp;
}
- p = *head;
- if (p == NULL || p->sec != sec)
+ hdh_p = *hdh_head;
+ if (hdh_p == NULL || hdh_p->sec != sec)
{
- p = bfd_alloc (htab->elf.dynobj, sizeof *p);
- if (p == NULL)
+ hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
+ if (hdh_p == NULL)
return FALSE;
- p->next = *head;
- *head = p;
- p->sec = sec;
- p->count = 0;
+ hdh_p->next = *hdh_head;
+ *hdh_head = hdh_p;
+ hdh_p->sec = sec;
+ hdh_p->count = 0;
#if RELATIVE_DYNRELOCS
- p->relative_count = 0;
+ hdh_p->pc_count = 0;
#endif
}
- p->count += 1;
+ hdh_p->count += 1;
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (rtype))
- p->relative_count += 1;
+ hdh_p->pc_count += 1;
#endif
}
}
static asection *
elf32_hppa_gc_mark_hook (asection *sec,
- struct bfd_link_info *info ATTRIBUTE_UNUSED,
- Elf_Internal_Rela *rel,
- struct elf_link_hash_entry *h,
+ struct bfd_link_info *info,
+ Elf_Internal_Rela *rela,
+ struct elf_link_hash_entry *hh,
Elf_Internal_Sym *sym)
{
- if (h != NULL)
- {
- switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
- {
- case R_PARISC_GNU_VTINHERIT:
- case R_PARISC_GNU_VTENTRY:
- break;
-
- default:
- switch (h->root.type)
- {
- case bfd_link_hash_defined:
- case bfd_link_hash_defweak:
- return h->root.u.def.section;
-
- case bfd_link_hash_common:
- return h->root.u.c.p->section;
-
- default:
- break;
- }
- }
- }
- else
- return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
-
- return NULL;
-}
-
-/* Update the got and plt entry reference counts for the section being
- removed. */
-
-static bfd_boolean
-elf32_hppa_gc_sweep_hook (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED,
- asection *sec,
- const Elf_Internal_Rela *relocs)
-{
- Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
- bfd_signed_vma *local_got_refcounts;
- bfd_signed_vma *local_plt_refcounts;
- const Elf_Internal_Rela *rel, *relend;
-
- elf_section_data (sec)->local_dynrel = NULL;
-
- symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
- local_got_refcounts = elf_local_got_refcounts (abfd);
- local_plt_refcounts = local_got_refcounts;
- if (local_plt_refcounts != NULL)
- local_plt_refcounts += symtab_hdr->sh_info;
-
- relend = relocs + sec->reloc_count;
- for (rel = relocs; rel < relend; rel++)
- {
- unsigned long r_symndx;
- unsigned int r_type;
- struct elf_link_hash_entry *h = NULL;
-
- r_symndx = ELF32_R_SYM (rel->r_info);
- if (r_symndx >= symtab_hdr->sh_info)
- {
- struct elf32_hppa_link_hash_entry *eh;
- struct elf32_hppa_dyn_reloc_entry **pp;
- struct elf32_hppa_dyn_reloc_entry *p;
-
- h = sym_hashes[r_symndx - symtab_hdr->sh_info];
- while (h->root.type == bfd_link_hash_indirect
- || h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
- eh = (struct elf32_hppa_link_hash_entry *) h;
-
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
- if (p->sec == sec)
- {
- /* Everything must go for SEC. */
- *pp = p->next;
- break;
- }
- }
-
- r_type = ELF32_R_TYPE (rel->r_info);
- switch (r_type)
- {
- case R_PARISC_DLTIND14F:
- case R_PARISC_DLTIND14R:
- case R_PARISC_DLTIND21L:
- if (h != NULL)
- {
- if (h->got.refcount > 0)
- h->got.refcount -= 1;
- }
- else if (local_got_refcounts != NULL)
- {
- if (local_got_refcounts[r_symndx] > 0)
- local_got_refcounts[r_symndx] -= 1;
- }
- break;
-
- case R_PARISC_PCREL12F:
- case R_PARISC_PCREL17C:
- case R_PARISC_PCREL17F:
- case R_PARISC_PCREL22F:
- if (h != NULL)
- {
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
- }
- break;
-
- case R_PARISC_PLABEL14R:
- case R_PARISC_PLABEL21L:
- case R_PARISC_PLABEL32:
- if (h != NULL)
- {
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
- }
- else if (local_plt_refcounts != NULL)
- {
- if (local_plt_refcounts[r_symndx] > 0)
- local_plt_refcounts[r_symndx] -= 1;
- }
- break;
-
- default:
- break;
- }
- }
+ if (hh != NULL)
+ switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
+ {
+ case R_PARISC_GNU_VTINHERIT:
+ case R_PARISC_GNU_VTENTRY:
+ return NULL;
+ }
- return TRUE;
+ return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
}
/* Support for core dump NOTE sections. */
case 396: /* Linux/hppa */
/* pr_cursig */
- elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
+ 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;
return FALSE;
case 124: /* Linux/hppa elf_prpsinfo. */
- elf_tdata (abfd)->core_program
+ elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
- elf_tdata (abfd)->core_command
+ elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
}
onto the end of the args in some (at least one anyway)
implementations, so strip it off if it exists. */
{
- char *command = elf_tdata (abfd)->core_command;
+ char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
static void
elf32_hppa_hide_symbol (struct bfd_link_info *info,
- struct elf_link_hash_entry *h,
+ struct elf_link_hash_entry *eh,
bfd_boolean force_local)
{
if (force_local)
{
- h->forced_local = 1;
- if (h->dynindx != -1)
+ eh->forced_local = 1;
+ if (eh->dynindx != -1)
{
- h->dynindx = -1;
+ eh->dynindx = -1;
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
- h->dynstr_index);
+ eh->dynstr_index);
}
+
+ /* PR 16082: Remove version information from hidden symbol. */
+ eh->verinfo.verdef = NULL;
+ eh->verinfo.vertree = NULL;
}
- if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
+ /* STT_GNU_IFUNC symbol must go through PLT. */
+ if (! hppa_elf_hash_entry (eh)->plabel
+ && eh->type != STT_GNU_IFUNC)
{
- h->needs_plt = 0;
- h->plt = elf_hash_table (info)->init_refcount;
+ eh->needs_plt = 0;
+ eh->plt = elf_hash_table (info)->init_plt_offset;
}
}
+/* 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
+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;
+ hh = hppa_elf_hash_entry (hh->eh.u.alias);
+ } while (hh != NULL && &hh->eh != eh);
+
+ return FALSE;
+}
+
/* Adjust a symbol defined by a dynamic object and referenced by a
regular object. The current definition is in some section of the
dynamic object, but we're not including those sections. We have to
static bfd_boolean
elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
- struct elf_link_hash_entry *h)
+ struct elf_link_hash_entry *eh)
{
struct elf32_hppa_link_hash_table *htab;
- asection *s;
- unsigned int power_of_two;
+ asection *sec, *srel;
/* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later. */
- if (h->type == STT_FUNC
- || h->needs_plt)
+ if (eh->type == STT_FUNC
+ || eh->needs_plt)
{
- if (h->plt.refcount <= 0
- || (h->def_regular
- && h->root.type != bfd_link_hash_defweak
- && ! ((struct elf32_hppa_link_hash_entry *) h)->plabel
- && (!info->shared || info->symbolic)))
+ bfd_boolean 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;
+
+ /* 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
+ hide_symbol can be called before the plabel flag is set. */
+ if (hppa_elf_hash_entry (eh)->plabel)
+ eh->plt.refcount = 1;
+
+ /* Note that unlike some other backends, the refcount is not
+ incremented for a non-call (and non-plabel) function reference. */
+ else if (eh->plt.refcount <= 0
+ || local)
{
/* The .plt entry is not needed when:
a) Garbage collection has removed all references to the
object, and it's not a weak definition, nor is the symbol
used by a plabel relocation. Either this object is the
application or we are doing a shared symbolic link. */
-
- h->plt.offset = (bfd_vma) -1;
- h->needs_plt = 0;
+ eh->plt.offset = (bfd_vma) -1;
+ eh->needs_plt = 0;
}
+ /* Unlike other targets, elf32-hppa.c does not define a function
+ symbol in a non-pic executable on PLT stub code, so we don't
+ have a local definition in that case. ie. dyn_relocs can't
+ be discarded. */
+
+ /* Function symbols can't have copy relocs. */
return TRUE;
}
else
- h->plt.offset = (bfd_vma) -1;
+ eh->plt.offset = (bfd_vma) -1;
+
+ htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
/* If this is a weak symbol, and there is a real definition, the
processor independent code will have arranged for us to see the
real definition first, and we can just use the same value. */
- if (h->u.weakdef != NULL)
+ if (eh->is_weakalias)
{
- if (h->u.weakdef->root.type != bfd_link_hash_defined
- && h->u.weakdef->root.type != bfd_link_hash_defweak)
- abort ();
- h->root.u.def.section = h->u.weakdef->root.u.def.section;
- h->root.u.def.value = h->u.weakdef->root.u.def.value;
- if (ELIMINATE_COPY_RELOCS)
- h->non_got_ref = h->u.weakdef->non_got_ref;
+ struct elf_link_hash_entry *def = weakdef (eh);
+ BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+ eh->root.u.def.section = def->root.u.def.section;
+ eh->root.u.def.value = def->root.u.def.value;
+ if (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;
}
only references to the symbol are via the global offset table.
For such cases we need not do anything here; the relocations will
be handled correctly by relocate_section. */
- if (info->shared)
+ if (bfd_link_pic (info))
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 (!h->non_got_ref)
+ if (!eh->non_got_ref)
return TRUE;
- if (ELIMINATE_COPY_RELOCS)
- {
- struct elf32_hppa_link_hash_entry *eh;
- struct elf32_hppa_dyn_reloc_entry *p;
-
- eh = (struct elf32_hppa_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
- {
- s = p->sec->output_section;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- break;
- }
+ /* If -z nocopyreloc was given, we won't generate them either. */
+ if (info->nocopyreloc)
+ return TRUE;
- /* If we didn't find any dynamic relocs in read-only sections, then
- we'll be keeping the dynamic relocs and avoiding the copy reloc. */
- if (p == NULL)
- {
- h->non_got_ref = 0;
- 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;
/* We must allocate the symbol in our .dynbss section, which will
become part of the .bss section of the executable. There will be
determine the address it must put in the global offset table, so
both the dynamic object and the regular object will refer to the
same memory location for the variable. */
-
- htab = hppa_link_hash_table (info);
-
- /* We must generate a COPY reloc to tell the dynamic linker to
- copy the initial value out of the dynamic object and into the
- runtime process image. */
- if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
+ if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
{
- htab->srelbss->size += sizeof (Elf32_External_Rela);
- h->needs_copy = 1;
+ sec = htab->etab.sdynrelro;
+ srel = htab->etab.sreldynrelro;
}
-
- /* 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 (h->size);
- if (power_of_two > 3)
- power_of_two = 3;
-
- /* Apply the required alignment. */
- s = htab->sdynbss;
- s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
- if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
+ else
{
- if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
- return FALSE;
+ sec = htab->etab.sdynbss;
+ srel = htab->etab.srelbss;
+ }
+ if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
+ {
+ /* We must generate a COPY reloc to tell the dynamic linker to
+ copy the initial value out of the dynamic object and into the
+ runtime process image. */
+ srel->size += sizeof (Elf32_External_Rela);
+ eh->needs_copy = 1;
}
- /* Define the symbol as being at this point in the section. */
- h->root.u.def.section = s;
- h->root.u.def.value = s->size;
+ /* We no longer want dyn_relocs. */
+ hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
+ return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
+}
- /* Increment the section size to make room for the symbol. */
- s->size += h->size;
+/* If EH is undefined, make it dynamic if that makes sense. */
+static bfd_boolean
+ensure_undef_dynamic (struct bfd_link_info *info,
+ struct elf_link_hash_entry *eh)
+{
+ struct elf_link_hash_table *htab = elf_hash_table (info);
+
+ if (htab->dynamic_sections_created
+ && (eh->root.type == bfd_link_hash_undefweak
+ || eh->root.type == bfd_link_hash_undefined)
+ && eh->dynindx == -1
+ && !eh->forced_local
+ && eh->type != STT_PARISC_MILLI
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
+ && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
+ return bfd_elf_link_record_dynamic_symbol (info, eh);
return TRUE;
}
ie. plabel entries. */
static bfd_boolean
-allocate_plt_static (struct elf_link_hash_entry *h, void *inf)
+allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
{
struct bfd_link_info *info;
struct elf32_hppa_link_hash_table *htab;
- asection *s;
+ struct elf32_hppa_link_hash_entry *hh;
+ asection *sec;
- if (h->root.type == bfd_link_hash_indirect)
+ if (eh->root.type == bfd_link_hash_indirect)
return TRUE;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
- info = inf;
+ info = (struct bfd_link_info *) inf;
+ hh = hppa_elf_hash_entry (eh);
htab = hppa_link_hash_table (info);
- if (htab->elf.dynamic_sections_created
- && h->plt.refcount > 0)
+ if (htab == NULL)
+ return FALSE;
+
+ if (htab->etab.dynamic_sections_created
+ && eh->plt.refcount > 0)
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && h->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
+ if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
{
/* Allocate these later. From this point on, h->plabel
means that the plt entry is only used by a plabel.
We'll be using a normal plt entry for this symbol, so
clear the plabel indicator. */
- ((struct elf32_hppa_link_hash_entry *) h)->plabel = 0;
+
+ hh->plabel = 0;
}
- else if (((struct elf32_hppa_link_hash_entry *) h)->plabel)
+ else if (hh->plabel)
{
/* Make an entry in the .plt section for plabel references
that won't have a .plt entry for other reasons. */
- s = htab->splt;
- h->plt.offset = s->size;
- s->size += PLT_ENTRY_SIZE;
+ sec = htab->etab.splt;
+ eh->plt.offset = sec->size;
+ sec->size += PLT_ENTRY_SIZE;
+ if (bfd_link_pic (info))
+ htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
}
else
{
/* No .plt entry needed. */
- h->plt.offset = (bfd_vma) -1;
- h->needs_plt = 0;
+ eh->plt.offset = (bfd_vma) -1;
+ eh->needs_plt = 0;
}
}
else
{
- h->plt.offset = (bfd_vma) -1;
- h->needs_plt = 0;
+ eh->plt.offset = (bfd_vma) -1;
+ eh->needs_plt = 0;
}
return TRUE;
}
+/* Calculate size of GOT entries for symbol given its TLS_TYPE. */
+
+static inline unsigned int
+got_entries_needed (int tls_type)
+{
+ unsigned int need = 0;
+
+ if ((tls_type & GOT_NORMAL) != 0)
+ need += GOT_ENTRY_SIZE;
+ if ((tls_type & GOT_TLS_GD) != 0)
+ need += GOT_ENTRY_SIZE * 2;
+ if ((tls_type & GOT_TLS_IE) != 0)
+ need += GOT_ENTRY_SIZE;
+ return need;
+}
+
+/* Calculate size of relocs needed for symbol given its TLS_TYPE and
+ NEEDed GOT entries. TPREL_KNOWN says a TPREL offset can be
+ calculated at link time. DTPREL_KNOWN says the same for a DTPREL
+ offset. */
+
+static inline unsigned int
+got_relocs_needed (int tls_type, unsigned int need,
+ bfd_boolean dtprel_known, bfd_boolean tprel_known)
+{
+ /* All the entries we allocated need relocs.
+ Except for GD and IE with local symbols. */
+ if ((tls_type & GOT_TLS_GD) != 0 && dtprel_known)
+ need -= GOT_ENTRY_SIZE;
+ if ((tls_type & GOT_TLS_IE) != 0 && tprel_known)
+ need -= GOT_ENTRY_SIZE;
+ return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
+}
+
/* Allocate space in .plt, .got and associated reloc sections for
global syms. */
static bfd_boolean
-allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
{
struct bfd_link_info *info;
struct elf32_hppa_link_hash_table *htab;
- asection *s;
- struct elf32_hppa_link_hash_entry *eh;
- struct elf32_hppa_dyn_reloc_entry *p;
+ asection *sec;
+ struct elf32_hppa_link_hash_entry *hh;
+ struct elf_dyn_relocs *hdh_p;
- if (h->root.type == bfd_link_hash_indirect)
+ if (eh->root.type == bfd_link_hash_indirect)
return TRUE;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
info = inf;
htab = hppa_link_hash_table (info);
- if (htab->elf.dynamic_sections_created
- && h->plt.offset != (bfd_vma) -1
- && !((struct elf32_hppa_link_hash_entry *) h)->plabel)
+ if (htab == NULL)
+ return FALSE;
+
+ hh = hppa_elf_hash_entry (eh);
+
+ if (htab->etab.dynamic_sections_created
+ && eh->plt.offset != (bfd_vma) -1
+ && !hh->plabel
+ && eh->plt.refcount > 0)
{
/* Make an entry in the .plt section. */
- s = htab->splt;
- h->plt.offset = s->size;
- s->size += PLT_ENTRY_SIZE;
+ sec = htab->etab.splt;
+ eh->plt.offset = sec->size;
+ sec->size += PLT_ENTRY_SIZE;
/* We also need to make an entry in the .rela.plt section. */
- htab->srelplt->size += sizeof (Elf32_External_Rela);
+ htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
htab->need_plt_stub = 1;
}
- if (h->got.refcount > 0)
+ if (eh->got.refcount > 0)
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && h->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
+ unsigned int need;
- s = htab->sgot;
- h->got.offset = s->size;
- s->size += GOT_ENTRY_SIZE;
- if (htab->elf.dynamic_sections_created
- && (info->shared
- || (h->dynindx != -1
- && !h->forced_local)))
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
+
+ sec = htab->etab.sgot;
+ eh->got.offset = sec->size;
+ need = got_entries_needed (hh->tls_type);
+ sec->size += need;
+ if (htab->etab.dynamic_sections_created
+ && (bfd_link_dll (info)
+ || (bfd_link_pic (info) && (hh->tls_type & GOT_NORMAL) != 0)
+ || (eh->dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, eh)))
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- htab->srelgot->size += sizeof (Elf32_External_Rela);
+ bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);
+ htab->etab.srelgot->size
+ += got_relocs_needed (hh->tls_type, need, local,
+ local && bfd_link_executable (info));
}
}
else
- h->got.offset = (bfd_vma) -1;
+ eh->got.offset = (bfd_vma) -1;
+
+ /* If no dynamic sections we can't have dynamic relocs. */
+ if (!htab->etab.dynamic_sections_created)
+ hh->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 = (struct elf32_hppa_link_hash_entry *) h;
- if (eh->dyn_relocs == NULL)
+ if (hh->dyn_relocs == NULL)
return TRUE;
/* If this is a -Bsymbolic shared link, then we need to discard all
defined in a regular object. For the normal shared case, discard
space for relocs that have become local due to symbol visibility
changes. */
- if (info->shared)
+ if (bfd_link_pic (info))
{
#if RELATIVE_DYNRELOCS
- if (SYMBOL_CALLS_LOCAL (info, h))
+ if (SYMBOL_CALLS_LOCAL (info, eh))
{
- struct elf32_hppa_dyn_reloc_entry **pp;
+ struct elf_dyn_relocs **hdh_pp;
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
+ for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
{
- p->count -= p->relative_count;
- p->relative_count = 0;
- if (p->count == 0)
- *pp = p->next;
+ hdh_p->count -= hdh_p->pc_count;
+ hdh_p->pc_count = 0;
+ if (hdh_p->count == 0)
+ *hdh_pp = hdh_p->next;
else
- pp = &p->next;
+ hdh_pp = &hdh_p->next;
}
}
#endif
- /* Also discard relocs on undefined weak syms with non-default
- visibility. */
- if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
- && h->root.type == bfd_link_hash_undefweak)
- eh->dyn_relocs = NULL;
+ if (hh->dyn_relocs != NULL)
+ {
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
+ }
}
- else
+ else if (ELIMINATE_COPY_RELOCS)
{
/* For the non-shared case, discard space for relocs against
symbols which turn out to need copy relocs or are not
dynamic. */
- if (!h->non_got_ref
- && ((ELIMINATE_COPY_RELOCS
- && h->def_dynamic
- && !h->def_regular)
- || (htab->elf.dynamic_sections_created
- && (h->root.type == bfd_link_hash_undefweak
- || h->root.type == bfd_link_hash_undefined))))
+
+ if (eh->dynamic_adjusted
+ && !eh->def_regular
+ && !ELF_COMMON_DEF_P (eh))
{
- /* Make sure this symbol is output as a dynamic symbol.
- Undefined weak syms won't yet be marked as dynamic. */
- if (h->dynindx == -1
- && !h->forced_local
- && h->type != STT_PARISC_MILLI)
- {
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
- return FALSE;
- }
+ if (!ensure_undef_dynamic (info, eh))
+ return FALSE;
- /* If that succeeded, we know we'll be keeping all the
- relocs. */
- if (h->dynindx != -1)
- goto keep;
+ if (eh->dynindx == -1)
+ hh->dyn_relocs = NULL;
}
-
- eh->dyn_relocs = NULL;
- return TRUE;
-
- keep: ;
+ else
+ hh->dyn_relocs = NULL;
}
/* Finally, allocate space. */
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
- asection *sreloc = elf_section_data (p->sec)->sreloc;
- sreloc->size += p->count * sizeof (Elf32_External_Rela);
+ asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
+ sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
}
return TRUE;
elf_adjust_dynamic_symbol. */
static bfd_boolean
-clobber_millicode_symbols (struct elf_link_hash_entry *h,
+clobber_millicode_symbols (struct elf_link_hash_entry *eh,
struct bfd_link_info *info)
{
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
-
- if (h->type == STT_PARISC_MILLI
- && !h->forced_local)
+ if (eh->type == STT_PARISC_MILLI
+ && !eh->forced_local)
{
- elf32_hppa_hide_symbol (info, h, TRUE);
+ elf32_hppa_hide_symbol (info, eh, TRUE);
}
return TRUE;
}
-/* Find any dynamic relocs that apply to read-only sections. */
+/* Set DF_TEXTREL if we find any dynamic relocs that apply to
+ read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
{
- struct elf32_hppa_link_hash_entry *eh;
- struct elf32_hppa_dyn_reloc_entry *p;
+ asection *sec;
- if (h->root.type == bfd_link_hash_warning)
- h = (struct elf_link_hash_entry *) h->root.u.i.link;
+ if (eh->root.type == bfd_link_hash_indirect)
+ return TRUE;
- eh = (struct elf32_hppa_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ sec = readonly_dynrelocs (eh);
+ if (sec != NULL)
{
- asection *s = p->sec->output_section;
+ struct bfd_link_info *info = (struct bfd_link_info *) inf;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
- {
- struct bfd_link_info *info = inf;
-
- info->flags |= DF_TEXTREL;
+ 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;
- }
+ /* Not an error, just cut short the traversal. */
+ return FALSE;
}
return TRUE;
}
struct elf32_hppa_link_hash_table *htab;
bfd *dynobj;
bfd *ibfd;
- asection *s;
+ asection *sec;
bfd_boolean relocs;
htab = hppa_link_hash_table (info);
- dynobj = htab->elf.dynobj;
+ if (htab == NULL)
+ return FALSE;
+
+ dynobj = htab->etab.dynobj;
if (dynobj == NULL)
abort ();
- if (htab->elf.dynamic_sections_created)
+ if (htab->etab.dynamic_sections_created)
{
/* Set the contents of the .interp section to the interpreter. */
- if (info->executable)
+ if (bfd_link_executable (info) && !info->nointerp)
{
- s = bfd_get_section_by_name (dynobj, ".interp");
- if (s == NULL)
+ sec = bfd_get_linker_section (dynobj, ".interp");
+ if (sec == NULL)
abort ();
- s->size = sizeof ELF_DYNAMIC_INTERPRETER;
- s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
+ sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
+ sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
}
/* Force millicode symbols local. */
- elf_link_hash_traverse (&htab->elf,
+ elf_link_hash_traverse (&htab->etab,
clobber_millicode_symbols,
info);
}
/* Set up .got and .plt offsets for local syms, and space for local
dynamic relocs. */
- for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
+ for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
{
bfd_signed_vma *local_got;
bfd_signed_vma *end_local_got;
bfd_size_type locsymcount;
Elf_Internal_Shdr *symtab_hdr;
asection *srel;
+ char *local_tls_type;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
continue;
- for (s = ibfd->sections; s != NULL; s = s->next)
+ for (sec = ibfd->sections; sec != NULL; sec = sec->next)
{
- struct elf32_hppa_dyn_reloc_entry *p;
+ struct elf_dyn_relocs *hdh_p;
- for (p = ((struct elf32_hppa_dyn_reloc_entry *)
- elf_section_data (s)->local_dynrel);
- p != NULL;
- p = p->next)
+ for (hdh_p = ((struct elf_dyn_relocs *)
+ elf_section_data (sec)->local_dynrel);
+ hdh_p != NULL;
+ hdh_p = hdh_p->next)
{
- if (!bfd_is_abs_section (p->sec)
- && bfd_is_abs_section (p->sec->output_section))
+ if (!bfd_is_abs_section (hdh_p->sec)
+ && bfd_is_abs_section (hdh_p->sec->output_section))
{
/* Input section has been discarded, either because
it is a copy of a linkonce section or due to
linker script /DISCARD/, so we'll be discarding
the relocs too. */
}
- else if (p->count != 0)
+ else if (hdh_p->count != 0)
{
- srel = elf_section_data (p->sec)->sreloc;
- srel->size += p->count * sizeof (Elf32_External_Rela);
- if ((p->sec->output_section->flags & SEC_READONLY) != 0)
+ srel = elf_section_data (hdh_p->sec)->sreloc;
+ srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
+ if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
info->flags |= DF_TEXTREL;
}
}
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
- s = htab->sgot;
- srel = htab->srelgot;
+ local_tls_type = hppa_elf_local_got_tls_type (ibfd);
+ sec = htab->etab.sgot;
+ srel = htab->etab.srelgot;
for (; local_got < end_local_got; ++local_got)
{
if (*local_got > 0)
{
- *local_got = s->size;
- s->size += GOT_ENTRY_SIZE;
- if (info->shared)
- srel->size += sizeof (Elf32_External_Rela);
+ unsigned int need;
+
+ *local_got = sec->size;
+ need = got_entries_needed (*local_tls_type);
+ sec->size += need;
+ if (bfd_link_dll (info)
+ || (bfd_link_pic (info)
+ && (*local_tls_type & GOT_NORMAL) != 0))
+ htab->etab.srelgot->size
+ += got_relocs_needed (*local_tls_type, need, TRUE,
+ bfd_link_executable (info));
}
else
*local_got = (bfd_vma) -1;
+
+ ++local_tls_type;
}
local_plt = end_local_got;
end_local_plt = local_plt + locsymcount;
- if (! htab->elf.dynamic_sections_created)
+ if (! htab->etab.dynamic_sections_created)
{
/* Won't be used, but be safe. */
for (; local_plt < end_local_plt; ++local_plt)
}
else
{
- s = htab->splt;
- srel = htab->srelplt;
+ sec = htab->etab.splt;
+ srel = htab->etab.srelplt;
for (; local_plt < end_local_plt; ++local_plt)
{
if (*local_plt > 0)
{
- *local_plt = s->size;
- s->size += PLT_ENTRY_SIZE;
- if (info->shared)
+ *local_plt = sec->size;
+ sec->size += PLT_ENTRY_SIZE;
+ if (bfd_link_pic (info))
srel->size += sizeof (Elf32_External_Rela);
}
else
}
}
+ if (htab->tls_ldm_got.refcount > 0)
+ {
+ /* Allocate 2 got entries and 1 dynamic reloc for
+ R_PARISC_TLS_DTPMOD32 relocs. */
+ htab->tls_ldm_got.offset = htab->etab.sgot->size;
+ htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
+ htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
+ }
+ else
+ htab->tls_ldm_got.offset = -1;
+
/* Do all the .plt entries without relocs first. The dynamic linker
uses the last .plt reloc to find the end of the .plt (and hence
the start of the .got) for lazy linking. */
- elf_link_hash_traverse (&htab->elf, allocate_plt_static, info);
+ elf_link_hash_traverse (&htab->etab, allocate_plt_static, info);
/* Allocate global sym .plt and .got entries, and space for global
sym dynamic relocs. */
- elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
+ elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
/* The check_relocs and adjust_dynamic_symbol entry points have
determined the sizes of the various dynamic sections. Allocate
memory for them. */
relocs = FALSE;
- for (s = dynobj->sections; s != NULL; s = s->next)
+ for (sec = dynobj->sections; sec != NULL; sec = sec->next)
{
- if ((s->flags & SEC_LINKER_CREATED) == 0)
+ if ((sec->flags & SEC_LINKER_CREATED) == 0)
continue;
- if (s == htab->splt)
+ if (sec == htab->etab.splt)
{
if (htab->need_plt_stub)
{
/* 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->sgot);
- int pltalign = bfd_section_alignment (dynobj, s);
+ 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)
- bfd_set_section_alignment (dynobj, s, gotalign);
+ if (align > pltalign)
+ bfd_set_section_alignment (sec, align);
mask = ((bfd_size_type) 1 << gotalign) - 1;
- s->size = (s->size + sizeof (plt_stub) + mask) & ~mask;
+ sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
}
}
- else if (s == htab->sgot)
+ else if (sec == htab->etab.sgot
+ || sec == htab->etab.sdynbss
+ || sec == htab->etab.sdynrelro)
;
- else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+ else if (CONST_STRNEQ (bfd_section_name (sec), ".rela"))
{
- if (s->size != 0)
+ if (sec->size != 0)
{
/* Remember whether there are any reloc sections other
than .rela.plt. */
- if (s != htab->srelplt)
+ if (sec != htab->etab.srelplt)
relocs = TRUE;
/* We use the reloc_count field as a counter if we need
to copy relocs into the output file. */
- s->reloc_count = 0;
+ sec->reloc_count = 0;
}
}
else
continue;
}
- if (s->size == 0)
+ if (sec->size == 0)
{
/* If we don't need this section, strip it from the
output file. This is mostly to handle .rela.bss and
adjust_dynamic_symbol is called, and it is that
function which decides whether anything needs to go
into these sections. */
- s->flags |= SEC_EXCLUDE;
+ sec->flags |= SEC_EXCLUDE;
continue;
}
+ if ((sec->flags & SEC_HAS_CONTENTS) == 0)
+ continue;
+
/* Allocate memory for the section contents. Zero it, because
we may not fill in all the reloc sections. */
- s->contents = bfd_zalloc (dynobj, s->size);
- if (s->contents == NULL && s->size != 0)
+ sec->contents = bfd_zalloc (dynobj, sec->size);
+ if (sec->contents == NULL)
return FALSE;
}
- if (htab->elf.dynamic_sections_created)
+ 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
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 (!info->shared)
+ if (bfd_link_executable (info))
{
if (!add_dynamic_entry (DT_DEBUG, 0))
return FALSE;
}
- if (htab->srelplt->size != 0)
+ if (htab->etab.srelplt->size != 0)
{
if (!add_dynamic_entry (DT_PLTRELSZ, 0)
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
/* 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->elf, readonly_dynrelocs, info);
+ elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
if ((info->flags & DF_TEXTREL) != 0)
{
{
bfd *input_bfd;
unsigned int bfd_count;
- int top_id, top_index;
+ unsigned int top_id, top_index;
asection *section;
asection **input_list, **list;
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;
- input_bfd = input_bfd->link_next)
+ input_bfd = input_bfd->link.next)
{
bfd_count += 1;
for (section = input_bfd->sections;
{
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. */
export stubs. */
for (bfd_indx = 0;
input_bfd != NULL;
- input_bfd = input_bfd->link_next, bfd_indx++)
+ input_bfd = input_bfd->link.next, bfd_indx++)
{
Elf_Internal_Shdr *symtab_hdr;
all_local_syms[bfd_indx] = local_syms;
- if (info->shared && htab->multi_subspace)
+ if (bfd_link_pic (info) && htab->multi_subspace)
{
- struct elf_link_hash_entry **sym_hashes;
- struct elf_link_hash_entry **end_hashes;
+ struct elf_link_hash_entry **eh_syms;
+ struct elf_link_hash_entry **eh_symend;
unsigned int symcount;
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
- symtab_hdr->sh_info);
- sym_hashes = elf_sym_hashes (input_bfd);
- end_hashes = sym_hashes + symcount;
+ eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd);
+ eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount);
/* Look through the global syms for functions; We need to
build export stubs for all globally visible functions. */
- for (; sym_hashes < end_hashes; sym_hashes++)
+ for (; eh_syms < eh_symend; eh_syms++)
{
- struct elf32_hppa_link_hash_entry *hash;
+ struct elf32_hppa_link_hash_entry *hh;
- hash = (struct elf32_hppa_link_hash_entry *) *sym_hashes;
+ hh = hppa_elf_hash_entry (*eh_syms);
- while (hash->elf.root.type == bfd_link_hash_indirect
- || hash->elf.root.type == bfd_link_hash_warning)
- hash = ((struct elf32_hppa_link_hash_entry *)
- hash->elf.root.u.i.link);
+ 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);
/* At this point in the link, undefined syms have been
resolved, so we need to check that the symbol was
defined in this BFD. */
- if ((hash->elf.root.type == bfd_link_hash_defined
- || hash->elf.root.type == bfd_link_hash_defweak)
- && hash->elf.type == STT_FUNC
- && hash->elf.root.u.def.section->output_section != NULL
- && (hash->elf.root.u.def.section->output_section->owner
+ if ((hh->eh.root.type == bfd_link_hash_defined
+ || hh->eh.root.type == bfd_link_hash_defweak)
+ && hh->eh.type == STT_FUNC
+ && hh->eh.root.u.def.section->output_section != NULL
+ && (hh->eh.root.u.def.section->output_section->owner
== output_bfd)
- && hash->elf.root.u.def.section->owner == input_bfd
- && hash->elf.def_regular
- && !hash->elf.forced_local
- && ELF_ST_VISIBILITY (hash->elf.other) == STV_DEFAULT)
+ && hh->eh.root.u.def.section->owner == input_bfd
+ && hh->eh.def_regular
+ && !hh->eh.forced_local
+ && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT)
{
asection *sec;
const char *stub_name;
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh;
- sec = hash->elf.root.u.def.section;
- stub_name = hash->elf.root.root.string;
- stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
+ sec = hh->eh.root.u.def.section;
+ stub_name = hh_name (hh);
+ hsh = hppa_stub_hash_lookup (&htab->bstab,
stub_name,
FALSE, FALSE);
- if (stub_entry == NULL)
+ if (hsh == NULL)
{
- stub_entry = hppa_add_stub (stub_name, sec, htab);
- if (!stub_entry)
+ hsh = hppa_add_stub (stub_name, sec, htab);
+ if (!hsh)
return -1;
- stub_entry->target_value = hash->elf.root.u.def.value;
- stub_entry->target_section = hash->elf.root.u.def.section;
- stub_entry->stub_type = hppa_stub_export;
- stub_entry->h = hash;
+ hsh->target_value = hh->eh.root.u.def.value;
+ hsh->target_section = hh->eh.root.u.def.section;
+ hsh->stub_type = hppa_stub_export;
+ hsh->hh = hh;
stub_changed = 1;
}
else
{
- (*_bfd_error_handler) (_("%B: duplicate export stub %s"),
- input_bfd,
- stub_name);
+ /* xgettext:c-format */
+ _bfd_error_handler (_("%pB: duplicate export stub %s"),
+ input_bfd, stub_name);
}
}
}
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;
for (input_bfd = info->input_bfds, bfd_indx = 0;
input_bfd != NULL;
- input_bfd = input_bfd->link_next, bfd_indx++)
+ input_bfd = input_bfd->link.next, bfd_indx++)
{
Elf_Internal_Shdr *symtab_hdr;
asection *section;
/* If there aren't any relocs, then there's nothing more
to do. */
if ((section->flags & SEC_RELOC) == 0
+ || (section->flags & SEC_ALLOC) == 0
+ || (section->flags & SEC_LOAD) == 0
+ || (section->flags & SEC_CODE) == 0
|| section->reloc_count == 0)
continue;
{
unsigned int r_type, r_indx;
enum elf32_hppa_stub_type stub_type;
- struct elf32_hppa_stub_hash_entry *stub_entry;
+ struct elf32_hppa_stub_hash_entry *hsh;
asection *sym_sec;
bfd_vma sym_value;
bfd_vma destination;
- struct elf32_hppa_link_hash_entry *hash;
+ struct elf32_hppa_link_hash_entry *hh;
char *stub_name;
const asection *id_sec;
section. */
sym_sec = NULL;
sym_value = 0;
- destination = 0;
- hash = NULL;
+ destination = -1;
+ hh = NULL;
if (r_indx < symtab_hdr->sh_info)
{
/* 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
{
int e_indx;
e_indx = r_indx - symtab_hdr->sh_info;
- hash = ((struct elf32_hppa_link_hash_entry *)
- elf_sym_hashes (input_bfd)[e_indx]);
+ hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]);
- while (hash->elf.root.type == bfd_link_hash_indirect
- || hash->elf.root.type == bfd_link_hash_warning)
- hash = ((struct elf32_hppa_link_hash_entry *)
- hash->elf.root.u.i.link);
+ 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);
- if (hash->elf.root.type == bfd_link_hash_defined
- || hash->elf.root.type == bfd_link_hash_defweak)
+ if (hh->eh.root.type == bfd_link_hash_defined
+ || hh->eh.root.type == bfd_link_hash_defweak)
{
- sym_sec = hash->elf.root.u.def.section;
- sym_value = hash->elf.root.u.def.value;
+ sym_sec = hh->eh.root.u.def.section;
+ sym_value = hh->eh.root.u.def.value;
if (sym_sec->output_section != NULL)
destination = (sym_value + irela->r_addend
+ sym_sec->output_offset
+ sym_sec->output_section->vma);
}
- else if (hash->elf.root.type == bfd_link_hash_undefweak)
+ else if (hh->eh.root.type == bfd_link_hash_undefweak)
{
- if (! info->shared)
+ if (! bfd_link_pic (info))
continue;
}
- else if (hash->elf.root.type == bfd_link_hash_undefined)
+ else if (hh->eh.root.type == bfd_link_hash_undefined)
{
if (! (info->unresolved_syms_in_objects == RM_IGNORE
- && (ELF_ST_VISIBILITY (hash->elf.other)
+ && (ELF_ST_VISIBILITY (hh->eh.other)
== STV_DEFAULT)
- && hash->elf.type != STT_PARISC_MILLI))
+ && hh->eh.type != STT_PARISC_MILLI))
continue;
}
else
}
/* Determine what (if any) linker stub is needed. */
- stub_type = hppa_type_of_stub (section, irela, hash,
+ stub_type = hppa_type_of_stub (section, irela, hh,
destination, info);
if (stub_type == hppa_stub_none)
continue;
id_sec = htab->stub_group[section->id].link_sec;
/* Get the name of this stub. */
- stub_name = hppa_stub_name (id_sec, sym_sec, hash, irela);
+ stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela);
if (!stub_name)
goto error_ret_free_internal;
- stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
+ hsh = hppa_stub_hash_lookup (&htab->bstab,
stub_name,
FALSE, FALSE);
- if (stub_entry != NULL)
+ if (hsh != NULL)
{
/* The proper stub has already been created. */
free (stub_name);
continue;
}
- stub_entry = hppa_add_stub (stub_name, section, htab);
- if (stub_entry == NULL)
+ hsh = hppa_add_stub (stub_name, section, htab);
+ if (hsh == NULL)
{
free (stub_name);
goto error_ret_free_internal;
}
- stub_entry->target_value = sym_value;
- stub_entry->target_section = sym_sec;
- stub_entry->stub_type = stub_type;
- if (info->shared)
+ hsh->target_value = sym_value;
+ hsh->target_section = sym_sec;
+ hsh->stub_type = stub_type;
+ if (bfd_link_pic (info))
{
if (stub_type == hppa_stub_import)
- stub_entry->stub_type = hppa_stub_import_shared;
+ hsh->stub_type = hppa_stub_import_shared;
else if (stub_type == hppa_stub_long_branch)
- stub_entry->stub_type = hppa_stub_long_branch_shared;
+ hsh->stub_type = hppa_stub_long_branch_shared;
}
- stub_entry->h = hash;
+ hsh->hh = hh;
stub_changed = TRUE;
}
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
stub_sec = stub_sec->next)
- stub_sec->size = 0;
+ if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
+ stub_sec->size = 0;
- bfd_hash_traverse (&htab->stub_hash_table, hppa_size_one_stub, htab);
+ bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab);
/* Ask the linker to do its stuff. */
(*htab->layout_sections_again) ();
struct bfd_link_hash_entry *h;
asection *sec = NULL;
bfd_vma gp_val = 0;
- struct elf32_hppa_link_hash_table *htab;
- htab = hppa_link_hash_table (info);
- h = bfd_link_hash_lookup (&htab->elf.root, "$global$", FALSE, FALSE, FALSE);
+ h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
if (h != NULL
&& (h->type == bfd_link_hash_defined
{
if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
{
- /* We know we don't have a .plt. If .got is large,
+ /* We know we don't have a .plt. If .got is large,
offset our LTP. */
- if (sec->size > 0x2000)
+ if (sec->size > 0x2000)
gp_val = 0x2000;
}
}
}
}
- if (sec != NULL && sec->output_section != NULL)
- gp_val += sec->output_section->vma + sec->output_offset;
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ {
+ if (sec != NULL && sec->output_section != NULL)
+ gp_val += sec->output_section->vma + sec->output_offset;
- elf_gp (abfd) = gp_val;
+ elf_gp (abfd) = gp_val;
+ }
return TRUE;
}
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;
stub_sec = stub_sec->next)
- {
- bfd_size_type size;
-
- /* Allocate memory to hold the linker stubs. */
- size = stub_sec->size;
- stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
- if (stub_sec->contents == NULL && size != 0)
- return FALSE;
- stub_sec->size = 0;
- }
+ if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
+ && stub_sec->size != 0)
+ {
+ /* 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;
+ stub_sec->size = 0;
+ }
/* Build the stubs as directed by the stub hash table. */
- table = &htab->stub_hash_table;
+ table = &htab->bstab;
bfd_hash_traverse (table, hppa_build_one_stub, info);
return TRUE;
}
+/* Return the base vma address which should be subtracted from the real
+ address when resolving a dtpoff relocation.
+ This is PT_TLS segment p_vaddr. */
+
+static bfd_vma
+dtpoff_base (struct bfd_link_info *info)
+{
+ /* If tls_sec is NULL, we should have signalled an error already. */
+ if (elf_hash_table (info)->tls_sec == NULL)
+ return 0;
+ return elf_hash_table (info)->tls_sec->vma;
+}
+
+/* Return the relocation value for R_PARISC_TLS_TPOFF*.. */
+
+static bfd_vma
+tpoff (struct bfd_link_info *info, bfd_vma address)
+{
+ struct elf_link_hash_table *htab = elf_hash_table (info);
+
+ /* If tls_sec is NULL, we should have signalled an error already. */
+ if (htab->tls_sec == NULL)
+ return 0;
+ /* hppa TLS ABI is variant I and static TLS block start just after
+ tcbhead structure which has 2 pointer fields. */
+ return (address - htab->tls_sec->vma
+ + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power));
+}
+
/* Perform a final link. */
static bfd_boolean
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;
/* If we're producing a final executable, sort the contents of the
unwind section. */
+ if (bfd_link_relocatable (info))
+ 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
+ || !S_ISREG(buf.st_mode))
+ 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;
+ 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)
{
static bfd_reloc_status_type
final_link_relocate (asection *input_section,
bfd_byte *contents,
- const Elf_Internal_Rela *rel,
+ const Elf_Internal_Rela *rela,
bfd_vma value,
struct elf32_hppa_link_hash_table *htab,
asection *sym_sec,
- struct elf32_hppa_link_hash_entry *h,
+ struct elf32_hppa_link_hash_entry *hh,
struct bfd_link_info *info)
{
int insn;
- unsigned int r_type = ELF32_R_TYPE (rel->r_info);
+ 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;
int r_format = howto->bitsize;
enum hppa_reloc_field_selector_type_alt r_field;
bfd *input_bfd = input_section->owner;
- bfd_vma offset = rel->r_offset;
+ bfd_vma offset = rela->r_offset;
bfd_vma max_branch_offset = 0;
bfd_byte *hit_data = contents + offset;
- bfd_signed_vma addend = rel->r_addend;
+ bfd_signed_vma addend = rela->r_addend;
bfd_vma location;
- struct elf32_hppa_stub_hash_entry *stub_entry = NULL;
+ struct elf32_hppa_stub_hash_entry *hsh = NULL;
int val;
if (r_type == R_PARISC_NONE)
/* If we are not building a shared library, convert DLTIND relocs to
DPREL relocs. */
- if (!info->shared)
+ if (!bfd_link_pic (info))
{
switch (r_type)
{
case R_PARISC_DLTIND21L:
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_IE21L:
r_type = R_PARISC_DPREL21L;
break;
case R_PARISC_DLTIND14R:
+ case R_PARISC_TLS_GD14R:
+ case R_PARISC_TLS_LDM14R:
+ case R_PARISC_TLS_IE14R:
r_type = R_PARISC_DPREL14R;
break;
the stub hash. */
if (sym_sec == NULL
|| sym_sec->output_section == NULL
- || (h != NULL
- && h->elf.plt.offset != (bfd_vma) -1
- && h->elf.dynindx != -1
- && !h->plabel
- && (info->shared
- || !h->elf.def_regular
- || h->elf.root.type == bfd_link_hash_defweak)))
+ || (hh != NULL
+ && hh->eh.plt.offset != (bfd_vma) -1
+ && hh->eh.dynindx != -1
+ && !hh->plabel
+ && (bfd_link_pic (info)
+ || !hh->eh.def_regular
+ || hh->eh.root.type == bfd_link_hash_defweak)))
{
- stub_entry = hppa_get_stub_entry (input_section, sym_sec,
- h, rel, htab);
- if (stub_entry != NULL)
+ hsh = hppa_get_stub_entry (input_section, sym_sec,
+ hh, rela, htab);
+ if (hsh != NULL)
{
- value = (stub_entry->stub_offset
- + stub_entry->stub_sec->output_offset
- + stub_entry->stub_sec->output_section->vma);
+ value = (hsh->stub_offset
+ + hsh->stub_sec->output_offset
+ + hsh->stub_sec->output_section->vma);
addend = 0;
}
- else if (sym_sec == NULL && h != NULL
- && h->elf.root.type == bfd_link_hash_undefweak)
+ else if (sym_sec == NULL && hh != NULL
+ && hh->eh.root.type == bfd_link_hash_undefweak)
{
/* It's OK if undefined weak. Calls to undefined weak
symbols behave as if the "called" function
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)
- {
- /* Convert addil instructions if the original reloc was a
- DLTIND21L. 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))
- insn = ADDIL_DP;
- else
- /* We must have a ldil instruction. It's too hard to find
- and convert the associated add instruction, so issue an
- error. */
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
- input_bfd,
- input_section,
- (long) rel->r_offset,
- howto->name,
- insn);
- }
- else if (orig_r_type == R_PARISC_DLTIND14F)
+ if (orig_r_type != r_type)
{
- /* This must be a format 1 load/store. Change the base
- register to dp. */
- insn = (insn & 0xfc1ffff) | (27 << 21);
+ if (r_type == R_PARISC_DPREL21L)
+ {
+ /* 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))
+ insn = ADDIL_DP;
+ else
+ /* We must have a ldil instruction. It's too hard to find
+ and convert the associated add instruction, so issue an
+ error. */
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): %s fixup for insn %#x "
+ "is not supported in a non-shared link"),
+ input_bfd,
+ input_section,
+ (uint64_t) offset,
+ howto->name,
+ insn);
+ }
+ else if (r_type == R_PARISC_DPREL14F)
+ {
+ /* This must be a format 1 load/store. Change the base
+ register to dp. */
+ insn = (insn & 0xfc1ffff) | (27 << 21);
+ }
}
- /* For all the DP relative relocations, we need to examine the symbol's
- section. If it has no section or if it's a code section, then
- "data pointer relative" makes no sense. In that case we don't
- adjust the "value", and for 21 bit addil instructions, we change the
- source addend register from %dp to %r0. This situation commonly
- arises for undefined weak symbols and when a variable's "constness"
- is declared differently from the way the variable is defined. For
- instance: "extern int foo" with foo defined as "const int foo". */
+ /* For all the DP relative relocations, we need to examine the symbol's
+ section. If it has no section or if it's a code section, then
+ "data pointer relative" makes no sense. In that case we don't
+ adjust the "value", and for 21 bit addil instructions, we change the
+ source addend register from %dp to %r0. This situation commonly
+ arises for undefined weak symbols and when a variable's "constness"
+ is declared differently from the way the variable is defined. For
+ 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)))
case R_PARISC_DLTIND21L:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND14F:
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_IE21L:
+ case R_PARISC_TLS_GD14R:
+ case R_PARISC_TLS_LDM14R:
+ case R_PARISC_TLS_IE14R:
value -= elf_gp (input_section->output_section->owner);
break;
case R_PARISC_DLTIND14F:
case R_PARISC_SEGBASE:
case R_PARISC_SEGREL32:
+ case R_PARISC_TLS_DTPMOD32:
+ case R_PARISC_TLS_DTPOFF32:
+ case R_PARISC_TLS_TPREL32:
r_field = e_fsel;
break;
case R_PARISC_DIR21L:
case R_PARISC_DPREL21L:
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_LDO21L:
+ case R_PARISC_TLS_IE21L:
+ case R_PARISC_TLS_LE21L:
r_field = e_lrsel;
break;
case R_PARISC_DIR17R:
case R_PARISC_DIR14R:
case R_PARISC_DPREL14R:
+ case R_PARISC_TLS_GD14R:
+ case R_PARISC_TLS_LDM14R:
+ case R_PARISC_TLS_LDO14R:
+ case R_PARISC_TLS_IE14R:
+ case R_PARISC_TLS_LE14R:
r_field = e_rrsel;
break;
call to the local stub for this function. */
if (value + addend + max_branch_offset >= 2*max_branch_offset)
{
- stub_entry = hppa_get_stub_entry (input_section, sym_sec,
- h, rel, htab);
- if (stub_entry == NULL)
+ hsh = hppa_get_stub_entry (input_section, sym_sec,
+ hh, rela, htab);
+ if (hsh == NULL)
return bfd_reloc_undefined;
/* Munge up the value and addend so that we call the stub
rather than the procedure directly. */
- value = (stub_entry->stub_offset
- + stub_entry->stub_sec->output_offset
- + stub_entry->stub_sec->output_section->vma
+ value = (hsh->stub_offset
+ + hsh->stub_sec->output_offset
+ + hsh->stub_sec->output_section->vma
- location);
addend = -8;
}
if (max_branch_offset != 0
&& value + addend + max_branch_offset >= 2*max_branch_offset)
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): cannot reach %s, "
+ "recompile with -ffunction-sections"),
input_bfd,
input_section,
- (long) rel->r_offset,
- stub_entry->root.string);
+ (uint64_t) offset,
+ hsh->bh_root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
}
bfd_vma *local_got_offsets;
struct elf32_hppa_link_hash_table *htab;
Elf_Internal_Shdr *symtab_hdr;
- Elf_Internal_Rela *rel;
+ Elf_Internal_Rela *rela;
Elf_Internal_Rela *relend;
- if (info->relocatable)
- return TRUE;
-
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);
- rel = relocs;
+ rela = relocs;
relend = relocs + input_section->reloc_count;
- for (; rel < relend; rel++)
+ for (; rela < relend; rela++)
{
unsigned int r_type;
reloc_howto_type *howto;
unsigned int r_symndx;
- struct elf32_hppa_link_hash_entry *h;
+ struct elf32_hppa_link_hash_entry *hh;
Elf_Internal_Sym *sym;
asection *sym_sec;
bfd_vma relocation;
- bfd_reloc_status_type r;
+ bfd_reloc_status_type rstatus;
const char *sym_name;
bfd_boolean plabel;
bfd_boolean warned_undef;
- r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rela->r_info);
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
{
bfd_set_error (bfd_error_bad_value);
|| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
continue;
- /* This is a final link. */
- r_symndx = ELF32_R_SYM (rel->r_info);
- h = NULL;
+ r_symndx = ELF32_R_SYM (rela->r_info);
+ hh = NULL;
sym = NULL;
sym_sec = NULL;
warned_undef = FALSE;
/* This is a local symbol, h defaults to NULL. */
sym = local_syms + r_symndx;
sym_sec = local_sections[r_symndx];
- relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
+ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela);
}
else
{
- struct elf_link_hash_entry *hh;
- bfd_boolean unresolved_reloc;
+ struct elf_link_hash_entry *eh;
+ bfd_boolean unresolved_reloc, ignored;
struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
- RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
+ RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
r_symndx, symtab_hdr, sym_hashes,
- hh, sym_sec, relocation,
- unresolved_reloc, warned_undef);
-
- if (relocation == 0
- && hh->root.type != bfd_link_hash_defined
- && hh->root.type != bfd_link_hash_defweak
- && hh->root.type != bfd_link_hash_undefweak)
+ eh, sym_sec, relocation,
+ unresolved_reloc, warned_undef,
+ ignored);
+
+ if (!bfd_link_relocatable (info)
+ && relocation == 0
+ && eh->root.type != bfd_link_hash_defined
+ && eh->root.type != bfd_link_hash_defweak
+ && eh->root.type != bfd_link_hash_undefweak)
{
if (info->unresolved_syms_in_objects == RM_IGNORE
- && ELF_ST_VISIBILITY (hh->other) == STV_DEFAULT
- && hh->type == STT_PARISC_MILLI)
+ && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
+ && eh->type == STT_PARISC_MILLI)
{
- if (! info->callbacks->undefined_symbol
- (info, hh->root.root.string, input_bfd,
- input_section, rel->r_offset, FALSE))
- return FALSE;
+ (*info->callbacks->undefined_symbol)
+ (info, eh_name (eh), input_bfd,
+ input_section, rela->r_offset, FALSE);
warned_undef = TRUE;
}
}
- h = (struct elf32_hppa_link_hash_entry *) hh;
+ hh = hppa_elf_hash_entry (eh);
}
+ if (sym_sec != NULL && discarded_section (sym_sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rela, 1, relend,
+ elf_hppa_howto_table + r_type, 0,
+ contents);
+
+ if (bfd_link_relocatable (info))
+ continue;
+
/* Do any required modifications to the relocation value, and
determine what types of dynamic info we need to output, if
any. */
case R_PARISC_DLTIND21L:
{
bfd_vma off;
- bfd_boolean do_got = 0;
+ bfd_boolean do_got = FALSE;
+ bfd_boolean reloc = bfd_link_pic (info);
/* Relocation is to the entry for this symbol in the
global offset table. */
- if (h != NULL)
+ if (hh != NULL)
{
bfd_boolean dyn;
- off = h->elf.got.offset;
- dyn = htab->elf.dynamic_sections_created;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
- &h->elf))
+ off = hh->eh.got.offset;
+ dyn = htab->etab.dynamic_sections_created;
+ reloc = (!UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)
+ && (reloc
+ || (hh->eh.dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))));
+ if (!reloc
+ || !WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
+ bfd_link_pic (info),
+ &hh->eh))
{
/* If we aren't going to call finish_dynamic_symbol,
then we need to handle initialisation of the .got
off &= ~1;
else
{
- h->elf.got.offset |= 1;
- do_got = 1;
+ hh->eh.got.offset |= 1;
+ do_got = TRUE;
}
}
}
else
{
local_got_offsets[r_symndx] |= 1;
- do_got = 1;
+ do_got = TRUE;
}
}
if (do_got)
{
- if (info->shared)
+ if (reloc)
{
/* Output a dynamic relocation for this GOT entry.
In this case it is relative to the base of the
object because the symbol index is zero. */
Elf_Internal_Rela outrel;
bfd_byte *loc;
- asection *s = htab->srelgot;
+ asection *sec = htab->etab.srelgot;
outrel.r_offset = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
outrel.r_addend = relocation;
- loc = s->contents;
- loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
+ loc = sec->contents;
+ loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
else
bfd_put_32 (output_bfd, relocation,
- htab->sgot->contents + off);
+ htab->etab.sgot->contents + off);
}
if (off >= (bfd_vma) -2)
/* Add the base of the GOT to the relocation value. */
relocation = (off
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
}
break;
case R_PARISC_PLABEL14R:
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
- if (htab->elf.dynamic_sections_created)
+ if (htab->etab.dynamic_sections_created)
{
bfd_vma off;
bfd_boolean do_plt = 0;
-
/* If we have a global symbol with a PLT slot, then
redirect this relocation to it. */
- if (h != NULL)
+ if (hh != NULL)
{
- off = h->elf.plt.offset;
- if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared,
- &h->elf))
+ off = hh->eh.plt.offset;
+ if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1,
+ bfd_link_pic (info),
+ &hh->eh))
{
- /* In a non-shared link, adjust_dynamic_symbols
+ /* In a non-shared link, adjust_dynamic_symbol
isn't called for symbols forced local. We
need to write out the plt entry here. */
if ((off & 1) != 0)
off &= ~1;
else
{
- h->elf.plt.offset |= 1;
+ hh->eh.plt.offset |= 1;
do_plt = 1;
}
}
if (do_plt)
{
- if (info->shared)
+ if (bfd_link_pic (info))
{
/* Output a dynamic IPLT relocation for this
PLT entry. */
Elf_Internal_Rela outrel;
bfd_byte *loc;
- asection *s = htab->srelplt;
+ asection *s = htab->etab.srelplt;
outrel.r_offset = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma);
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma);
outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
outrel.r_addend = relocation;
loc = s->contents;
{
bfd_put_32 (output_bfd,
relocation,
- htab->splt->contents + off);
+ htab->etab.splt->contents + off);
bfd_put_32 (output_bfd,
- elf_gp (htab->splt->output_section->owner),
- htab->splt->contents + off + 4);
+ elf_gp (htab->etab.splt->output_section->owner),
+ htab->etab.splt->contents + off + 4);
}
}
is in the .plt and thus has a gp pointer too.
Exception: Undefined PLABELs should have a value of
zero. */
- if (h == NULL
- || (h->elf.root.type != bfd_link_hash_undefweak
- && h->elf.root.type != bfd_link_hash_undefined))
+ if (hh == NULL
+ || (hh->eh.root.type != bfd_link_hash_undefweak
+ && hh->eh.root.type != bfd_link_hash_undefined))
{
relocation = (off
- + htab->splt->output_offset
- + htab->splt->output_section->vma
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ 2);
}
plabel = 1;
}
- /* Fall through and possibly emit a dynamic relocation. */
+ /* Fall through. */
case R_PARISC_DIR17F:
case R_PARISC_DIR17R:
case R_PARISC_DPREL14R:
case R_PARISC_DPREL21L:
case R_PARISC_DIR32:
- /* r_symndx will be zero only for relocs against symbols
- from removed linkonce sections, or sections discarded by
- a linker script. */
- if (r_symndx == 0
- || (input_section->flags & SEC_ALLOC) == 0)
+ if ((input_section->flags & SEC_ALLOC) == 0)
break;
- /* The reloc types handled here and this conditional
- expression must match the code in ..check_relocs and
- allocate_dynrelocs. ie. We need exactly the same condition
- as in ..check_relocs, with some extra conditions (dynindx
- test in this case) to cater for relocs removed by
- allocate_dynrelocs. If you squint, the non-shared test
- here does indeed match the one in ..check_relocs, the
- difference being that here we test DEF_DYNAMIC as well as
- !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
- which is why we can't use just that test here.
- Conversely, DEF_DYNAMIC can't be used in check_relocs as
- there all files have not been loaded. */
- if ((info->shared
- && (h == NULL
- || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
- || h->elf.root.type != bfd_link_hash_undefweak)
- && (IS_ABSOLUTE_RELOC (r_type)
- || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
- || (!info->shared
- && h != NULL
- && h->elf.dynindx != -1
- && !h->elf.non_got_ref
- && ((ELIMINATE_COPY_RELOCS
- && h->elf.def_dynamic
- && !h->elf.def_regular)
- || h->elf.root.type == bfd_link_hash_undefweak
- || h->elf.root.type == bfd_link_hash_undefined)))
+ if (bfd_link_pic (info)
+ ? ((hh == NULL
+ || hh->dyn_relocs != NULL)
+ && ((hh != NULL && pc_dynrelocs (hh))
+ || IS_ABSOLUTE_RELOC (r_type)))
+ : (hh != NULL
+ && hh->dyn_relocs != NULL))
{
Elf_Internal_Rela outrel;
bfd_boolean skip;
are copied into the output file to be resolved at run
time. */
- outrel.r_addend = rel->r_addend;
+ outrel.r_addend = rela->r_addend;
outrel.r_offset =
_bfd_elf_section_offset (output_bfd, info, input_section,
- rel->r_offset);
+ rela->r_offset);
skip = (outrel.r_offset == (bfd_vma) -1
|| outrel.r_offset == (bfd_vma) -2);
outrel.r_offset += (input_section->output_offset
{
memset (&outrel, 0, sizeof (outrel));
}
- else if (h != NULL
- && h->elf.dynindx != -1
+ else if (hh != NULL
+ && hh->eh.dynindx != -1
&& (plabel
|| !IS_ABSOLUTE_RELOC (r_type)
- || !info->shared
- || !info->symbolic
- || !h->elf.def_regular))
+ || !bfd_link_pic (info)
+ || !SYMBOLIC_BIND (info, &hh->eh)
+ || !hh->eh.def_regular))
{
- outrel.r_info = ELF32_R_INFO (h->elf.dynindx, r_type);
+ outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
}
else /* It's a local symbol, or one marked to become local. */
{
&& sym_sec->output_section != NULL
&& ! bfd_is_abs_section (sym_sec))
{
- /* Skip this relocation if the output section has
- been discarded. */
- if (bfd_is_abs_section (sym_sec->output_section))
- break;
+ asection *osec;
+
+ osec = sym_sec->output_section;
+ indx = elf_section_data (osec)->dynindx;
+ if (indx == 0)
+ {
+ osec = htab->etab.text_index_section;
+ indx = elf_section_data (osec)->dynindx;
+ }
+ BFD_ASSERT (indx != 0);
- indx = elf_section_data (sym_sec->output_section)->dynindx;
/* We are turning this relocation into one
against a section symbol, so subtract out the
output section's address but not the offset
of the input section in the output section. */
- outrel.r_addend -= sym_sec->output_section->vma;
+ outrel.r_addend -= osec->vma;
}
outrel.r_info = ELF32_R_INFO (indx, r_type);
}
break;
+ case R_PARISC_TLS_LDM21L:
+ case R_PARISC_TLS_LDM14R:
+ {
+ bfd_vma off;
+
+ off = htab->tls_ldm_got.offset;
+ if (off & 1)
+ off &= ~1;
+ else
+ {
+ Elf_Internal_Rela outrel;
+ bfd_byte *loc;
+
+ outrel.r_offset = (off
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
+ outrel.r_addend = 0;
+ outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
+ loc = htab->etab.srelgot->contents;
+ loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
+
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+ htab->tls_ldm_got.offset |= 1;
+ }
+
+ /* Add the base of the GOT to the relocation value. */
+ relocation = (off
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
+
+ break;
+ }
+
+ case R_PARISC_TLS_LDO21L:
+ case R_PARISC_TLS_LDO14R:
+ relocation -= dtpoff_base (info);
+ break;
+
+ case R_PARISC_TLS_GD21L:
+ case R_PARISC_TLS_GD14R:
+ case R_PARISC_TLS_IE21L:
+ case R_PARISC_TLS_IE14R:
+ {
+ bfd_vma off;
+ int indx;
+ char tls_type;
+
+ indx = 0;
+ if (hh != NULL)
+ {
+ if (!htab->etab.dynamic_sections_created
+ || hh->eh.dynindx == -1
+ || SYMBOL_REFERENCES_LOCAL (info, &hh->eh)
+ || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))
+ /* This is actually a static link, or it is a
+ -Bsymbolic link and the symbol is defined
+ locally, or the symbol was forced to be local
+ because of a version file. */
+ ;
+ else
+ indx = hh->eh.dynindx;
+ off = hh->eh.got.offset;
+ tls_type = hh->tls_type;
+ }
+ else
+ {
+ off = local_got_offsets[r_symndx];
+ tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx];
+ }
+
+ if (tls_type == GOT_UNKNOWN)
+ abort ();
+
+ if ((off & 1) != 0)
+ off &= ~1;
+ else
+ {
+ bfd_boolean need_relocs = FALSE;
+ Elf_Internal_Rela outrel;
+ bfd_byte *loc = NULL;
+ int cur_off = off;
+
+ /* The GOT entries have not been initialized yet. Do it
+ now, and emit any relocations. If both an IE GOT and a
+ GD GOT are necessary, we emit the GD first. */
+
+ if (indx != 0
+ || (bfd_link_dll (info)
+ && (hh == NULL
+ || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
+ {
+ need_relocs = TRUE;
+ loc = htab->etab.srelgot->contents;
+ loc += (htab->etab.srelgot->reloc_count
+ * sizeof (Elf32_External_Rela));
+ }
+
+ if (tls_type & GOT_TLS_GD)
+ {
+ if (need_relocs)
+ {
+ outrel.r_offset
+ = (cur_off
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
+ outrel.r_info
+ = ELF32_R_INFO (indx, R_PARISC_TLS_DTPMOD32);
+ outrel.r_addend = 0;
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+ htab->etab.srelgot->reloc_count++;
+ loc += sizeof (Elf32_External_Rela);
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + cur_off);
+ }
+ else
+ /* If we are not emitting relocations for a
+ general dynamic reference, then we must be in a
+ static link or an executable link with the
+ symbol binding locally. Mark it as belonging
+ to module 1, the executable. */
+ bfd_put_32 (output_bfd, 1,
+ htab->etab.sgot->contents + cur_off);
+
+ if (indx != 0)
+ {
+ outrel.r_info
+ = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
+ outrel.r_offset += 4;
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+ htab->etab.srelgot->reloc_count++;
+ loc += sizeof (Elf32_External_Rela);
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + cur_off + 4);
+ }
+ else
+ bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
+ htab->etab.sgot->contents + cur_off + 4);
+ cur_off += 8;
+ }
+
+ if (tls_type & GOT_TLS_IE)
+ {
+ if (need_relocs
+ && !(bfd_link_executable (info)
+ && SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
+ {
+ outrel.r_offset
+ = (cur_off
+ + htab->etab.sgot->output_section->vma
+ + htab->etab.sgot->output_offset);
+ outrel.r_info = ELF32_R_INFO (indx,
+ R_PARISC_TLS_TPREL32);
+ if (indx == 0)
+ outrel.r_addend = relocation - dtpoff_base (info);
+ else
+ outrel.r_addend = 0;
+ bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
+ htab->etab.srelgot->reloc_count++;
+ loc += sizeof (Elf32_External_Rela);
+ }
+ else
+ bfd_put_32 (output_bfd, tpoff (info, relocation),
+ htab->etab.sgot->contents + cur_off);
+ cur_off += 4;
+ }
+
+ if (hh != NULL)
+ hh->eh.got.offset |= 1;
+ else
+ local_got_offsets[r_symndx] |= 1;
+ }
+
+ if ((tls_type & GOT_NORMAL) != 0
+ && (tls_type & (GOT_TLS_GD | GOT_TLS_LDM | GOT_TLS_IE)) != 0)
+ {
+ if (hh != NULL)
+ _bfd_error_handler (_("%s has both normal and TLS relocs"),
+ hh_name (hh));
+ else
+ {
+ Elf_Internal_Sym *isym
+ = bfd_sym_from_r_symndx (&htab->sym_cache,
+ input_bfd, r_symndx);
+ if (isym == NULL)
+ 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;
+ if (*sym_name == '\0')
+ 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;
+ }
+
+ if ((tls_type & GOT_TLS_GD)
+ && r_type != R_PARISC_TLS_GD21L
+ && r_type != R_PARISC_TLS_GD14R)
+ off += 2 * GOT_ENTRY_SIZE;
+
+ /* Add the base of the GOT to the relocation value. */
+ relocation = (off
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
+
+ break;
+ }
+
+ case R_PARISC_TLS_LE21L:
+ case R_PARISC_TLS_LE14R:
+ {
+ relocation = tpoff (info, relocation);
+ break;
+ }
+ break;
+
default:
break;
}
- r = final_link_relocate (input_section, contents, rel, relocation,
- htab, sym_sec, h, info);
+ rstatus = final_link_relocate (input_section, contents, rela, relocation,
+ htab, sym_sec, hh, info);
- if (r == bfd_reloc_ok)
+ if (rstatus == bfd_reloc_ok)
continue;
- if (h != NULL)
- sym_name = h->elf.root.root.string;
+ if (hh != NULL)
+ sym_name = hh_name (hh);
else
{
sym_name = bfd_elf_string_from_elf_section (input_bfd,
if (sym_name == NULL)
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;
- if (r == bfd_reloc_undefined || r == bfd_reloc_notsupported)
+ if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported)
{
- if (r == bfd_reloc_notsupported || !warned_undef)
+ if (rstatus == bfd_reloc_notsupported || !warned_undef)
{
- (*_bfd_error_handler)
- (_("%B(%A+0x%lx): cannot handle %s for %s"),
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%pB(%pA+%#" PRIx64 "): cannot handle %s for %s"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (uint64_t) rela->r_offset,
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
}
}
else
- {
- if (!((*info->callbacks->reloc_overflow)
- (info, (h ? &h->elf.root : NULL), sym_name, howto->name,
- (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
- return FALSE;
- }
+ (*info->callbacks->reloc_overflow)
+ (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rela->r_offset);
}
return TRUE;
static bfd_boolean
elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
struct bfd_link_info *info,
- struct elf_link_hash_entry *h,
+ struct elf_link_hash_entry *eh,
Elf_Internal_Sym *sym)
{
struct elf32_hppa_link_hash_table *htab;
- Elf_Internal_Rela rel;
+ Elf_Internal_Rela rela;
bfd_byte *loc;
htab = hppa_link_hash_table (info);
+ if (htab == NULL)
+ return FALSE;
- if (h->plt.offset != (bfd_vma) -1)
+ if (eh->plt.offset != (bfd_vma) -1)
{
bfd_vma value;
- if (h->plt.offset & 1)
+ if (eh->plt.offset & 1)
abort ();
/* This symbol has an entry in the procedure linkage table. Set
<__gp>
*/
value = 0;
- if (h->root.type == bfd_link_hash_defined
- || h->root.type == bfd_link_hash_defweak)
+ if (eh->root.type == bfd_link_hash_defined
+ || eh->root.type == bfd_link_hash_defweak)
{
- value = h->root.u.def.value;
- if (h->root.u.def.section->output_section != NULL)
- value += (h->root.u.def.section->output_offset
- + h->root.u.def.section->output_section->vma);
+ value = eh->root.u.def.value;
+ if (eh->root.u.def.section->output_section != NULL)
+ value += (eh->root.u.def.section->output_offset
+ + eh->root.u.def.section->output_section->vma);
}
/* Create a dynamic IPLT relocation for this entry. */
- rel.r_offset = (h->plt.offset
- + htab->splt->output_offset
- + htab->splt->output_section->vma);
- if (h->dynindx != -1)
+ rela.r_offset = (eh->plt.offset
+ + htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma);
+ if (eh->dynindx != -1)
{
- rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_IPLT);
- rel.r_addend = 0;
+ rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
+ rela.r_addend = 0;
}
else
{
/* This symbol has been marked to become local, and is
used by a plabel so must be kept in the .plt. */
- rel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
- rel.r_addend = value;
+ rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
+ rela.r_addend = value;
}
- loc = htab->srelplt->contents;
- loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rel, loc);
+ loc = htab->etab.srelplt->contents;
+ loc += htab->etab.srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
+ bfd_elf32_swap_reloca_out (htab->etab.splt->output_section->owner, &rela, loc);
- if (!h->def_regular)
+ if (!eh->def_regular)
{
/* Mark the symbol as undefined, rather than as defined in
the .plt section. Leave the value alone. */
}
}
- if (h->got.offset != (bfd_vma) -1)
+ if (eh->got.offset != (bfd_vma) -1
+ && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
+ && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
{
- /* This symbol has an entry in the global offset table. Set it
- up. */
-
- rel.r_offset = ((h->got.offset &~ (bfd_vma) 1)
- + htab->sgot->output_offset
- + htab->sgot->output_section->vma);
-
- /* If this is a -Bsymbolic link and the symbol is defined
- locally or was forced to be local because of a version file,
- we just want to emit a RELATIVE reloc. The entry in the
- global offset table will already have been initialized in the
- relocate_section function. */
- if (info->shared
- && (info->symbolic || h->dynindx == -1)
- && h->def_regular)
- {
- rel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
- rel.r_addend = (h->root.u.def.value
- + h->root.u.def.section->output_offset
- + h->root.u.def.section->output_section->vma);
- }
- else
+ bfd_boolean is_dyn = (eh->dynindx != -1
+ && !SYMBOL_REFERENCES_LOCAL (info, eh));
+
+ if (is_dyn || bfd_link_pic (info))
{
- if ((h->got.offset & 1) != 0)
- abort ();
- bfd_put_32 (output_bfd, 0, htab->sgot->contents + h->got.offset);
- rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_DIR32);
- rel.r_addend = 0;
- }
+ /* This symbol has an entry in the global offset table. Set
+ it up. */
+
+ rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
+ + htab->etab.sgot->output_offset
+ + htab->etab.sgot->output_section->vma);
+
+ /* If this is a -Bsymbolic link and the symbol is defined
+ locally or was forced to be local because of a version
+ file, we just want to emit a RELATIVE reloc. The entry
+ in the global offset table will already have been
+ initialized in the relocate_section function. */
+ if (!is_dyn)
+ {
+ rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
+ rela.r_addend = (eh->root.u.def.value
+ + eh->root.u.def.section->output_offset
+ + eh->root.u.def.section->output_section->vma);
+ }
+ else
+ {
+ if ((eh->got.offset & 1) != 0)
+ abort ();
- loc = htab->srelgot->contents;
- loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
+ bfd_put_32 (output_bfd, 0,
+ htab->etab.sgot->contents + (eh->got.offset & ~1));
+ rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
+ rela.r_addend = 0;
+ }
+
+ loc = htab->etab.srelgot->contents;
+ loc += (htab->etab.srelgot->reloc_count++
+ * sizeof (Elf32_External_Rela));
+ bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
+ }
}
- if (h->needs_copy)
+ if (eh->needs_copy)
{
- asection *s;
+ asection *sec;
/* This symbol needs a copy reloc. Set it up. */
- if (! (h->dynindx != -1
- && (h->root.type == bfd_link_hash_defined
- || h->root.type == bfd_link_hash_defweak)))
+ if (! (eh->dynindx != -1
+ && (eh->root.type == bfd_link_hash_defined
+ || eh->root.type == bfd_link_hash_defweak)))
abort ();
- s = htab->srelbss;
-
- rel.r_offset = (h->root.u.def.value
- + h->root.u.def.section->output_offset
- + h->root.u.def.section->output_section->vma);
- rel.r_addend = 0;
- rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_COPY);
- loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
- bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
+ rela.r_offset = (eh->root.u.def.value
+ + eh->root.u.def.section->output_offset
+ + eh->root.u.def.section->output_section->vma);
+ rela.r_addend = 0;
+ rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
+ if (eh->root.u.def.section == htab->etab.sdynrelro)
+ sec = htab->etab.sreldynrelro;
+ else
+ sec = htab->etab.srelbss;
+ loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
+ bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
}
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
- if (h->root.root.string[0] == '_'
- && (strcmp (h->root.root.string, "_DYNAMIC") == 0
- || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0))
+ if (eh == htab->etab.hdynamic || eh == htab->etab.hgot)
{
sym->st_shndx = SHN_ABS;
}
dynamic linker, before writing them out. */
static enum elf_reloc_type_class
-elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela)
+elf32_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
+ const asection *rel_sec ATTRIBUTE_UNUSED,
+ const Elf_Internal_Rela *rela)
{
- if (ELF32_R_SYM (rela->r_info) == 0)
+ /* Handle TLS relocs first; we don't want them to be marked
+ relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
+ check below. */
+ switch ((int) ELF32_R_TYPE (rela->r_info))
+ {
+ case R_PARISC_TLS_DTPMOD32:
+ case R_PARISC_TLS_DTPOFF32:
+ case R_PARISC_TLS_TPREL32:
+ return reloc_class_normal;
+ }
+
+ if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
return reloc_class_relative;
switch ((int) ELF32_R_TYPE (rela->r_info))
bfd *dynobj;
struct elf32_hppa_link_hash_table *htab;
asection *sdyn;
+ asection * sgot;
htab = hppa_link_hash_table (info);
- dynobj = htab->elf.dynobj;
+ if (htab == NULL)
+ return FALSE;
+
+ dynobj = htab->etab.dynobj;
+
+ sgot = htab->etab.sgot;
+ /* 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;
- sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
+ sdyn = bfd_get_linker_section (dynobj, ".dynamic");
- if (htab->elf.dynamic_sections_created)
+ if (htab->etab.dynamic_sections_created)
{
Elf32_External_Dyn *dyncon, *dynconend;
break;
case DT_JMPREL:
- s = htab->srelplt;
+ s = htab->etab.srelplt;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
break;
case DT_PLTRELSZ:
- s = htab->srelplt;
+ s = htab->etab.srelplt;
dyn.d_un.d_val = s->size;
break;
-
- case DT_RELASZ:
- /* Don't count procedure linkage table relocs in the
- overall reloc count. */
- s = htab->srelplt;
- if (s == NULL)
- continue;
- dyn.d_un.d_val -= s->size;
- break;
-
- case DT_RELA:
- /* We may not be using the standard ELF linker script.
- If .rela.plt is the first .rela section, we adjust
- DT_RELA to not include it. */
- s = htab->srelplt;
- if (s == NULL)
- continue;
- if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
- continue;
- dyn.d_un.d_ptr += s->size;
- break;
}
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
}
}
- if (htab->sgot != NULL && htab->sgot->size != 0)
+ if (sgot != NULL && sgot->size != 0)
{
/* Fill in the first entry in the global offset table.
We use it to point to our dynamic section, if we have one. */
bfd_put_32 (output_bfd,
sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
- htab->sgot->contents);
+ sgot->contents);
/* The second entry is reserved for use by the dynamic linker. */
- memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
+ memset (sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
/* Set .got entry size. */
- elf_section_data (htab->sgot->output_section)
+ elf_section_data (sgot->output_section)
->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
}
- if (htab->splt != NULL && htab->splt->size != 0)
+ if (htab->etab.splt != NULL && htab->etab.splt->size != 0)
{
- /* Set plt entry size. */
- elf_section_data (htab->splt->output_section)
- ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
+ /* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
+ plt stubs and as such the section does not hold a table of fixed-size
+ entries. */
+ elf_section_data (htab->etab.splt->output_section)->this_hdr.sh_entsize = 0;
if (htab->need_plt_stub)
{
/* Set up the .plt stub. */
- memcpy (htab->splt->contents
- + htab->splt->size - sizeof (plt_stub),
+ memcpy (htab->etab.splt->contents
+ + htab->etab.splt->size - sizeof (plt_stub),
plt_stub, sizeof (plt_stub));
- if ((htab->splt->output_offset
- + htab->splt->output_section->vma
- + htab->splt->size)
- != (htab->sgot->output_offset
- + htab->sgot->output_section->vma))
+ if ((htab->etab.splt->output_offset
+ + htab->etab.splt->output_section->vma
+ + htab->etab.splt->size)
+ != (sgot->output_offset
+ + sgot->output_section->vma))
{
- (*_bfd_error_handler)
+ _bfd_error_handler
(_(".got section not immediately after .plt section"));
return FALSE;
}
return TRUE;
}
-/* Tweak the OSABI field of the elf header. */
-
-static void
-elf32_hppa_post_process_headers (bfd *abfd,
- struct bfd_link_info *info ATTRIBUTE_UNUSED)
-{
- Elf_Internal_Ehdr * i_ehdrp;
-
- i_ehdrp = elf_elfheader (abfd);
-
- if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
- {
- i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
- }
- else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
- {
- i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_NETBSD;
- }
- else
- {
- i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
- }
-}
-
/* Called when writing out an object file to decide the type of a
symbol. */
static int
/* 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
/* Stuff for the BFD linker. */
#define bfd_elf32_bfd_final_link elf32_hppa_final_link
#define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
-#define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free
#define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
#define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
#define elf_backend_check_relocs elf32_hppa_check_relocs
+#define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
#define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
#define elf_backend_fake_sections elf_hppa_fake_sections
#define elf_backend_relocate_section elf32_hppa_relocate_section
#define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
#define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
#define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
+#define elf_backend_init_index_section _bfd_elf_init_1_index_section
#define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
-#define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
#define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
#define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
#define elf_backend_object_p elf32_hppa_object_p
#define elf_backend_final_write_processing elf_hppa_final_write_processing
-#define elf_backend_post_process_headers elf32_hppa_post_process_headers
#define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
#define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
+#define elf_backend_action_discarded elf_hppa_action_discarded
#define elf_backend_can_gc_sections 1
#define elf_backend_can_refcount 1
#define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 8
+#define elf_backend_want_dynrelro 1
#define elf_backend_rela_normal 1
+#define elf_backend_dtrel_excludes_plt 1
+#define elf_backend_no_page_alias 1
-#define TARGET_BIG_SYM bfd_elf32_hppa_vec
+#define TARGET_BIG_SYM hppa_elf32_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
+#define elf32_bed elf32_hppa_hpux_bed
#include "elf32-target.h"
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
+#define TARGET_BIG_SYM hppa_elf32_linux_vec
#undef TARGET_BIG_NAME
-#define TARGET_BIG_NAME "elf32-hppa-linux"
+#define TARGET_BIG_NAME "elf32-hppa-linux"
+#undef ELF_OSABI
+#define ELF_OSABI ELFOSABI_GNU
+#undef elf32_bed
+#define elf32_bed elf32_hppa_linux_bed
-#define INCLUDED_TARGET_FILE 1
#include "elf32-target.h"
#undef TARGET_BIG_SYM
-#define TARGET_BIG_SYM bfd_elf32_hppa_nbsd_vec
+#define TARGET_BIG_SYM hppa_elf32_nbsd_vec
#undef TARGET_BIG_NAME
-#define TARGET_BIG_NAME "elf32-hppa-netbsd"
+#define TARGET_BIG_NAME "elf32-hppa-netbsd"
+#undef ELF_OSABI
+#define ELF_OSABI ELFOSABI_NETBSD
+#undef elf32_bed
+#define elf32_bed elf32_hppa_netbsd_bed
#include "elf32-target.h"
projects / deliverable / binutils-gdb.git / blobdiff