#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/hppa.h"
#include "libhppa.h"
#include "elf32-hppa.h"
#define ARCH_SIZE 32
#include "elf32-hppa.h"
#include "elf-hppa.h"
#define PLT_ENTRY_SIZE 8
#define GOT_ENTRY_SIZE 4
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
static const bfd_byte plt_stub[] =
{
0x0e, 0x80, 0x10, 0x96,
0xea, 0xc0, 0xc0, 0x00,
0x0e, 0x88, 0x10, 0x95,
#define PLT_STUB_ENTRY (3*4)
0xea, 0x9f, 0x1f, 0xdd,
0xd6, 0x80, 0x1c, 0x1e,
0x00, 0xc0, 0xff, 0xee,
0xde, 0xad, 0xbe, 0xef
};
#define STUB_SUFFIX ".stub"
#ifndef RELATIVE_DYNRELOCS
#define RELATIVE_DYNRELOCS 0
#define IS_ABSOLUTE_RELOC(r_type) 1
#endif
enum elf32_hppa_stub_type {
hppa_stub_long_branch,
hppa_stub_long_branch_shared,
hppa_stub_import,
hppa_stub_import_shared,
hppa_stub_export,
hppa_stub_none
};
struct elf32_hppa_stub_hash_entry {
struct bfd_hash_entry root;
asection *stub_sec;
bfd_vma stub_offset;
bfd_vma target_value;
asection *target_section;
enum elf32_hppa_stub_type stub_type;
struct elf32_hppa_link_hash_entry *h;
asection *id_sec;
};
struct elf32_hppa_link_hash_entry {
struct elf_link_hash_entry elf;
struct elf32_hppa_stub_hash_entry *stub_cache;
struct elf32_hppa_dyn_reloc_entry {
struct elf32_hppa_dyn_reloc_entry *next;
asection *sec;
bfd_size_type count;
#if RELATIVE_DYNRELOCS
bfd_size_type relative_count;
#endif
} *dyn_relocs;
unsigned int pic_call:1;
unsigned int plabel:1;
};
struct elf32_hppa_link_hash_table {
struct elf_link_hash_table elf;
struct bfd_hash_table stub_hash_table;
bfd *stub_bfd;
asection * (*add_stub_section) PARAMS ((const char *, asection *));
void (*layout_sections_again) PARAMS ((void));
struct map_stub {
asection *link_sec;
asection *stub_sec;
} *stub_group;
unsigned int bfd_count;
int top_index;
asection **input_list;
Elf_Internal_Sym **all_local_syms;
asection *sgot;
asection *srelgot;
asection *splt;
asection *srelplt;
asection *sdynbss;
asection *srelbss;
bfd_vma text_segment_base;
bfd_vma data_segment_base;
unsigned int multi_subspace:1;
unsigned int has_12bit_branch:1;
unsigned int has_17bit_branch:1;
unsigned int has_22bit_branch:1;
unsigned int need_plt_stub:1;
struct sym_sec_cache sym_sec;
};
#define hppa_link_hash_table(p) \
((struct elf32_hppa_link_hash_table *) ((p)->hash))
#define hppa_stub_hash_lookup(table, string, create, copy) \
((struct elf32_hppa_stub_hash_entry *) \
bfd_hash_lookup ((table), (string), (create), (copy)))
static struct bfd_hash_entry *stub_hash_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
static struct bfd_hash_entry *hppa_link_hash_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
PARAMS ((bfd *));
static void elf32_hppa_link_hash_table_free
PARAMS ((struct bfd_link_hash_table *));
static char *hppa_stub_name
PARAMS ((const asection *, const asection *,
const struct elf32_hppa_link_hash_entry *,
const Elf_Internal_Rela *));
static struct elf32_hppa_stub_hash_entry *hppa_get_stub_entry
PARAMS ((const asection *, const asection *,
struct elf32_hppa_link_hash_entry *,
const Elf_Internal_Rela *,
struct elf32_hppa_link_hash_table *));
static struct elf32_hppa_stub_hash_entry *hppa_add_stub
PARAMS ((const char *, asection *, struct elf32_hppa_link_hash_table *));
static enum elf32_hppa_stub_type hppa_type_of_stub
PARAMS ((asection *, const Elf_Internal_Rela *,
struct elf32_hppa_link_hash_entry *, bfd_vma));
static bfd_boolean hppa_build_one_stub
PARAMS ((struct bfd_hash_entry *, PTR));
static bfd_boolean hppa_size_one_stub
PARAMS ((struct bfd_hash_entry *, PTR));
static bfd_boolean elf32_hppa_object_p PARAMS ((bfd *));
static bfd_boolean elf32_hppa_add_symbol_hook
PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
const char **, flagword *, asection **, bfd_vma *));
static bfd_boolean elf32_hppa_create_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *));
static void elf32_hppa_copy_indirect_symbol
PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
struct elf_link_hash_entry *));
static bfd_boolean elf32_hppa_check_relocs
PARAMS ((bfd *, struct bfd_link_info *,
asection *, const Elf_Internal_Rela *));
static asection *elf32_hppa_gc_mark_hook
PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
struct elf_link_hash_entry *, Elf_Internal_Sym *));
static bfd_boolean elf32_hppa_gc_sweep_hook
PARAMS ((bfd *, struct bfd_link_info *,
asection *, const Elf_Internal_Rela *));
static void elf32_hppa_hide_symbol
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
static bfd_boolean elf32_hppa_adjust_dynamic_symbol
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
static bfd_boolean mark_PIC_calls
PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean allocate_plt_static
PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean allocate_dynrelocs
PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean readonly_dynrelocs
PARAMS ((struct elf_link_hash_entry *, PTR));
static bfd_boolean clobber_millicode_symbols
PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
static bfd_boolean elf32_hppa_size_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *));
static void group_sections
PARAMS ((struct elf32_hppa_link_hash_table *, bfd_size_type, bfd_boolean));
static int get_local_syms
PARAMS ((bfd *, bfd *, struct bfd_link_info *));
static bfd_boolean elf32_hppa_final_link
PARAMS ((bfd *, struct bfd_link_info *));
static void hppa_record_segment_addr
PARAMS ((bfd *, asection *, PTR));
static bfd_reloc_status_type final_link_relocate
PARAMS ((asection *, bfd_byte *, const Elf_Internal_Rela *,
bfd_vma, struct elf32_hppa_link_hash_table *, asection *,
struct elf32_hppa_link_hash_entry *));
static bfd_boolean elf32_hppa_relocate_section
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
static bfd_boolean elf32_hppa_finish_dynamic_symbol
PARAMS ((bfd *, struct bfd_link_info *,
struct elf_link_hash_entry *, Elf_Internal_Sym *));
static enum elf_reloc_type_class elf32_hppa_reloc_type_class
PARAMS ((const Elf_Internal_Rela *));
static bfd_boolean elf32_hppa_finish_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *));
static void elf32_hppa_post_process_headers
PARAMS ((bfd *, struct bfd_link_info *));
static int elf32_hppa_elf_get_symbol_type
PARAMS ((Elf_Internal_Sym *, int));
static struct bfd_hash_entry *
stub_hash_newfunc (entry, table, string)
struct bfd_hash_entry *entry;
struct bfd_hash_table *table;
const char *string;
{
if (entry == NULL)
{
entry = bfd_hash_allocate (table,
sizeof (struct elf32_hppa_stub_hash_entry));
if (entry == NULL)
return entry;
}
entry = bfd_hash_newfunc (entry, table, string);
if (entry != NULL)
{
struct elf32_hppa_stub_hash_entry *eh;
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;
}
return entry;
}
static struct bfd_hash_entry *
hppa_link_hash_newfunc (entry, table, string)
struct bfd_hash_entry *entry;
struct bfd_hash_table *table;
const char *string;
{
if (entry == NULL)
{
entry = bfd_hash_allocate (table,
sizeof (struct elf32_hppa_link_hash_entry));
if (entry == NULL)
return entry;
}
entry = _bfd_elf_link_hash_newfunc (entry, table, string);
if (entry != NULL)
{
struct elf32_hppa_link_hash_entry *eh;
eh = (struct elf32_hppa_link_hash_entry *) entry;
eh->stub_cache = NULL;
eh->dyn_relocs = NULL;
eh->pic_call = 0;
eh->plabel = 0;
}
return entry;
}
static struct bfd_link_hash_table *
elf32_hppa_link_hash_table_create (abfd)
bfd *abfd;
{
struct elf32_hppa_link_hash_table *ret;
bfd_size_type amt = sizeof (*ret);
ret = (struct elf32_hppa_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return NULL;
if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, hppa_link_hash_newfunc))
{
free (ret);
return NULL;
}
if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc))
return NULL;
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;
}
static void
elf32_hppa_link_hash_table_free (hash)
struct bfd_link_hash_table *hash;
{
struct elf32_hppa_link_hash_table *ret
= (struct elf32_hppa_link_hash_table *) hash;
bfd_hash_table_free (&ret->stub_hash_table);
_bfd_generic_link_hash_table_free (hash);
}
static char *
hppa_stub_name (input_section, sym_sec, hash, rel)
const asection *input_section;
const asection *sym_sec;
const struct elf32_hppa_link_hash_entry *hash;
const Elf_Internal_Rela *rel;
{
char *stub_name;
bfd_size_type len;
if (hash)
{
len = 8 + 1 + strlen (hash->elf.root.root.string) + 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);
}
}
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);
}
}
return stub_name;
}
static struct elf32_hppa_stub_hash_entry *
hppa_get_stub_entry (input_section, sym_sec, hash, rel, htab)
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_table *htab;
{
struct elf32_hppa_stub_hash_entry *stub_entry;
const asection *id_sec;
id_sec = htab->stub_group[input_section->id].link_sec;
if (hash != NULL && hash->stub_cache != NULL
&& hash->stub_cache->h == hash
&& hash->stub_cache->id_sec == id_sec)
{
stub_entry = hash->stub_cache;
}
else
{
char *stub_name;
stub_name = hppa_stub_name (id_sec, sym_sec, hash, rel);
if (stub_name == NULL)
return NULL;
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
stub_name, FALSE, FALSE);
if (hash != NULL)
hash->stub_cache = stub_entry;
free (stub_name);
}
return stub_entry;
}
static struct elf32_hppa_stub_hash_entry *
hppa_add_stub (stub_name, section, htab)
const char *stub_name;
asection *section;
struct elf32_hppa_link_hash_table *htab;
{
asection *link_sec;
asection *stub_sec;
struct elf32_hppa_stub_hash_entry *stub_entry;
link_sec = htab->stub_group[section->id].link_sec;
stub_sec = htab->stub_group[section->id].stub_sec;
if (stub_sec == NULL)
{
stub_sec = htab->stub_group[link_sec->id].stub_sec;
if (stub_sec == NULL)
{
size_t namelen;
bfd_size_type len;
char *s_name;
namelen = strlen (link_sec->name);
len = namelen + sizeof (STUB_SUFFIX);
s_name = bfd_alloc (htab->stub_bfd, len);
if (s_name == NULL)
return NULL;
memcpy (s_name, link_sec->name, namelen);
memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
stub_sec = (*htab->add_stub_section) (s_name, link_sec);
if (stub_sec == NULL)
return NULL;
htab->stub_group[link_sec->id].stub_sec = stub_sec;
}
htab->stub_group[section->id].stub_sec = stub_sec;
}
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table, stub_name,
TRUE, FALSE);
if (stub_entry == NULL)
{
(*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
bfd_archive_filename (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;
}
static enum elf32_hppa_stub_type
hppa_type_of_stub (input_sec, rel, hash, destination)
asection *input_sec;
const Elf_Internal_Rela *rel;
struct elf32_hppa_link_hash_entry *hash;
bfd_vma destination;
{
bfd_vma location;
bfd_vma branch_offset;
bfd_vma max_branch_offset;
unsigned int r_type;
if (hash != NULL
&& hash->elf.plt.offset != (bfd_vma) -1
&& (hash->elf.dynindx != -1 || hash->pic_call)
&& !hash->plabel)
{
return hppa_stub_import;
}
location = (input_sec->output_offset
+ input_sec->output_section->vma
+ rel->r_offset);
branch_offset = destination - location - 8;
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type == (unsigned int) R_PARISC_PCREL17F)
{
max_branch_offset = (1 << (17-1)) << 2;
}
else if (r_type == (unsigned int) R_PARISC_PCREL12F)
{
max_branch_offset = (1 << (12-1)) << 2;
}
else
{
max_branch_offset = (1 << (22-1)) << 2;
}
if (branch_offset + max_branch_offset >= 2*max_branch_offset)
return hppa_stub_long_branch;
return hppa_stub_none;
}
#define LDIL_R1 0x20200000
#define BE_SR4_R1 0xe0202002
#define BL_R1 0xe8200000
#define ADDIL_R1 0x28200000
#define DEPI_R1 0xd4201c1e
#define ADDIL_DP 0x2b600000
#define LDW_R1_R21 0x48350000
#define BV_R0_R21 0xeaa0c000
#define LDW_R1_R19 0x48330000
#define ADDIL_R19 0x2a600000
#define LDW_R1_DP 0x483b0000
#define LDSID_R21_R1 0x02a010a1
#define MTSP_R1 0x00011820
#define BE_SR0_R21 0xe2a00000
#define STW_RP 0x6bc23fd1
#define BL22_RP 0xe800a002
#define BL_RP 0xe8400002
#define NOP 0x08000240
#define LDW_RP 0x4bc23fd1
#define LDSID_RP_R1 0x004010a1
#define BE_SR0_RP 0xe0400002
#ifndef R19_STUBS
#define R19_STUBS 1
#endif
#if R19_STUBS
#define LDW_R1_DLT LDW_R1_R19
#else
#define LDW_R1_DLT LDW_R1_DP
#endif
static bfd_boolean
hppa_build_one_stub (gen_entry, in_arg)
struct bfd_hash_entry *gen_entry;
PTR in_arg;
{
struct elf32_hppa_stub_hash_entry *stub_entry;
struct bfd_link_info *info;
struct elf32_hppa_link_hash_table *htab;
asection *stub_sec;
bfd *stub_bfd;
bfd_byte *loc;
bfd_vma sym_value;
bfd_vma insn;
bfd_vma off;
int val;
int size;
stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
info = (struct bfd_link_info *) in_arg;
htab = hppa_link_hash_table (info);
stub_sec = stub_entry->stub_sec;
stub_entry->stub_offset = stub_sec->_raw_size;
loc = stub_sec->contents + stub_entry->stub_offset;
stub_bfd = stub_sec->owner;
switch (stub_entry->stub_type)
{
case hppa_stub_long_branch:
sym_value = (stub_entry->target_value
+ stub_entry->target_section->output_offset
+ stub_entry->target_section->output_section->vma);
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel);
insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
bfd_put_32 (stub_bfd, insn, loc);
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel) >> 2;
insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
bfd_put_32 (stub_bfd, insn, loc + 4);
size = 8;
break;
case hppa_stub_long_branch_shared:
sym_value = (stub_entry->target_value
+ stub_entry->target_section->output_offset
+ stub_entry->target_section->output_section->vma);
sym_value -= (stub_entry->stub_offset
+ stub_sec->output_offset
+ stub_sec->output_section->vma);
bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
bfd_put_32 (stub_bfd, insn, loc + 4);
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;
break;
case hppa_stub_import:
case hppa_stub_import_shared:
off = stub_entry->h->elf.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));
insn = ADDIL_DP;
#if R19_STUBS
if (stub_entry->stub_type == hppa_stub_import_shared)
insn = ADDIL_R19;
#endif
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel),
insn = hppa_rebuild_insn ((int) insn, val, 21);
bfd_put_32 (stub_bfd, insn, loc);
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel);
insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
bfd_put_32 (stub_bfd, insn, loc + 4);
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);
size = 28;
}
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);
size = 16;
}
if (!info->shared
&& stub_entry->h != NULL
&& stub_entry->h->pic_call)
{
bfd *dynobj;
struct elf32_hppa_link_hash_entry *eh;
bfd_vma value;
dynobj = htab->elf.dynobj;
eh = (struct elf32_hppa_link_hash_entry *) stub_entry->h;
if (eh->elf.root.type != bfd_link_hash_defined
&& eh->elf.root.type != bfd_link_hash_defweak)
abort ();
value = (eh->elf.root.u.def.value
+ eh->elf.root.u.def.section->output_offset
+ eh->elf.root.u.def.section->output_section->vma);
bfd_put_32 (htab->splt->owner, value,
htab->splt->contents + off);
value = elf_gp (htab->splt->output_section->owner);
bfd_put_32 (htab->splt->owner, value,
htab->splt->contents + off + 4);
}
break;
case hppa_stub_export:
sym_value = (stub_entry->target_value
+ stub_entry->target_section->output_offset
+ stub_entry->target_section->output_section->vma);
sym_value -= (stub_entry->stub_offset
+ stub_sec->output_offset
+ stub_sec->output_section->vma);
if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
&& (!htab->has_22bit_branch
|| sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
{
(*_bfd_error_handler)
(_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
bfd_archive_filename (stub_entry->target_section->owner),
stub_sec->name,
(long) stub_entry->stub_offset,
stub_entry->root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
if (!htab->has_22bit_branch)
insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
else
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) 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);
stub_entry->h->elf.root.u.def.section = stub_sec;
stub_entry->h->elf.root.u.def.value = stub_sec->_raw_size;
size = 24;
break;
default:
BFD_FAIL ();
return FALSE;
}
stub_sec->_raw_size += size;
return TRUE;
}
#undef LDIL_R1
#undef BE_SR4_R1
#undef BL_R1
#undef ADDIL_R1
#undef DEPI_R1
#undef ADDIL_DP
#undef LDW_R1_R21
#undef LDW_R1_DLT
#undef LDW_R1_R19
#undef ADDIL_R19
#undef LDW_R1_DP
#undef LDSID_R21_R1
#undef MTSP_R1
#undef BE_SR0_R21
#undef STW_RP
#undef BV_R0_R21
#undef BL_RP
#undef NOP
#undef LDW_RP
#undef LDSID_RP_R1
#undef BE_SR0_RP
static bfd_boolean
hppa_size_one_stub (gen_entry, in_arg)
struct bfd_hash_entry *gen_entry;
PTR in_arg;
{
struct elf32_hppa_stub_hash_entry *stub_entry;
struct elf32_hppa_link_hash_table *htab;
int size;
stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
htab = (struct elf32_hppa_link_hash_table *) 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;
else
{
if (htab->multi_subspace)
size = 28;
else
size = 16;
}
stub_entry->stub_sec->_raw_size += size;
return TRUE;
}
static bfd_boolean
elf32_hppa_object_p (abfd)
bfd *abfd;
{
Elf_Internal_Ehdr * i_ehdrp;
unsigned int flags;
i_ehdrp = elf_elfheader (abfd);
if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
{
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX)
return FALSE;
}
else
{
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
return FALSE;
}
flags = i_ehdrp->e_flags;
switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
{
case EFA_PARISC_1_0:
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
case EFA_PARISC_1_1:
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
case EFA_PARISC_2_0:
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
case EFA_PARISC_2_0 | EF_PARISC_WIDE:
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
}
return TRUE;
}
static bfd_boolean
elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
bfd *abfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
const Elf_Internal_Sym *sym ATTRIBUTE_UNUSED;
const char **namep ATTRIBUTE_UNUSED;
flagword *flagsp ATTRIBUTE_UNUSED;
asection **secp;
bfd_vma *valp;
{
*valp += (*secp)->vma;
return TRUE;
}
static bfd_boolean
elf32_hppa_create_dynamic_sections (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
struct elf32_hppa_link_hash_table *htab;
htab = hppa_link_hash_table (info);
if (htab->splt != NULL)
return TRUE;
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");
return TRUE;
}
static void
elf32_hppa_copy_indirect_symbol (bed, dir, ind)
struct elf_backend_data *bed;
struct elf_link_hash_entry *dir, *ind;
{
struct elf32_hppa_link_hash_entry *edir, *eind;
edir = (struct elf32_hppa_link_hash_entry *) dir;
eind = (struct elf32_hppa_link_hash_entry *) ind;
if (eind->dyn_relocs != NULL)
{
if (edir->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 ();
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
{
struct elf32_hppa_dyn_reloc_entry *q;
for (q = edir->dyn_relocs; q != NULL; q = q->next)
if (q->sec == p->sec)
{
#if RELATIVE_DYNRELOCS
q->relative_count += p->relative_count;
#endif
q->count += p->count;
*pp = p->next;
break;
}
if (q == NULL)
pp = &p->next;
}
*pp = edir->dyn_relocs;
}
edir->dyn_relocs = eind->dyn_relocs;
eind->dyn_relocs = NULL;
}
_bfd_elf_link_hash_copy_indirect (bed, dir, ind);
}
static bfd_boolean
elf32_hppa_check_relocs (abfd, info, sec, relocs)
bfd *abfd;
struct bfd_link_info *info;
asection *sec;
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 elf32_hppa_link_hash_table *htab;
asection *sreloc;
asection *stubreloc;
if (info->relocateable)
return TRUE;
htab = hppa_link_hash_table (info);
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
sym_hashes = elf_sym_hashes (abfd);
sreloc = NULL;
stubreloc = NULL;
rel_end = relocs + sec->reloc_count;
for (rel = relocs; rel < rel_end; rel++)
{
enum {
NEED_GOT = 1,
NEED_PLT = 2,
NEED_DYNREL = 4,
PLT_PLABEL = 8
};
unsigned int r_symndx, r_type;
struct elf32_hppa_link_hash_entry *h;
int need_entry;
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx < symtab_hdr->sh_info)
h = NULL;
else
h = ((struct elf32_hppa_link_hash_entry *)
sym_hashes[r_symndx - symtab_hdr->sh_info]);
r_type = ELF32_R_TYPE (rel->r_info);
switch (r_type)
{
case R_PARISC_DLTIND14F:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND21L:
need_entry = NEED_GOT;
sec->flags |= SEC_HAS_GOT_REF;
break;
case R_PARISC_PLABEL14R:
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
if (rel->r_addend != 0)
abort ();
need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
break;
case R_PARISC_PCREL12F:
htab->has_12bit_branch = 1;
goto branch_common;
case R_PARISC_PCREL17C:
case R_PARISC_PCREL17F:
htab->has_17bit_branch = 1;
goto branch_common;
case R_PARISC_PCREL22F:
htab->has_22bit_branch = 1;
branch_common:
if (h == NULL)
{
continue;
}
else
{
need_entry = NEED_PLT;
if (h->elf.type == STT_PARISC_MILLI)
need_entry = 0;
}
break;
case R_PARISC_SEGBASE:
case R_PARISC_SEGREL32:
case R_PARISC_PCREL14F:
case R_PARISC_PCREL14R:
case R_PARISC_PCREL17R:
case R_PARISC_PCREL21L:
continue;
case R_PARISC_DPREL14F:
case R_PARISC_DPREL14R:
case R_PARISC_DPREL21L:
if (info->shared)
{
(*_bfd_error_handler)
(_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
bfd_archive_filename (abfd),
elf_hppa_howto_table[r_type].name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case R_PARISC_DIR17F:
case R_PARISC_DIR17R:
case R_PARISC_DIR14F:
case R_PARISC_DIR14R:
case R_PARISC_DIR21L:
#if 0
if (info->shared)
{
(*_bfd_error_handler)
(_("%s: relocation %s should not be used when making a shared object; recompile with -fPIC"),
bfd_archive_filename (abfd),
elf_hppa_howto_table[r_type].name);
}
#endif
case R_PARISC_DIR32:
need_entry = NEED_DYNREL;
break;
case R_PARISC_GNU_VTINHERIT:
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec,
&h->elf, rel->r_offset))
return FALSE;
continue;
case R_PARISC_GNU_VTENTRY:
if (!_bfd_elf32_gc_record_vtentry (abfd, sec,
&h->elf, rel->r_addend))
return FALSE;
continue;
default:
continue;
}
if (need_entry & NEED_GOT)
{
if (htab->sgot == NULL)
{
if (htab->elf.dynobj == NULL)
htab->elf.dynobj = abfd;
if (!elf32_hppa_create_dynamic_sections (htab->elf.dynobj, info))
return FALSE;
}
if (h != NULL)
{
h->elf.got.refcount += 1;
}
else
{
bfd_signed_vma *local_got_refcounts;
local_got_refcounts = elf_local_got_refcounts (abfd);
if (local_got_refcounts == NULL)
{
bfd_size_type size;
size = symtab_hdr->sh_info;
size *= 2 * sizeof (bfd_signed_vma);
local_got_refcounts = ((bfd_signed_vma *)
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;
}
}
if (need_entry & NEED_PLT)
{
if ((sec->flags & SEC_ALLOC) != 0)
{
if (h != NULL)
{
h->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
h->elf.plt.refcount += 1;
if (need_entry & PLT_PLABEL)
h->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);
if (local_got_refcounts == NULL)
{
bfd_size_type size;
size = symtab_hdr->sh_info;
size *= 2 * sizeof (bfd_signed_vma);
local_got_refcounts = ((bfd_signed_vma *)
bfd_zalloc (abfd, size));
if (local_got_refcounts == NULL)
return FALSE;
elf_local_got_refcounts (abfd) = local_got_refcounts;
}
local_plt_refcounts = (local_got_refcounts
+ symtab_hdr->sh_info);
local_plt_refcounts[r_symndx] += 1;
}
}
}
if (need_entry & NEED_DYNREL)
{
if (h != NULL && !info->shared)
h->elf.elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
if ((info->shared
&& (sec->flags & SEC_ALLOC) != 0
&& (IS_ABSOLUTE_RELOC (r_type)
|| (h != NULL
&& (!info->symbolic
|| h->elf.root.type == bfd_link_hash_defweak
|| (h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
|| (!info->shared
&& (sec->flags & SEC_ALLOC) != 0
&& h != NULL
&& (h->elf.root.type == bfd_link_hash_defweak
|| (h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0)))
{
struct elf32_hppa_dyn_reloc_entry *p;
struct elf32_hppa_dyn_reloc_entry **head;
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;
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;
}
elf_section_data (sec)->sreloc = sreloc;
}
if (h != NULL)
{
head = &h->dyn_relocs;
}
else
{
asection *s;
s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
sec, r_symndx);
if (s == NULL)
return FALSE;
head = ((struct elf32_hppa_dyn_reloc_entry **)
&elf_section_data (s)->local_dynrel);
}
p = *head;
if (p == NULL || p->sec != sec)
{
p = ((struct elf32_hppa_dyn_reloc_entry *)
bfd_alloc (htab->elf.dynobj,
(bfd_size_type) sizeof *p));
if (p == NULL)
return FALSE;
p->next = *head;
*head = p;
p->sec = sec;
p->count = 0;
#if RELATIVE_DYNRELOCS
p->relative_count = 0;
#endif
}
p->count += 1;
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (rtype))
p->relative_count += 1;
#endif
}
}
}
return TRUE;
}
static asection *
elf32_hppa_gc_mark_hook (sec, info, rel, h, sym)
asection *sec;
struct bfd_link_info *info ATTRIBUTE_UNUSED;
Elf_Internal_Rela *rel;
struct elf_link_hash_entry *h;
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;
}
static bfd_boolean
elf32_hppa_gc_sweep_hook (abfd, info, sec, relocs)
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;
unsigned long r_symndx;
struct elf_link_hash_entry *h;
struct elf32_hppa_link_hash_table *htab;
bfd *dynobj;
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;
htab = hppa_link_hash_table (info);
dynobj = htab->elf.dynobj;
if (dynobj == NULL)
return TRUE;
relend = relocs + sec->reloc_count;
for (rel = relocs; rel < relend; rel++)
switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
{
case R_PARISC_DLTIND14F:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND21L:
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx >= symtab_hdr->sh_info)
{
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
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:
r_symndx = ELF32_R_SYM (rel->r_info);
if (r_symndx >= symtab_hdr->sh_info)
{
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
if (h->plt.refcount > 0)
h->plt.refcount -= 1;
}
break;
case R_PARISC_PLABEL14R:
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
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];
if (h->plt.refcount > 0)
h->plt.refcount -= 1;
eh = (struct elf32_hppa_link_hash_entry *) h;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
if (p->sec == sec)
{
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (rtype))
p->relative_count -= 1;
#endif
p->count -= 1;
if (p->count == 0)
*pp = p->next;
break;
}
}
else if (local_plt_refcounts != NULL)
{
if (local_plt_refcounts[r_symndx] > 0)
local_plt_refcounts[r_symndx] -= 1;
}
break;
case R_PARISC_DIR32:
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];
eh = (struct elf32_hppa_link_hash_entry *) h;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
if (p->sec == sec)
{
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (R_PARISC_DIR32))
p->relative_count -= 1;
#endif
p->count -= 1;
if (p->count == 0)
*pp = p->next;
break;
}
}
break;
default:
break;
}
return TRUE;
}
static void
elf32_hppa_hide_symbol (info, h, force_local)
struct bfd_link_info *info;
struct elf_link_hash_entry *h;
bfd_boolean force_local;
{
if (force_local)
{
h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
if (h->dynindx != -1)
{
h->dynindx = -1;
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
h->dynstr_index);
}
}
if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
{
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
h->plt.offset = (bfd_vma) -1;
}
}
#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
((DYN) \
&& ((INFO)->shared \
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
&& ((H)->dynindx != -1 \
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
static bfd_boolean
elf32_hppa_adjust_dynamic_symbol (info, h)
struct bfd_link_info *info;
struct elf_link_hash_entry *h;
{
struct elf32_hppa_link_hash_table *htab;
struct elf32_hppa_link_hash_entry *eh;
struct elf32_hppa_dyn_reloc_entry *p;
asection *s;
unsigned int power_of_two;
if (h->type == STT_FUNC
|| (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
{
if (h->plt.refcount <= 0
|| ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
&& h->root.type != bfd_link_hash_defweak
&& ! ((struct elf32_hppa_link_hash_entry *) h)->plabel
&& (!info->shared || info->symbolic)))
{
if (!info->shared
&& h->plt.refcount > 0
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
&& (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0)
((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
else
{
h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
}
}
return TRUE;
}
else
h->plt.offset = (bfd_vma) -1;
if (h->weakdef != NULL)
{
if (h->weakdef->root.type != bfd_link_hash_defined
&& h->weakdef->root.type != bfd_link_hash_defweak)
abort ();
h->root.u.def.section = h->weakdef->root.u.def.section;
h->root.u.def.value = h->weakdef->root.u.def.value;
return TRUE;
}
if (info->shared)
return TRUE;
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
return TRUE;
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 (p == NULL)
{
h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
return TRUE;
}
htab = hppa_link_hash_table (info);
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
{
htab->srelbss->_raw_size += sizeof (Elf32_External_Rela);
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
}
power_of_two = bfd_log2 (h->size);
if (power_of_two > 3)
power_of_two = 3;
s = htab->sdynbss;
s->_raw_size = BFD_ALIGN (s->_raw_size,
(bfd_size_type) (1 << power_of_two));
if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
{
if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
return FALSE;
}
h->root.u.def.section = s;
h->root.u.def.value = s->_raw_size;
s->_raw_size += h->size;
return TRUE;
}
static bfd_boolean
mark_PIC_calls (h, inf)
struct elf_link_hash_entry *h;
PTR inf ATTRIBUTE_UNUSED;
{
if (h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
if (! (h->plt.refcount > 0
&& (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
&& (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0))
{
h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
return TRUE;
}
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
return TRUE;
}
static bfd_boolean
allocate_plt_static (h, inf)
struct elf_link_hash_entry *h;
PTR inf;
{
struct bfd_link_info *info;
struct elf32_hppa_link_hash_table *htab;
asection *s;
if (h->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 = (struct bfd_link_info *) inf;
htab = hppa_link_hash_table (info);
if (((struct elf32_hppa_link_hash_entry *) h)->pic_call)
{
((struct elf32_hppa_link_hash_entry *) h)->plabel = 0;
s = htab->splt;
h->plt.offset = s->_raw_size;
s->_raw_size += PLT_ENTRY_SIZE;
}
else if (htab->elf.dynamic_sections_created
&& h->plt.refcount > 0)
{
if (h->dynindx == -1
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
&& h->type != STT_PARISC_MILLI)
{
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
{
((struct elf32_hppa_link_hash_entry *) h)->plabel = 0;
}
else if (((struct elf32_hppa_link_hash_entry *) h)->plabel)
{
s = htab->splt;
h->plt.offset = s->_raw_size;
s->_raw_size += PLT_ENTRY_SIZE;
}
else
{
h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
}
}
else
{
h->plt.offset = (bfd_vma) -1;
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
}
return TRUE;
}
static bfd_boolean
allocate_dynrelocs (h, inf)
struct elf_link_hash_entry *h;
PTR 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;
if (h->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 = (struct bfd_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)->pic_call
&& !((struct elf32_hppa_link_hash_entry *) h)->plabel)
{
s = htab->splt;
h->plt.offset = s->_raw_size;
s->_raw_size += PLT_ENTRY_SIZE;
htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
htab->need_plt_stub = 1;
}
if (h->got.refcount > 0)
{
if (h->dynindx == -1
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
&& h->type != STT_PARISC_MILLI)
{
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
s = htab->sgot;
h->got.offset = s->_raw_size;
s->_raw_size += GOT_ENTRY_SIZE;
if (htab->elf.dynamic_sections_created
&& (info->shared
|| (h->dynindx != -1
&& h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0))
{
htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
}
}
else
h->got.offset = (bfd_vma) -1;
eh = (struct elf32_hppa_link_hash_entry *) h;
if (eh->dyn_relocs == NULL)
return TRUE;
if (info->shared)
{
#if RELATIVE_DYNRELOCS
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
&& ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
|| info->symbolic))
{
struct elf32_hppa_dyn_reloc_entry **pp;
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
{
p->count -= p->relative_count;
p->relative_count = 0;
if (p->count == 0)
*pp = p->next;
else
pp = &p->next;
}
}
#endif
}
else
{
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
&& (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
|| (htab->elf.dynamic_sections_created
&& (h->root.type == bfd_link_hash_undefweak
|| h->root.type == bfd_link_hash_undefined))))
{
if (h->dynindx == -1
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
&& h->type != STT_PARISC_MILLI)
{
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
return FALSE;
}
if (h->dynindx != -1)
goto keep;
}
eh->dyn_relocs = NULL;
return TRUE;
keep: ;
}
for (p = eh->dyn_relocs; p != NULL; p = p->next)
{
asection *sreloc = elf_section_data (p->sec)->sreloc;
sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
}
return TRUE;
}
static bfd_boolean
clobber_millicode_symbols (h, info)
struct elf_link_hash_entry *h;
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->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
{
elf32_hppa_hide_symbol (info, h, TRUE);
}
return TRUE;
}
static bfd_boolean
readonly_dynrelocs (h, inf)
struct elf_link_hash_entry *h;
PTR inf;
{
struct elf32_hppa_link_hash_entry *eh;
struct elf32_hppa_dyn_reloc_entry *p;
if (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 (p = eh->dyn_relocs; p != NULL; p = p->next)
{
asection *s = p->sec->output_section;
if (s != NULL && (s->flags & SEC_READONLY) != 0)
{
struct bfd_link_info *info = (struct bfd_link_info *) inf;
info->flags |= DF_TEXTREL;
return FALSE;
}
}
return TRUE;
}
static bfd_boolean
elf32_hppa_size_dynamic_sections (output_bfd, info)
bfd *output_bfd ATTRIBUTE_UNUSED;
struct bfd_link_info *info;
{
struct elf32_hppa_link_hash_table *htab;
bfd *dynobj;
bfd *ibfd;
asection *s;
bfd_boolean relocs;
htab = hppa_link_hash_table (info);
dynobj = htab->elf.dynobj;
if (dynobj == NULL)
abort ();
if (htab->elf.dynamic_sections_created)
{
if (! info->shared)
{
s = bfd_get_section_by_name (dynobj, ".interp");
if (s == NULL)
abort ();
s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
}
elf_link_hash_traverse (&htab->elf,
clobber_millicode_symbols,
info);
}
else
{
if (! info->shared)
elf_link_hash_traverse (&htab->elf, mark_PIC_calls, (PTR) info);
}
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
{
bfd_signed_vma *local_got;
bfd_signed_vma *end_local_got;
bfd_signed_vma *local_plt;
bfd_signed_vma *end_local_plt;
bfd_size_type locsymcount;
Elf_Internal_Shdr *symtab_hdr;
asection *srel;
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
continue;
for (s = ibfd->sections; s != NULL; s = s->next)
{
struct elf32_hppa_dyn_reloc_entry *p;
for (p = ((struct elf32_hppa_dyn_reloc_entry *)
elf_section_data (s)->local_dynrel);
p != NULL;
p = p->next)
{
if (!bfd_is_abs_section (p->sec)
&& bfd_is_abs_section (p->sec->output_section))
{
}
else if (p->count != 0)
{
srel = elf_section_data (p->sec)->sreloc;
srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
info->flags |= DF_TEXTREL;
}
}
}
local_got = elf_local_got_refcounts (ibfd);
if (!local_got)
continue;
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
s = htab->sgot;
srel = htab->srelgot;
for (; local_got < end_local_got; ++local_got)
{
if (*local_got > 0)
{
*local_got = s->_raw_size;
s->_raw_size += GOT_ENTRY_SIZE;
if (info->shared)
srel->_raw_size += sizeof (Elf32_External_Rela);
}
else
*local_got = (bfd_vma) -1;
}
local_plt = end_local_got;
end_local_plt = local_plt + locsymcount;
if (! htab->elf.dynamic_sections_created)
{
for (; local_plt < end_local_plt; ++local_plt)
*local_plt = (bfd_vma) -1;
}
else
{
s = htab->splt;
srel = htab->srelplt;
for (; local_plt < end_local_plt; ++local_plt)
{
if (*local_plt > 0)
{
*local_plt = s->_raw_size;
s->_raw_size += PLT_ENTRY_SIZE;
if (info->shared)
srel->_raw_size += sizeof (Elf32_External_Rela);
}
else
*local_plt = (bfd_vma) -1;
}
}
}
elf_link_hash_traverse (&htab->elf, allocate_plt_static, (PTR) info);
elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
relocs = FALSE;
for (s = dynobj->sections; s != NULL; s = s->next)
{
if ((s->flags & SEC_LINKER_CREATED) == 0)
continue;
if (s == htab->splt)
{
if (htab->need_plt_stub)
{
int gotalign = bfd_section_alignment (dynobj, htab->sgot);
int pltalign = bfd_section_alignment (dynobj, s);
bfd_size_type mask;
if (gotalign > pltalign)
bfd_set_section_alignment (dynobj, s, gotalign);
mask = ((bfd_size_type) 1 << gotalign) - 1;
s->_raw_size = (s->_raw_size + sizeof (plt_stub) + mask) & ~mask;
}
}
else if (s == htab->sgot)
;
else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
{
if (s->_raw_size != 0)
{
if (s != htab->srelplt)
relocs = TRUE;
s->reloc_count = 0;
}
}
else
{
continue;
}
if (s->_raw_size == 0)
{
_bfd_strip_section_from_output (info, s);
continue;
}
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
if (s->contents == NULL && s->_raw_size != 0)
return FALSE;
}
if (htab->elf.dynamic_sections_created)
{
#define add_dynamic_entry(TAG, VAL) \
bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
if (!add_dynamic_entry (DT_PLTGOT, 0))
return FALSE;
if (!info->shared)
{
if (!add_dynamic_entry (DT_DEBUG, 0))
return FALSE;
}
if (htab->srelplt->_raw_size != 0)
{
if (!add_dynamic_entry (DT_PLTRELSZ, 0)
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
|| !add_dynamic_entry (DT_JMPREL, 0))
return FALSE;
}
if (relocs)
{
if (!add_dynamic_entry (DT_RELA, 0)
|| !add_dynamic_entry (DT_RELASZ, 0)
|| !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
return FALSE;
if ((info->flags & DF_TEXTREL) == 0)
elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
(PTR) info);
if ((info->flags & DF_TEXTREL) != 0)
{
if (!add_dynamic_entry (DT_TEXTREL, 0))
return FALSE;
}
}
}
#undef add_dynamic_entry
return TRUE;
}
int
elf32_hppa_setup_section_lists (output_bfd, info)
bfd *output_bfd;
struct bfd_link_info *info;
{
bfd *input_bfd;
unsigned int bfd_count;
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->elf.root.creator->flavour != bfd_target_elf_flavour)
return 0;
for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
input_bfd != NULL;
input_bfd = input_bfd->link_next)
{
bfd_count += 1;
for (section = input_bfd->sections;
section != NULL;
section = section->next)
{
if (top_id < section->id)
top_id = section->id;
}
}
htab->bfd_count = bfd_count;
amt = sizeof (struct map_stub) * (top_id + 1);
htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
if (htab->stub_group == NULL)
return -1;
for (section = output_bfd->sections, top_index = 0;
section != NULL;
section = section->next)
{
if (top_index < section->index)
top_index = section->index;
}
htab->top_index = top_index;
amt = sizeof (asection *) * (top_index + 1);
input_list = (asection **) bfd_malloc (amt);
htab->input_list = input_list;
if (input_list == NULL)
return -1;
list = input_list + top_index;
do
*list = bfd_abs_section_ptr;
while (list-- != input_list);
for (section = output_bfd->sections;
section != NULL;
section = section->next)
{
if ((section->flags & SEC_CODE) != 0)
input_list[section->index] = NULL;
}
return 1;
}
void
elf32_hppa_next_input_section (info, isec)
struct bfd_link_info *info;
asection *isec;
{
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
if (isec->output_section->index <= htab->top_index)
{
asection **list = htab->input_list + isec->output_section->index;
if (*list != bfd_abs_section_ptr)
{
#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
PREV_SEC (isec) = *list;
*list = isec;
}
}
}
static void
group_sections (htab, stub_group_size, stubs_always_before_branch)
struct elf32_hppa_link_hash_table *htab;
bfd_size_type stub_group_size;
bfd_boolean stubs_always_before_branch;
{
asection **list = htab->input_list + htab->top_index;
do
{
asection *tail = *list;
if (tail == bfd_abs_section_ptr)
continue;
while (tail != NULL)
{
asection *curr;
asection *prev;
bfd_size_type total;
curr = tail;
if (tail->_cooked_size)
total = tail->_cooked_size;
else
total = tail->_raw_size;
while ((prev = PREV_SEC (curr)) != NULL
&& ((total += curr->output_offset - prev->output_offset)
< stub_group_size))
curr = prev;
do
{
prev = PREV_SEC (tail);
htab->stub_group[tail->id].link_sec = curr;
}
while (tail != curr && (tail = prev) != NULL);
if (!stubs_always_before_branch)
{
total = 0;
while (prev != NULL
&& ((total += tail->output_offset - prev->output_offset)
< stub_group_size))
{
tail = prev;
prev = PREV_SEC (tail);
htab->stub_group[tail->id].link_sec = curr;
}
}
tail = prev;
}
}
while (list-- != htab->input_list);
free (htab->input_list);
#undef PREV_SEC
}
static int
get_local_syms (output_bfd, input_bfd, info)
bfd *output_bfd;
bfd *input_bfd;
struct bfd_link_info *info;
{
unsigned int bfd_indx;
Elf_Internal_Sym *local_syms, **all_local_syms;
int stub_changed = 0;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
htab->all_local_syms = all_local_syms;
if (all_local_syms == NULL)
return -1;
for (bfd_indx = 0;
input_bfd != NULL;
input_bfd = input_bfd->link_next, bfd_indx++)
{
Elf_Internal_Shdr *symtab_hdr;
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
if (symtab_hdr->sh_info == 0)
continue;
local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
if (local_syms == NULL)
{
local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
symtab_hdr->sh_info, 0,
NULL, NULL, NULL);
symtab_hdr->contents = (unsigned char *) local_syms;
}
if (local_syms == NULL)
return -1;
all_local_syms[bfd_indx] = local_syms;
if (info->shared && htab->multi_subspace)
{
struct elf_link_hash_entry **sym_hashes;
struct elf_link_hash_entry **end_hashes;
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;
for (; sym_hashes < end_hashes; sym_hashes++)
{
struct elf32_hppa_link_hash_entry *hash;
hash = (struct elf32_hppa_link_hash_entry *) *sym_hashes;
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);
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
== output_bfd)
&& hash->elf.root.u.def.section->owner == input_bfd
&& (hash->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
&& !(hash->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
&& ELF_ST_VISIBILITY (hash->elf.other) == STV_DEFAULT)
{
asection *sec;
const char *stub_name;
struct elf32_hppa_stub_hash_entry *stub_entry;
sec = hash->elf.root.u.def.section;
stub_name = hash->elf.root.root.string;
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
stub_name,
FALSE, FALSE);
if (stub_entry == NULL)
{
stub_entry = hppa_add_stub (stub_name, sec, htab);
if (!stub_entry)
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;
stub_changed = 1;
}
else
{
(*_bfd_error_handler) (_("%s: duplicate export stub %s"),
bfd_archive_filename (input_bfd),
stub_name);
}
}
}
}
}
return stub_changed;
}
bfd_boolean
elf32_hppa_size_stubs (output_bfd, stub_bfd, info, multi_subspace, group_size,
add_stub_section, layout_sections_again)
bfd *output_bfd;
bfd *stub_bfd;
struct bfd_link_info *info;
bfd_boolean multi_subspace;
bfd_signed_vma group_size;
asection * (*add_stub_section) PARAMS ((const char *, asection *));
void (*layout_sections_again) PARAMS ((void));
{
bfd_size_type stub_group_size;
bfd_boolean stubs_always_before_branch;
bfd_boolean stub_changed;
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
htab->stub_bfd = stub_bfd;
htab->multi_subspace = multi_subspace;
htab->add_stub_section = add_stub_section;
htab->layout_sections_again = layout_sections_again;
stubs_always_before_branch = group_size < 0;
if (group_size < 0)
stub_group_size = -group_size;
else
stub_group_size = group_size;
if (stub_group_size == 1)
{
stub_group_size = 7680000;
if (htab->has_17bit_branch || htab->multi_subspace)
stub_group_size = 240000;
if (htab->has_12bit_branch)
stub_group_size = 7500;
}
group_sections (htab, stub_group_size, stubs_always_before_branch);
switch (get_local_syms (output_bfd, info->input_bfds, info))
{
default:
if (htab->all_local_syms)
goto error_ret_free_local;
return FALSE;
case 0:
stub_changed = FALSE;
break;
case 1:
stub_changed = TRUE;
break;
}
while (1)
{
bfd *input_bfd;
unsigned int bfd_indx;
asection *stub_sec;
for (input_bfd = info->input_bfds, bfd_indx = 0;
input_bfd != NULL;
input_bfd = input_bfd->link_next, bfd_indx++)
{
Elf_Internal_Shdr *symtab_hdr;
asection *section;
Elf_Internal_Sym *local_syms;
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
if (symtab_hdr->sh_info == 0)
continue;
local_syms = htab->all_local_syms[bfd_indx];
for (section = input_bfd->sections;
section != NULL;
section = section->next)
{
Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
if ((section->flags & SEC_RELOC) == 0
|| section->reloc_count == 0)
continue;
if (section->output_section == NULL
|| section->output_section->owner != output_bfd)
continue;
internal_relocs
= _bfd_elf32_link_read_relocs (input_bfd, section, NULL,
(Elf_Internal_Rela *) NULL,
info->keep_memory);
if (internal_relocs == NULL)
goto error_ret_free_local;
irela = internal_relocs;
irelaend = irela + section->reloc_count;
for (; irela < irelaend; irela++)
{
unsigned int r_type, r_indx;
enum elf32_hppa_stub_type stub_type;
struct elf32_hppa_stub_hash_entry *stub_entry;
asection *sym_sec;
bfd_vma sym_value;
bfd_vma destination;
struct elf32_hppa_link_hash_entry *hash;
char *stub_name;
const asection *id_sec;
r_type = ELF32_R_TYPE (irela->r_info);
r_indx = ELF32_R_SYM (irela->r_info);
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
{
bfd_set_error (bfd_error_bad_value);
error_ret_free_internal:
if (elf_section_data (section)->relocs == NULL)
free (internal_relocs);
goto error_ret_free_local;
}
if (r_type != (unsigned int) R_PARISC_PCREL12F
&& r_type != (unsigned int) R_PARISC_PCREL17F
&& r_type != (unsigned int) R_PARISC_PCREL22F)
continue;
sym_sec = NULL;
sym_value = 0;
destination = 0;
hash = NULL;
if (r_indx < symtab_hdr->sh_info)
{
Elf_Internal_Sym *sym;
Elf_Internal_Shdr *hdr;
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);
}
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]);
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);
if (hash->elf.root.type == bfd_link_hash_defined
|| hash->elf.root.type == bfd_link_hash_defweak)
{
sym_sec = hash->elf.root.u.def.section;
sym_value = hash->elf.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)
{
if (! info->shared)
continue;
}
else if (hash->elf.root.type == bfd_link_hash_undefined)
{
if (! (info->shared
&& !info->no_undefined
&& (ELF_ST_VISIBILITY (hash->elf.other)
== STV_DEFAULT)
&& hash->elf.type != STT_PARISC_MILLI))
continue;
}
else
{
bfd_set_error (bfd_error_bad_value);
goto error_ret_free_internal;
}
}
stub_type = hppa_type_of_stub (section, irela, hash,
destination);
if (stub_type == hppa_stub_none)
continue;
id_sec = htab->stub_group[section->id].link_sec;
stub_name = hppa_stub_name (id_sec, sym_sec, hash, irela);
if (!stub_name)
goto error_ret_free_internal;
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
stub_name,
FALSE, FALSE);
if (stub_entry != NULL)
{
free (stub_name);
continue;
}
stub_entry = hppa_add_stub (stub_name, section, htab);
if (stub_entry == 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)
{
if (stub_type == hppa_stub_import)
stub_entry->stub_type = hppa_stub_import_shared;
else if (stub_type == hppa_stub_long_branch)
stub_entry->stub_type = hppa_stub_long_branch_shared;
}
stub_entry->h = hash;
stub_changed = TRUE;
}
if (elf_section_data (section)->relocs == NULL)
free (internal_relocs);
}
}
if (!stub_changed)
break;
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
stub_sec = stub_sec->next)
{
stub_sec->_raw_size = 0;
stub_sec->_cooked_size = 0;
}
bfd_hash_traverse (&htab->stub_hash_table, hppa_size_one_stub, htab);
(*htab->layout_sections_again) ();
stub_changed = FALSE;
}
free (htab->all_local_syms);
return TRUE;
error_ret_free_local:
free (htab->all_local_syms);
return FALSE;
}
bfd_boolean
elf32_hppa_set_gp (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
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);
if (h != NULL
&& (h->type == bfd_link_hash_defined
|| h->type == bfd_link_hash_defweak))
{
gp_val = h->u.def.value;
sec = h->u.def.section;
}
else
{
asection *splt;
asection *sgot;
if (htab->elf.root.creator->flavour == bfd_target_elf_flavour)
{
splt = htab->splt;
sgot = htab->sgot;
}
else
{
splt = bfd_get_section_by_name (abfd, ".plt");
sgot = bfd_get_section_by_name (abfd, ".got");
}
sec = splt;
if (sec != NULL)
{
gp_val = sec->_raw_size;
if (gp_val > 0x2000 || (sgot && sgot->_raw_size > 0x2000))
{
gp_val = 0x2000;
}
}
else
{
sec = sgot;
if (sec != NULL)
{
if (sec->_raw_size > 0x2000)
gp_val = 0x2000;
}
else
{
sec = bfd_get_section_by_name (abfd, ".data");
}
}
if (h != NULL)
{
h->type = bfd_link_hash_defined;
h->u.def.value = gp_val;
if (sec != NULL)
h->u.def.section = sec;
else
h->u.def.section = bfd_abs_section_ptr;
}
}
if (sec != NULL && sec->output_section != NULL)
gp_val += sec->output_section->vma + sec->output_offset;
elf_gp (abfd) = gp_val;
return TRUE;
}
bfd_boolean
elf32_hppa_build_stubs (info)
struct bfd_link_info *info;
{
asection *stub_sec;
struct bfd_hash_table *table;
struct elf32_hppa_link_hash_table *htab;
htab = hppa_link_hash_table (info);
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
stub_sec = stub_sec->next)
{
bfd_size_type size;
size = stub_sec->_raw_size;
stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
if (stub_sec->contents == NULL && size != 0)
return FALSE;
stub_sec->_raw_size = 0;
}
table = &htab->stub_hash_table;
bfd_hash_traverse (table, hppa_build_one_stub, info);
return TRUE;
}
static bfd_boolean
elf32_hppa_final_link (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
if (!bfd_elf32_bfd_final_link (abfd, info))
return FALSE;
return elf_hppa_sort_unwind (abfd);
}
static void
hppa_record_segment_addr (abfd, section, data)
bfd *abfd ATTRIBUTE_UNUSED;
asection *section;
PTR data;
{
struct elf32_hppa_link_hash_table *htab;
htab = (struct elf32_hppa_link_hash_table *) data;
if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
bfd_vma value = section->vma - section->filepos;
if ((section->flags & SEC_READONLY) != 0)
{
if (value < htab->text_segment_base)
htab->text_segment_base = value;
}
else
{
if (value < htab->data_segment_base)
htab->data_segment_base = value;
}
}
}
static bfd_reloc_status_type
final_link_relocate (input_section, contents, rel, value, htab, sym_sec, h)
asection *input_section;
bfd_byte *contents;
const Elf_Internal_Rela *rel;
bfd_vma value;
struct elf32_hppa_link_hash_table *htab;
asection *sym_sec;
struct elf32_hppa_link_hash_entry *h;
{
int insn;
unsigned int r_type = ELF32_R_TYPE (rel->r_info);
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 max_branch_offset = 0;
bfd_byte *hit_data = contents + offset;
bfd_signed_vma addend = rel->r_addend;
bfd_vma location;
struct elf32_hppa_stub_hash_entry *stub_entry = NULL;
int val;
if (r_type == R_PARISC_NONE)
return bfd_reloc_ok;
insn = bfd_get_32 (input_bfd, hit_data);
location = (offset +
input_section->output_offset +
input_section->output_section->vma);
switch (r_type)
{
case R_PARISC_PCREL12F:
case R_PARISC_PCREL17F:
case R_PARISC_PCREL22F:
if (sym_sec == NULL
|| sym_sec->output_section == NULL
|| (h != NULL
&& h->elf.plt.offset != (bfd_vma) -1
&& (h->elf.dynindx != -1 || h->pic_call)
&& !h->plabel))
{
stub_entry = hppa_get_stub_entry (input_section, sym_sec,
h, rel, htab);
if (stub_entry != NULL)
{
value = (stub_entry->stub_offset
+ stub_entry->stub_sec->output_offset
+ stub_entry->stub_sec->output_section->vma);
addend = 0;
}
else if (sym_sec == NULL && h != NULL
&& h->elf.root.type == bfd_link_hash_undefweak)
{
value = location;
addend = 8;
}
else
return bfd_reloc_undefined;
}
case R_PARISC_PCREL21L:
case R_PARISC_PCREL17C:
case R_PARISC_PCREL17R:
case R_PARISC_PCREL14R:
case R_PARISC_PCREL14F:
value -= location;
addend -= 8;
break;
case R_PARISC_DPREL21L:
case R_PARISC_DPREL14R:
case R_PARISC_DPREL14F:
if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
{
if ((insn & ((0x3f << 26) | (0x1f << 21)))
== (((int) OP_ADDIL << 26) | (27 << 21)))
{
insn &= ~ (0x1f << 21);
#if 0
(*_bfd_error_handler)
(_("%s(%s+0x%lx): fixing %s"),
bfd_archive_filename (input_bfd),
input_section->name,
(long) rel->r_offset,
howto->name);
#endif
}
break;
}
case R_PARISC_DLTIND21L:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND14F:
value -= elf_gp (input_section->output_section->owner);
break;
case R_PARISC_SEGREL32:
if ((sym_sec->flags & SEC_CODE) != 0)
value -= htab->text_segment_base;
else
value -= htab->data_segment_base;
break;
default:
break;
}
switch (r_type)
{
case R_PARISC_DIR32:
case R_PARISC_DIR14F:
case R_PARISC_DIR17F:
case R_PARISC_PCREL17C:
case R_PARISC_PCREL14F:
case R_PARISC_DPREL14F:
case R_PARISC_PLABEL32:
case R_PARISC_DLTIND14F:
case R_PARISC_SEGBASE:
case R_PARISC_SEGREL32:
r_field = e_fsel;
break;
case R_PARISC_DLTIND21L:
case R_PARISC_PCREL21L:
case R_PARISC_PLABEL21L:
r_field = e_lsel;
break;
case R_PARISC_DIR21L:
case R_PARISC_DPREL21L:
r_field = e_lrsel;
break;
case R_PARISC_PCREL17R:
case R_PARISC_PCREL14R:
case R_PARISC_PLABEL14R:
case R_PARISC_DLTIND14R:
r_field = e_rsel;
break;
case R_PARISC_DIR17R:
case R_PARISC_DIR14R:
case R_PARISC_DPREL14R:
r_field = e_rrsel;
break;
case R_PARISC_PCREL12F:
case R_PARISC_PCREL17F:
case R_PARISC_PCREL22F:
r_field = e_fsel;
if (r_type == (unsigned int) R_PARISC_PCREL17F)
{
max_branch_offset = (1 << (17-1)) << 2;
}
else if (r_type == (unsigned int) R_PARISC_PCREL12F)
{
max_branch_offset = (1 << (12-1)) << 2;
}
else
{
max_branch_offset = (1 << (22-1)) << 2;
}
if (sym_sec == NULL)
break;
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)
return bfd_reloc_undefined;
value = (stub_entry->stub_offset
+ stub_entry->stub_sec->output_offset
+ stub_entry->stub_sec->output_section->vma
- location);
addend = -8;
}
break;
default:
return bfd_reloc_notsupported;
}
if (max_branch_offset != 0
&& value + addend + max_branch_offset >= 2*max_branch_offset)
{
(*_bfd_error_handler)
(_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
bfd_archive_filename (input_bfd),
input_section->name,
(long) rel->r_offset,
stub_entry->root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
}
val = hppa_field_adjust (value, addend, r_field);
switch (r_type)
{
case R_PARISC_PCREL12F:
case R_PARISC_PCREL17C:
case R_PARISC_PCREL17F:
case R_PARISC_PCREL17R:
case R_PARISC_PCREL22F:
case R_PARISC_DIR17F:
case R_PARISC_DIR17R:
val >>= 2;
break;
default:
break;
}
insn = hppa_rebuild_insn (insn, val, r_format);
bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
return bfd_reloc_ok;
}
static bfd_boolean
elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
contents, relocs, local_syms, local_sections)
bfd *output_bfd;
struct bfd_link_info *info;
bfd *input_bfd;
asection *input_section;
bfd_byte *contents;
Elf_Internal_Rela *relocs;
Elf_Internal_Sym *local_syms;
asection **local_sections;
{
bfd_vma *local_got_offsets;
struct elf32_hppa_link_hash_table *htab;
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Rela *rel;
Elf_Internal_Rela *relend;
if (info->relocateable)
return TRUE;
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
htab = hppa_link_hash_table (info);
local_got_offsets = elf_local_got_offsets (input_bfd);
rel = relocs;
relend = relocs + input_section->reloc_count;
for (; rel < relend; rel++)
{
unsigned int r_type;
reloc_howto_type *howto;
unsigned int r_symndx;
struct elf32_hppa_link_hash_entry *h;
Elf_Internal_Sym *sym;
asection *sym_sec;
bfd_vma relocation;
bfd_reloc_status_type r;
const char *sym_name;
bfd_boolean plabel;
bfd_boolean warned_undef;
r_type = ELF32_R_TYPE (rel->r_info);
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
{
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
|| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
continue;
r_symndx = ELF32_R_SYM (rel->r_info);
h = NULL;
sym = NULL;
sym_sec = NULL;
warned_undef = FALSE;
if (r_symndx < symtab_hdr->sh_info)
{
sym = local_syms + r_symndx;
sym_sec = local_sections[r_symndx];
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
}
else
{
int indx;
indx = r_symndx - symtab_hdr->sh_info;
h = ((struct elf32_hppa_link_hash_entry *)
elf_sym_hashes (input_bfd)[indx]);
while (h->elf.root.type == bfd_link_hash_indirect
|| h->elf.root.type == bfd_link_hash_warning)
h = (struct elf32_hppa_link_hash_entry *) h->elf.root.u.i.link;
relocation = 0;
if (h->elf.root.type == bfd_link_hash_defined
|| h->elf.root.type == bfd_link_hash_defweak)
{
sym_sec = h->elf.root.u.def.section;
if (sym_sec->output_section != NULL)
relocation = (h->elf.root.u.def.value
+ sym_sec->output_offset
+ sym_sec->output_section->vma);
}
else if (h->elf.root.type == bfd_link_hash_undefweak)
;
else if (info->shared && !info->no_undefined
&& ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
&& h->elf.type != STT_PARISC_MILLI)
{
if (info->symbolic && !info->allow_shlib_undefined)
{
if (!((*info->callbacks->undefined_symbol)
(info, h->elf.root.root.string, input_bfd,
input_section, rel->r_offset, FALSE)))
return FALSE;
warned_undef = TRUE;
}
}
else
{
if (!((*info->callbacks->undefined_symbol)
(info, h->elf.root.root.string, input_bfd,
input_section, rel->r_offset, TRUE)))
return FALSE;
warned_undef = TRUE;
}
}
plabel = 0;
switch (r_type)
{
case R_PARISC_DLTIND14F:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND21L:
{
bfd_vma off;
bfd_boolean do_got = 0;
if (h != NULL)
{
bfd_boolean dyn;
off = h->elf.got.offset;
dyn = htab->elf.dynamic_sections_created;
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, &h->elf))
{
if ((off & 1) != 0)
off &= ~1;
else
{
h->elf.got.offset |= 1;
do_got = 1;
}
}
}
else
{
if (local_got_offsets == NULL)
abort ();
off = local_got_offsets[r_symndx];
if ((off & 1) != 0)
off &= ~1;
else
{
local_got_offsets[r_symndx] |= 1;
do_got = 1;
}
}
if (do_got)
{
if (info->shared)
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
asection *s = htab->srelgot;
outrel.r_offset = (off
+ htab->sgot->output_offset
+ htab->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);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
else
bfd_put_32 (output_bfd, relocation,
htab->sgot->contents + off);
}
if (off >= (bfd_vma) -2)
abort ();
relocation = (off
+ htab->sgot->output_offset
+ htab->sgot->output_section->vma);
}
break;
case R_PARISC_SEGREL32:
if (htab->text_segment_base == (bfd_vma) -1)
bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
break;
case R_PARISC_PLABEL14R:
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
if (htab->elf.dynamic_sections_created)
{
bfd_vma off;
bfd_boolean do_plt = 0;
if (h != NULL)
{
off = h->elf.plt.offset;
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, &h->elf))
{
if ((off & 1) != 0)
off &= ~1;
else
{
h->elf.plt.offset |= 1;
do_plt = 1;
}
}
}
else
{
bfd_vma *local_plt_offsets;
if (local_got_offsets == NULL)
abort ();
local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
off = local_plt_offsets[r_symndx];
if ((off & 1) != 0)
off &= ~1;
else
{
local_plt_offsets[r_symndx] |= 1;
do_plt = 1;
}
}
if (do_plt)
{
if (info->shared)
{
Elf_Internal_Rela outrel;
bfd_byte *loc;
asection *s = htab->srelplt;
outrel.r_offset = (off
+ htab->splt->output_offset
+ htab->splt->output_section->vma);
outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
outrel.r_addend = relocation;
loc = s->contents;
loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
else
{
bfd_put_32 (output_bfd,
relocation,
htab->splt->contents + off);
bfd_put_32 (output_bfd,
elf_gp (htab->splt->output_section->owner),
htab->splt->contents + off + 4);
}
}
if (off >= (bfd_vma) -2)
abort ();
if (h == NULL
|| (h->elf.root.type != bfd_link_hash_undefweak
&& h->elf.root.type != bfd_link_hash_undefined))
{
relocation = (off
+ htab->splt->output_offset
+ htab->splt->output_section->vma
+ 2);
}
plabel = 1;
}
case R_PARISC_DIR17F:
case R_PARISC_DIR17R:
case R_PARISC_DIR14F:
case R_PARISC_DIR14R:
case R_PARISC_DIR21L:
case R_PARISC_DPREL14F:
case R_PARISC_DPREL14R:
case R_PARISC_DPREL21L:
case R_PARISC_DIR32:
if (r_symndx == 0
|| (input_section->flags & SEC_ALLOC) == 0)
break;
if ((info->shared
&& (IS_ABSOLUTE_RELOC (r_type)
|| (h != NULL
&& h->elf.dynindx != -1
&& (!info->symbolic
|| (h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
|| (!info->shared
&& h != NULL
&& h->elf.dynindx != -1
&& (h->elf.elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
&& (((h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC) != 0
&& (h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0)
|| h->elf.root.type == bfd_link_hash_undefweak
|| h->elf.root.type == bfd_link_hash_undefined)))
{
Elf_Internal_Rela outrel;
bfd_boolean skip;
asection *sreloc;
bfd_byte *loc;
outrel.r_addend = rel->r_addend;
outrel.r_offset =
_bfd_elf_section_offset (output_bfd, info, input_section,
rel->r_offset);
skip = (outrel.r_offset == (bfd_vma) -1
|| outrel.r_offset == (bfd_vma) -2);
outrel.r_offset += (input_section->output_offset
+ input_section->output_section->vma);
if (skip)
{
memset (&outrel, 0, sizeof (outrel));
}
else if (h != NULL
&& h->elf.dynindx != -1
&& (plabel
|| !IS_ABSOLUTE_RELOC (r_type)
|| !info->shared
|| !info->symbolic
|| (h->elf.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR) == 0))
{
outrel.r_info = ELF32_R_INFO (h->elf.dynindx, r_type);
}
else
{
int indx = 0;
outrel.r_addend += relocation;
if (! plabel
&& sym_sec != NULL
&& sym_sec->output_section != NULL
&& ! bfd_is_abs_section (sym_sec))
{
indx = elf_section_data (sym_sec->output_section)->dynindx;
outrel.r_addend -= sym_sec->output_section->vma;
}
outrel.r_info = ELF32_R_INFO (indx, r_type);
}
#if 0
if (r_type == R_PARISC_DIR32 && (outrel.r_offset & 3) != 0)
outrel.r_info = ELF32_R_INFO (ELF32_R_SYM (outrel.r_info),
R_PARISC_DIR32U);
#endif
sreloc = elf_section_data (input_section)->sreloc;
if (sreloc == NULL)
abort ();
loc = sreloc->contents;
loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
break;
default:
break;
}
r = final_link_relocate (input_section, contents, rel, relocation,
htab, sym_sec, h);
if (r == bfd_reloc_ok)
continue;
if (h != NULL)
sym_name = h->elf.root.root.string;
else
{
sym_name = bfd_elf_string_from_elf_section (input_bfd,
symtab_hdr->sh_link,
sym->st_name);
if (sym_name == NULL)
return FALSE;
if (*sym_name == '\0')
sym_name = bfd_section_name (input_bfd, sym_sec);
}
howto = elf_hppa_howto_table + r_type;
if (r == bfd_reloc_undefined || r == bfd_reloc_notsupported)
{
if (r == bfd_reloc_notsupported || !warned_undef)
{
(*_bfd_error_handler)
(_("%s(%s+0x%lx): cannot handle %s for %s"),
bfd_archive_filename (input_bfd),
input_section->name,
(long) rel->r_offset,
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
}
else
{
if (!((*info->callbacks->reloc_overflow)
(info, sym_name, howto->name, (bfd_vma) 0,
input_bfd, input_section, rel->r_offset)))
return FALSE;
}
}
return TRUE;
}
static bfd_boolean
elf32_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
bfd *output_bfd;
struct bfd_link_info *info;
struct elf_link_hash_entry *h;
Elf_Internal_Sym *sym;
{
struct elf32_hppa_link_hash_table *htab;
htab = hppa_link_hash_table (info);
if (h->plt.offset != (bfd_vma) -1)
{
bfd_vma value;
if (h->plt.offset & 1)
abort ();
value = 0;
if (h->root.type == bfd_link_hash_defined
|| h->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);
}
if (! ((struct elf32_hppa_link_hash_entry *) h)->pic_call)
{
Elf_Internal_Rela rel;
bfd_byte *loc;
rel.r_offset = (h->plt.offset
+ htab->splt->output_offset
+ htab->splt->output_section->vma);
if (h->dynindx != -1)
{
rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_IPLT);
rel.r_addend = 0;
}
else
{
rel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
rel.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);
}
else
{
bfd_put_32 (htab->splt->owner,
value,
htab->splt->contents + h->plt.offset);
bfd_put_32 (htab->splt->owner,
elf_gp (htab->splt->output_section->owner),
htab->splt->contents + h->plt.offset + 4);
}
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
{
sym->st_shndx = SHN_UNDEF;
}
}
if (h->got.offset != (bfd_vma) -1)
{
Elf_Internal_Rela rel;
bfd_byte *loc;
rel.r_offset = ((h->got.offset &~ (bfd_vma) 1)
+ htab->sgot->output_offset
+ htab->sgot->output_section->vma);
if (info->shared
&& (info->symbolic || h->dynindx == -1)
&& (h->elf_link_hash_flags & ELF_LINK_HASH_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
{
if ((h->got.offset & 1) != 0)
abort ();
bfd_put_32 (output_bfd, (bfd_vma) 0,
htab->sgot->contents + h->got.offset);
rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_DIR32);
rel.r_addend = 0;
}
loc = htab->srelgot->contents;
loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
}
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
{
asection *s;
Elf_Internal_Rela rel;
bfd_byte *loc;
if (! (h->dynindx != -1
&& (h->root.type == bfd_link_hash_defined
|| h->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);
}
if (h->root.root.string[0] == '_'
&& (strcmp (h->root.root.string, "_DYNAMIC") == 0
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0))
{
sym->st_shndx = SHN_ABS;
}
return TRUE;
}
static enum elf_reloc_type_class
elf32_hppa_reloc_type_class (rela)
const Elf_Internal_Rela *rela;
{
if (ELF32_R_SYM (rela->r_info) == 0)
return reloc_class_relative;
switch ((int) ELF32_R_TYPE (rela->r_info))
{
case R_PARISC_IPLT:
return reloc_class_plt;
case R_PARISC_COPY:
return reloc_class_copy;
default:
return reloc_class_normal;
}
}
static bfd_boolean
elf32_hppa_finish_dynamic_sections (output_bfd, info)
bfd *output_bfd;
struct bfd_link_info *info;
{
bfd *dynobj;
struct elf32_hppa_link_hash_table *htab;
asection *sdyn;
htab = hppa_link_hash_table (info);
dynobj = htab->elf.dynobj;
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
if (htab->elf.dynamic_sections_created)
{
Elf32_External_Dyn *dyncon, *dynconend;
if (sdyn == NULL)
abort ();
dyncon = (Elf32_External_Dyn *) sdyn->contents;
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
for (; dyncon < dynconend; dyncon++)
{
Elf_Internal_Dyn dyn;
asection *s;
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
switch (dyn.d_tag)
{
default:
continue;
case DT_PLTGOT:
dyn.d_un.d_ptr = elf_gp (output_bfd);
break;
case DT_JMPREL:
s = htab->srelplt;
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
break;
case DT_PLTRELSZ:
s = htab->srelplt;
dyn.d_un.d_val = s->_raw_size;
break;
case DT_RELASZ:
s = htab->srelplt;
if (s == NULL)
continue;
dyn.d_un.d_val -= s->_raw_size;
break;
case DT_RELA:
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->_raw_size;
break;
}
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
}
}
if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
{
bfd_put_32 (output_bfd,
(sdyn != NULL
? sdyn->output_section->vma + sdyn->output_offset
: (bfd_vma) 0),
htab->sgot->contents);
memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
elf_section_data (htab->sgot->output_section)
->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
}
if (htab->splt != NULL && htab->splt->_raw_size != 0)
{
elf_section_data (htab->splt->output_section)
->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
if (htab->need_plt_stub)
{
memcpy (htab->splt->contents
+ htab->splt->_raw_size - sizeof (plt_stub),
plt_stub, sizeof (plt_stub));
if ((htab->splt->output_offset
+ htab->splt->output_section->vma
+ htab->splt->_raw_size)
!= (htab->sgot->output_offset
+ htab->sgot->output_section->vma))
{
(*_bfd_error_handler)
(_(".got section not immediately after .plt section"));
return FALSE;
}
}
}
return TRUE;
}
static void
elf32_hppa_post_process_headers (abfd, link_info)
bfd *abfd;
struct bfd_link_info *link_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
{
i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
}
}
static int
elf32_hppa_elf_get_symbol_type (elf_sym, type)
Elf_Internal_Sym *elf_sym;
int type;
{
if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
return STT_PARISC_MILLI;
else
return type;
}
#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 elf_info_to_howto elf_hppa_info_to_howto
#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
#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_add_symbol_hook elf32_hppa_add_symbol_hook
#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_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_hide_symbol elf32_hppa_hide_symbol
#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_gc_mark_hook elf32_hppa_gc_mark_hook
#define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
#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_can_gc_sections 1
#define elf_backend_can_refcount 1
#define elf_backend_plt_alignment 2
#define elf_backend_want_got_plt 0
#define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 0
#define elf_backend_got_header_size 8
#define elf_backend_rela_normal 1
#define TARGET_BIG_SYM bfd_elf32_hppa_vec
#define TARGET_BIG_NAME "elf32-hppa"
#define ELF_ARCH bfd_arch_hppa
#define ELF_MACHINE_CODE EM_PARISC
#define ELF_MAXPAGESIZE 0x1000
#include "elf32-target.h"
#undef TARGET_BIG_SYM
#define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
#undef TARGET_BIG_NAME
#define TARGET_BIG_NAME "elf32-hppa-linux"
#define INCLUDED_TARGET_FILE 1
#include "elf32-target.h"