This is the mail archive of the
binutils@sources.redhat.com
mailing list for the binutils project.
[PATCH] Naming consistency in bfd/elf32-hppa.c
- From: Carlos O'Donell <carlos at systemhalted dot org>
- To: binutils at sources dot redhat dot com
- Cc: John David Anglin <dave dot anglin at nrc-cnrc dot gc dot ca>,Randolph Chung <tausq at debian dot org>
- Date: Mon, 20 Jun 2005 14:22:29 -0400
- Subject: [PATCH] Naming consistency in bfd/elf32-hppa.c
binutils,
A group of us is are working on TLS for hppa, along with a number of
more general fixes including the addition of full OPD's for hppa-linux.
To kick off the show I would like to do a full scrub of elf32-hppa.c.
This file is difficult to read for a variety of resons including single
character variables, interchanging between base hash table types and
using the same name. Confusing to say the least. The comment at the
beggining of the file informs the reader of our coding conventions.
So instead of 'h' or 'hh' or 'hhh' we now denote meaning with either
'eh' 'hh' or 'hsh' (elf base hash table, hppa derived, hppa stub hash).
Passes the testsuite without regression. Builds the entire toolchain,
including gcc 4.0.0 testsuite, and glibc upstream cvs head testsuite
without regression.
Please apply.
2005-06-20 Carlos O'Donell <carlos@systemhalted.org>
* bfd/elf32-hppa.c (hppa_elf_hash_entry): Define.
(hppa_stub_hash_entry): Define.
(stub_hash_newfunc): Rename variables.
(hppa_link_hash_newfunc): Likewise.
(elf32_hppa_link_hash_table_free): Likewise.
(hppa_stub_name): Likewise.
(hppa_get_stub_entry): Likewise.
(hppa_add_stub): Likewise.
(hppa_type_of_stub): Likewise.
(hppa_build_one_stub): Likewise.
(hppa_size_one_stub): Likewise.
(elf32_hppa_create_dynamic_sections): Likewise.
(elf32_hppa_copy_indirect_symbol): Likewise.
(elf32_hppa_check_relocs): Likewise.
(elf32_hppa_gc_mark_hook): Likewise.
(elf32_hppa_gc_sweep_hook): Likewise.
(elf32_hppa_grok_psinfo): Likewise.
(elf32_hppa_hide_symbol): Likewise.
(elf32_hppa_adjust_dynamic_symbol): Likewise.
(allocate_dynrelocs): Likewise.
(clobber_millicode_symbols): Likewise.
(readonly_dynrelocs): Likewise.
(elf32_hppa_size_dynamic_sections): Likewise.
(get_local_syms): Likewise.
(elf32_hppa_size_stubs): Likewise.
(hppa_record_segment_addr): Likewise.
(final_link_relocate): Likewise.
(elf32_hppa_relocate_section): Likewise.
(elf32_hppa_finish_dynamic_symbol): Likewise.
Index: elf32-hppa.c
===================================================================
RCS file: /cvs/src/src/bfd/elf32-hppa.c,v
retrieving revision 1.133
diff -u -p -r1.133 elf32-hppa.c
--- elf32-hppa.c 20 Jun 2005 13:06:27 -0000 1.133
+++ elf32-hppa.c 20 Jun 2005 18:10:34 -0000
@@ -113,6 +113,24 @@
: 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"
+
+ elf32_hppa_dyn_reloc_entry "hdh" */
+
#define PLT_ENTRY_SIZE 8
#define GOT_ENTRY_SIZE 4
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
@@ -277,6 +295,12 @@ struct elf32_hppa_link_hash_table {
#define hppa_link_hash_table(p) \
((struct elf32_hppa_link_hash_table *) ((p)->hash))
+#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)))
@@ -304,17 +328,17 @@ stub_hash_newfunc (struct bfd_hash_entry
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->h = NULL;
+ hsh->id_sec = NULL;
}
return entry;
@@ -341,13 +365,13 @@ hppa_link_hash_newfunc (struct bfd_hash_
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->stub_cache = NULL;
+ hh->dyn_relocs = NULL;
+ hh->plabel = 0;
}
return entry;
@@ -360,55 +384,55 @@ hppa_link_hash_newfunc (struct bfd_hash_
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 = (struct elf32_hppa_link_hash_table *) bfd_malloc (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->elf, abfd, hppa_link_hash_newfunc))
{
- free (ret);
+ free (htab);
return NULL;
}
/* Init the stub hash table too. */
- if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc))
+ if (!bfd_hash_table_init (&htab->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;
+ htab->stub_bfd = NULL;
+ htab->add_stub_section = NULL;
+ htab->layout_sections_again = NULL;
+ htab->stub_group = NULL;
+ htab->sgot = NULL;
+ htab->srelgot = NULL;
+ htab->splt = NULL;
+ htab->srelplt = NULL;
+ htab->sdynbss = NULL;
+ htab->srelbss = NULL;
+ htab->text_segment_base = (bfd_vma) -1;
+ htab->data_segment_base = (bfd_vma) -1;
+ htab->multi_subspace = 0;
+ htab->has_12bit_branch = 0;
+ htab->has_17bit_branch = 0;
+ htab->has_22bit_branch = 0;
+ htab->need_plt_stub = 0;
+ htab->sym_sec.abfd = NULL;
- return &ret->elf.root;
+ return &htab->elf.root;
}
/* Free the derived linker hash table. */
static void
-elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *hash)
+elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *btab)
{
- struct elf32_hppa_link_hash_table *ret
- = (struct elf32_hppa_link_hash_table *) hash;
+ struct elf32_hppa_link_hash_table *htab
+ = (struct elf32_hppa_link_hash_table *) btab;
- bfd_hash_table_free (&ret->stub_hash_table);
- _bfd_generic_link_hash_table_free (hash);
+ bfd_hash_table_free (&htab->stub_hash_table);
+ _bfd_generic_link_hash_table_free (btab);
}
/* Build a name for an entry in the stub hash table. */
@@ -416,22 +440,22 @@ elf32_hppa_link_hash_table_free (struct
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->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);
+ hh->elf.root.root.string,
+ (int) rela->r_addend & 0xffffffff);
}
}
else
@@ -443,8 +467,8 @@ hppa_stub_name (const asection *input_se
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);
+ (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
+ (int) rela->r_addend & 0xffffffff);
}
}
return stub_name;
@@ -456,8 +480,8 @@ hppa_stub_name (const asection *input_se
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;
@@ -470,24 +494,24 @@ hppa_get_stub_entry (const asection *inp
distinguish between them. */
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)
+ if (hh != NULL && hh->stub_cache != NULL
+ && hh->stub_cache->h == hh
+ && hh->stub_cache->id_sec == id_sec)
{
- stub_entry = hash->stub_cache;
+ stub_entry = hh->stub_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,
stub_name, FALSE, FALSE);
- if (hash != NULL)
- hash->stub_cache = stub_entry;
+ if (hh != NULL)
+ hh->stub_cache = stub_entry;
free (stub_name);
}
@@ -505,7 +529,7 @@ hppa_add_stub (const char *stub_name,
{
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;
@@ -535,9 +559,9 @@ hppa_add_stub (const char *stub_name,
}
/* 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->stub_hash_table, stub_name,
TRUE, FALSE);
- if (stub_entry == NULL)
+ if (hsh == NULL)
{
(*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
section->owner,
@@ -545,18 +569,18 @@ hppa_add_stub (const char *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)
{
@@ -565,13 +589,13 @@ hppa_type_of_stub (asection *input_sec,
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
+ if (hh != NULL
+ && hh->elf.plt.offset != (bfd_vma) -1
+ && hh->elf.dynindx != -1
+ && !hh->plabel
&& (info->shared
- || !hash->elf.def_regular
- || hash->elf.root.type == bfd_link_hash_defweak))
+ || !hh->elf.def_regular
+ || hh->elf.root.type == bfd_link_hash_defweak))
{
/* We need an import stub. Decide between hppa_stub_import
and hppa_stub_import_shared later. */
@@ -581,10 +605,10 @@ hppa_type_of_stub (asection *input_sec,
/* 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
@@ -650,9 +674,9 @@ hppa_type_of_stub (asection *input_sec,
#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;
@@ -665,28 +689,28 @@ hppa_build_one_stub (struct bfd_hash_ent
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;
+ 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);
@@ -701,12 +725,12 @@ hppa_build_one_stub (struct bfd_hash_ent
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);
@@ -723,7 +747,7 @@ hppa_build_one_stub (struct bfd_hash_ent
case hppa_stub_import:
case hppa_stub_import_shared:
- off = stub_entry->h->elf.plt.offset;
+ off = hsh->h->elf.plt.offset;
if (off >= (bfd_vma) -2)
abort ();
@@ -735,7 +759,7 @@ hppa_build_one_stub (struct bfd_hash_ent
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
val = hppa_field_adjust (sym_value, 0, e_lrsel),
@@ -778,12 +802,12 @@ hppa_build_one_stub (struct bfd_hash_ent
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);
@@ -793,10 +817,10 @@ hppa_build_one_stub (struct bfd_hash_ent
{
(*_bfd_error_handler)
(_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
- stub_entry->target_section->owner,
+ hsh->target_section->owner,
stub_sec,
- (long) stub_entry->stub_offset,
- stub_entry->root.string);
+ (long) hsh->stub_offset,
+ hsh->root.string);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
@@ -815,8 +839,8 @@ hppa_build_one_stub (struct bfd_hash_ent
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->h->elf.root.u.def.section = stub_sec;
+ hsh->h->elf.root.u.def.value = stub_sec->size;
size = 24;
break;
@@ -855,21 +879,21 @@ hppa_build_one_stub (struct bfd_hash_ent
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)
+ if (hsh->stub_type == hppa_stub_long_branch)
size = 8;
- else if (stub_entry->stub_type == hppa_stub_long_branch_shared)
+ else if (hsh->stub_type == hppa_stub_long_branch_shared)
size = 12;
- else if (stub_entry->stub_type == hppa_stub_export)
+ else if (hsh->stub_type == hppa_stub_export)
size = 24;
else /* hppa_stub_import or hppa_stub_import_shared. */
{
@@ -879,7 +903,7 @@ hppa_size_one_stub (struct bfd_hash_entr
size = 16;
}
- stub_entry->stub_sec->size += size;
+ hsh->stub_sec->size += size;
return TRUE;
}
@@ -937,7 +961,7 @@ static bfd_boolean
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);
@@ -968,74 +992,74 @@ elf32_hppa_create_dynamic_sections (bfd
/* 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)
+ 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)
{
- 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;
+ struct elf32_hppa_dyn_reloc_entry **hdh_pp;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
- if (ind->root.type == bfd_link_hash_indirect)
+ if (eh_ind->root.type == bfd_link_hash_indirect)
abort ();
/* Add reloc counts against the weak sym to the strong 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 elf32_hppa_dyn_reloc_entry *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->relative_count += hdh_p->relative_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)
+ && eh_ind->root.type != bfd_link_hash_indirect
+ && eh_dir->dynamic_adjusted)
{
/* 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;
+ eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
+ eh_dir->ref_regular |= eh_ind->ref_regular;
+ eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak;
+ eh_dir->needs_plt |= eh_ind->needs_plt;
}
else
- _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
+ _bfd_elf_link_hash_copy_indirect (bed, eh_dir, eh_ind);
}
/* Look through the relocs for a section during the first phase, and
@@ -1050,9 +1074,9 @@ elf32_hppa_check_relocs (bfd *abfd,
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;
@@ -1062,12 +1086,12 @@ elf32_hppa_check_relocs (bfd *abfd,
htab = hppa_link_hash_table (info);
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,
@@ -1077,23 +1101,22 @@ elf32_hppa_check_relocs (bfd *abfd,
};
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]);
- 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;
+ {
+ hh = hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
+ while (hh->elf.root.type == bfd_link_hash_indirect
+ || hh->elf.root.type == bfd_link_hash_warning)
+ hh = hppa_elf_hash_entry (hh->elf.root.u.i.link);
}
- r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rela->r_info);
switch (r_type)
{
@@ -1108,7 +1131,7 @@ elf32_hppa_check_relocs (bfd *abfd,
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
@@ -1116,6 +1139,7 @@ elf32_hppa_check_relocs (bfd *abfd,
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
@@ -1144,7 +1168,7 @@ elf32_hppa_check_relocs (bfd *abfd,
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
@@ -1161,7 +1185,7 @@ elf32_hppa_check_relocs (bfd *abfd,
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->elf.type == STT_PARISC_MILLI)
need_entry = 0;
}
break;
@@ -1204,14 +1228,14 @@ elf32_hppa_check_relocs (bfd *abfd,
/* 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->elf, 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->elf, rela->r_addend))
return FALSE;
continue;
@@ -1232,15 +1256,14 @@ elf32_hppa_check_relocs (bfd *abfd,
return FALSE;
}
- if (h != NULL)
+ if (hh != NULL)
{
- h->elf.got.refcount += 1;
+ hh->elf.got.refcount += 1;
}
else
{
bfd_signed_vma *local_got_refcounts;
-
- /* This is a global offset table entry for a local symbol. */
+ /* This is a global offset table entry for a local symbol. */
local_got_refcounts = elf_local_got_refcounts (abfd);
if (local_got_refcounts == NULL)
{
@@ -1273,16 +1296,16 @@ elf32_hppa_check_relocs (bfd *abfd,
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->elf.needs_plt = 1;
+ hh->elf.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)
{
@@ -1315,8 +1338,8 @@ elf32_hppa_check_relocs (bfd *abfd,
/* 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 && !info->shared)
+ hh->elf.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
@@ -1349,19 +1372,19 @@ elf32_hppa_check_relocs (bfd *abfd,
if ((info->shared
&& (sec->flags & SEC_ALLOC) != 0
&& (IS_ABSOLUTE_RELOC (r_type)
- || (h != NULL
+ || (hh != NULL
&& (!info->symbolic
- || h->elf.root.type == bfd_link_hash_defweak
- || !h->elf.def_regular))))
+ || hh->elf.root.type == bfd_link_hash_defweak
+ || !hh->elf.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)))
+ && hh != NULL
+ && (hh->elf.root.type == bfd_link_hash_defweak
+ || !hh->elf.def_regular)))
{
- struct elf32_hppa_dyn_reloc_entry *p;
- struct elf32_hppa_dyn_reloc_entry **head;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
+ struct elf32_hppa_dyn_reloc_entry **hdh_head;
/* Create a reloc section in dynobj and make room for
this reloc. */
@@ -1409,9 +1432,9 @@ elf32_hppa_check_relocs (bfd *abfd,
/* 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
{
@@ -1419,35 +1442,35 @@ elf32_hppa_check_relocs (bfd *abfd,
We really need local syms available to do this
easily. Oh well. */
- asection *s;
- s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
- sec, r_symndx);
- if (s == NULL)
+ asection *sr;
+ sr = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
+ sec, r_symndx);
+ if (sr == NULL)
return FALSE;
- head = ((struct elf32_hppa_dyn_reloc_entry **)
- &elf_section_data (s)->local_dynrel);
+ hdh_head = ((struct elf32_hppa_dyn_reloc_entry **)
+ &elf_section_data (sr)->local_dynrel);
}
- 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->elf.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->relative_count = 0;
#endif
}
- p->count += 1;
+ hdh_p->count += 1;
#if RELATIVE_DYNRELOCS
if (!IS_ABSOLUTE_RELOC (rtype))
- p->relative_count += 1;
+ hdh_p->relative_count += 1;
#endif
}
}
@@ -1462,27 +1485,27 @@ elf32_hppa_check_relocs (bfd *abfd,
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,
+ Elf_Internal_Rela *rela,
+ struct elf_link_hash_entry *hh,
Elf_Internal_Sym *sym)
{
- if (h != NULL)
+ if (hh != NULL)
{
- switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
+ switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
{
case R_PARISC_GNU_VTINHERIT:
case R_PARISC_GNU_VTENTRY:
break;
default:
- switch (h->root.type)
+ switch (hh->root.type)
{
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
- return h->root.u.def.section;
+ return hh->root.u.def.section;
case bfd_link_hash_common:
- return h->root.u.c.p->section;
+ return hh->root.u.c.p->section;
default:
break;
@@ -1505,59 +1528,59 @@ elf32_hppa_gc_sweep_hook (bfd *abfd,
const Elf_Internal_Rela *relocs)
{
Elf_Internal_Shdr *symtab_hdr;
- struct elf_link_hash_entry **sym_hashes;
+ struct elf_link_hash_entry **eh_syms;
bfd_signed_vma *local_got_refcounts;
bfd_signed_vma *local_plt_refcounts;
- const Elf_Internal_Rela *rel, *relend;
+ const Elf_Internal_Rela *rela, *relend;
elf_section_data (sec)->local_dynrel = NULL;
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
- sym_hashes = elf_sym_hashes (abfd);
+ eh_syms = 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++)
+ for (rela = relocs; rela < relend; rela++)
{
unsigned long r_symndx;
unsigned int r_type;
- struct elf_link_hash_entry *h = NULL;
+ struct elf_link_hash_entry *eh = NULL;
- r_symndx = ELF32_R_SYM (rel->r_info);
+ r_symndx = ELF32_R_SYM (rela->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;
+ struct elf32_hppa_link_hash_entry *hh;
+ struct elf32_hppa_dyn_reloc_entry **hdh_pp;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
+
+ eh = eh_syms[r_symndx - symtab_hdr->sh_info];
+ while (eh->root.type == bfd_link_hash_indirect
+ || eh->root.type == bfd_link_hash_warning)
+ eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
+ hh = hppa_elf_hash_entry (eh);
- for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
- if (p->sec == sec)
+ for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; hdh_pp = &hdh_p->next)
+ if (hdh_p->sec == sec)
{
/* Everything must go for SEC. */
- *pp = p->next;
+ *hdh_pp = hdh_p->next;
break;
}
}
- r_type = ELF32_R_TYPE (rel->r_info);
+ r_type = ELF32_R_TYPE (rela->r_info);
switch (r_type)
{
case R_PARISC_DLTIND14F:
case R_PARISC_DLTIND14R:
case R_PARISC_DLTIND21L:
- if (h != NULL)
+ if (eh != NULL)
{
- if (h->got.refcount > 0)
- h->got.refcount -= 1;
+ if (eh->got.refcount > 0)
+ eh->got.refcount -= 1;
}
else if (local_got_refcounts != NULL)
{
@@ -1570,20 +1593,20 @@ elf32_hppa_gc_sweep_hook (bfd *abfd,
case R_PARISC_PCREL17C:
case R_PARISC_PCREL17F:
case R_PARISC_PCREL22F:
- if (h != NULL)
+ if (eh != NULL)
{
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
+ if (eh->plt.refcount > 0)
+ eh->plt.refcount -= 1;
}
break;
case R_PARISC_PLABEL14R:
case R_PARISC_PLABEL21L:
case R_PARISC_PLABEL32:
- if (h != NULL)
+ if (eh != NULL)
{
- if (h->plt.refcount > 0)
- h->plt.refcount -= 1;
+ if (eh->plt.refcount > 0)
+ eh->plt.refcount -= 1;
}
else if (local_plt_refcounts != NULL)
{
@@ -1666,24 +1689,24 @@ elf32_hppa_grok_psinfo (bfd *abfd, Elf_I
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);
}
}
- if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
+ if (! hppa_elf_hash_entry(eh)->plabel)
{
- h->needs_plt = 0;
- h->plt = elf_hash_table (info)->init_plt_refcount;
+ eh->needs_plt = 0;
+ eh->plt = elf_hash_table (info)->init_plt_refcount;
}
}
@@ -1695,21 +1718,21 @@ elf32_hppa_hide_symbol (struct bfd_link_
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;
+ asection *sec;
unsigned int power_of_two;
/* If this is a function, put it in the procedure linkage table. We
will fill in the contents of the procedure linkage table later. */
- 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
+ if (eh->plt.refcount <= 0
+ || (eh->def_regular
+ && eh->root.type != bfd_link_hash_defweak
+ && ! hppa_elf_hash_entry (eh)->plabel
&& (!info->shared || info->symbolic)))
{
/* The .plt entry is not needed when:
@@ -1720,27 +1743,27 @@ elf32_hppa_adjust_dynamic_symbol (struct
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;
}
return TRUE;
}
else
- h->plt.offset = (bfd_vma) -1;
+ eh->plt.offset = (bfd_vma) -1;
/* 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->u.weakdef != NULL)
{
- if (h->u.weakdef->root.type != bfd_link_hash_defined
- && h->u.weakdef->root.type != bfd_link_hash_defweak)
+ if (eh->u.weakdef->root.type != bfd_link_hash_defined
+ && eh->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;
+ eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
+ eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
if (ELIMINATE_COPY_RELOCS)
- h->non_got_ref = h->u.weakdef->non_got_ref;
+ eh->non_got_ref = eh->u.weakdef->non_got_ref;
return TRUE;
}
@@ -1756,27 +1779,27 @@ elf32_hppa_adjust_dynamic_symbol (struct
/* 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;
+ struct elf32_hppa_link_hash_entry *hh;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
- eh = (struct elf32_hppa_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ hh = hppa_elf_hash_entry (eh);
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
- s = p->sec->output_section;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
+ sec = hdh_p->sec->output_section;
+ if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
break;
}
/* 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)
+ if (hdh_p == NULL)
{
- h->non_got_ref = 0;
+ eh->non_got_ref = 0;
return TRUE;
}
}
@@ -1796,34 +1819,34 @@ elf32_hppa_adjust_dynamic_symbol (struct
/* 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_ALLOC) != 0)
{
htab->srelbss->size += sizeof (Elf32_External_Rela);
- h->needs_copy = 1;
+ eh->needs_copy = 1;
}
/* We need to figure out the alignment required for this symbol. I
have no idea how other ELF linkers handle this. */
- power_of_two = bfd_log2 (h->size);
+ power_of_two = bfd_log2 (eh->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))
+ sec = htab->sdynbss;
+ sec->size = BFD_ALIGN (sec->size, (bfd_size_type) (1 << power_of_two));
+ if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, sec))
{
- if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
+ if (! bfd_set_section_alignment (htab->elf.dynobj, sec, power_of_two))
return FALSE;
}
/* Define the symbol as being at this point in the section. */
- h->root.u.def.section = s;
- h->root.u.def.value = s->size;
+ eh->root.u.def.section = sec;
+ eh->root.u.def.value = sec->size;
/* Increment the section size to make room for the symbol. */
- s->size += h->size;
+ sec->size += eh->size;
return TRUE;
}
@@ -1832,60 +1855,63 @@ elf32_hppa_adjust_dynamic_symbol (struct
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;
+ if (eh->root.type == bfd_link_hash_warning)
+ eh = (struct elf_link_hash_entry *) eh->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)
+ && 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 (eh->dynindx == -1
+ && !eh->forced_local
+ && eh->type != STT_PARISC_MILLI)
{
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
+ if (! bfd_elf_link_record_dynamic_symbol (info, eh))
return FALSE;
}
- if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
+ if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, 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->splt;
+ eh->plt.offset = sec->size;
+ sec->size += PLT_ENTRY_SIZE;
}
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;
@@ -1895,64 +1921,66 @@ allocate_plt_static (struct elf_link_has
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 elf32_hppa_dyn_reloc_entry *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;
+ if (eh->root.type == bfd_link_hash_warning)
+ eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
info = inf;
htab = hppa_link_hash_table (info);
+ hh = hppa_elf_hash_entry (eh);
+
if (htab->elf.dynamic_sections_created
- && h->plt.offset != (bfd_vma) -1
- && !((struct elf32_hppa_link_hash_entry *) h)->plabel)
+ && 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->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->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 (eh->dynindx == -1
+ && !eh->forced_local
+ && eh->type != STT_PARISC_MILLI)
{
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
+ if (! bfd_elf_link_record_dynamic_symbol (info, eh))
return FALSE;
}
- s = htab->sgot;
- h->got.offset = s->size;
- s->size += GOT_ENTRY_SIZE;
+ sec = htab->sgot;
+ eh->got.offset = sec->size;
+ sec->size += GOT_ENTRY_SIZE;
if (htab->elf.dynamic_sections_created
&& (info->shared
- || (h->dynindx != -1
- && !h->forced_local)))
+ || (eh->dynindx != -1
+ && !eh->forced_local)))
{
htab->srelgot->size += sizeof (Elf32_External_Rela);
}
}
else
- h->got.offset = (bfd_vma) -1;
+ eh->got.offset = (bfd_vma) -1;
- 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
@@ -1963,68 +1991,69 @@ allocate_dynrelocs (struct elf_link_hash
if (info->shared)
{
#if RELATIVE_DYNRELOCS
- if (SYMBOL_CALLS_LOCAL (info, h))
+ if (SYMBOL_CALLS_LOCAL (info, eh))
{
- struct elf32_hppa_dyn_reloc_entry **pp;
+ struct elf32_hppa_dyn_reloc_entry **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->relative_count;
+ hdh_p->relative_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 (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT
+ && eh->root.type == bfd_link_hash_undefweak)
+ hh->dyn_relocs = NULL;
}
else
{
/* 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
+
+ if (!eh->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))))
+ && eh->def_dynamic
+ && !eh->def_regular)
+ || (htab->elf.dynamic_sections_created
+ && (eh->root.type == bfd_link_hash_undefweak
+ || eh->root.type == bfd_link_hash_undefined))))
{
/* 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 (eh->dynindx == -1
+ && !eh->forced_local
+ && eh->type != STT_PARISC_MILLI)
{
- if (! bfd_elf_link_record_dynamic_symbol (info, h))
+ if (! bfd_elf_link_record_dynamic_symbol (info, eh))
return FALSE;
}
/* If that succeeded, we know we'll be keeping all the
relocs. */
- if (h->dynindx != -1)
+ if (eh->dynindx != -1)
goto keep;
}
- eh->dyn_relocs = NULL;
+ hh->dyn_relocs = NULL;
return TRUE;
keep: ;
}
/* 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;
@@ -2038,16 +2067,16 @@ allocate_dynrelocs (struct elf_link_hash
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 (eh->root.type == bfd_link_hash_warning)
+ eh = (struct elf_link_hash_entry *) eh->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;
}
@@ -2055,20 +2084,20 @@ clobber_millicode_symbols (struct elf_li
/* Find any dynamic relocs that apply to read-only sections. */
static bfd_boolean
-readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
+readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
{
- struct elf32_hppa_link_hash_entry *eh;
- struct elf32_hppa_dyn_reloc_entry *p;
+ struct elf32_hppa_link_hash_entry *hh;
+ struct elf32_hppa_dyn_reloc_entry *hdh_p;
- 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_warning)
+ eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
- eh = (struct elf32_hppa_link_hash_entry *) h;
- for (p = eh->dyn_relocs; p != NULL; p = p->next)
+ hh = hppa_elf_hash_entry (eh);
+ for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
{
- asection *s = p->sec->output_section;
+ asection *sec = hdh_p->sec->output_section;
- if (s != NULL && (s->flags & SEC_READONLY) != 0)
+ if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
{
struct bfd_link_info *info = inf;
@@ -2090,7 +2119,7 @@ elf32_hppa_size_dynamic_sections (bfd *o
struct elf32_hppa_link_hash_table *htab;
bfd *dynobj;
bfd *ibfd;
- asection *s;
+ asection *sec;
bfd_boolean relocs;
htab = hppa_link_hash_table (info);
@@ -2103,11 +2132,11 @@ elf32_hppa_size_dynamic_sections (bfd *o
/* Set the contents of the .interp section to the interpreter. */
if (info->executable)
{
- s = bfd_get_section_by_name (dynobj, ".interp");
- if (s == NULL)
+ sec = bfd_get_section_by_name (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. */
@@ -2131,28 +2160,28 @@ elf32_hppa_size_dynamic_sections (bfd *o
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 elf32_hppa_dyn_reloc_entry *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 elf32_hppa_dyn_reloc_entry *)
+ 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;
}
}
@@ -2165,15 +2194,15 @@ elf32_hppa_size_dynamic_sections (bfd *o
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
locsymcount = symtab_hdr->sh_info;
end_local_got = local_got + locsymcount;
- s = htab->sgot;
+ sec = htab->sgot;
srel = htab->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)
+ *local_got = sec->size;
+ sec->size += GOT_ENTRY_SIZE;
+ if (info->shared)
srel->size += sizeof (Elf32_External_Rela);
}
else
@@ -2190,14 +2219,14 @@ elf32_hppa_size_dynamic_sections (bfd *o
}
else
{
- s = htab->splt;
+ sec = htab->splt;
srel = htab->srelplt;
for (; local_plt < end_local_plt; ++local_plt)
{
if (*local_plt > 0)
{
- *local_plt = s->size;
- s->size += PLT_ENTRY_SIZE;
+ *local_plt = sec->size;
+ sec->size += PLT_ENTRY_SIZE;
if (info->shared)
srel->size += sizeof (Elf32_External_Rela);
}
@@ -2220,12 +2249,12 @@ elf32_hppa_size_dynamic_sections (bfd *o
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->splt)
{
if (htab->need_plt_stub)
{
@@ -2233,29 +2262,29 @@ elf32_hppa_size_dynamic_sections (bfd *o
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 pltalign = bfd_section_alignment (dynobj, sec);
bfd_size_type mask;
if (gotalign > pltalign)
- bfd_set_section_alignment (dynobj, s, gotalign);
+ bfd_set_section_alignment (dynobj, sec, gotalign);
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->sgot)
;
- else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
+ else if (strncmp (bfd_get_section_name (dynobj, sec), ".rela", 5) == 0)
{
- 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->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
@@ -2264,7 +2293,7 @@ elf32_hppa_size_dynamic_sections (bfd *o
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
@@ -2275,14 +2304,14 @@ elf32_hppa_size_dynamic_sections (bfd *o
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;
}
/* 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 && sec->size != 0)
return FALSE;
}
@@ -2572,61 +2601,60 @@ get_local_syms (bfd *output_bfd, bfd *in
if (info->shared && 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->elf.root.type == bfd_link_hash_indirect
+ || hh->elf.root.type == bfd_link_hash_warning)
+ hh = hppa_elf_hash_entry (hh->elf.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->elf.root.type == bfd_link_hash_defined
+ || hh->elf.root.type == bfd_link_hash_defweak)
+ && hh->elf.type == STT_FUNC
+ && hh->elf.root.u.def.section->output_section != NULL
+ && (hh->elf.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->elf.root.u.def.section->owner == input_bfd
+ && hh->elf.def_regular
+ && !hh->elf.forced_local
+ && ELF_ST_VISIBILITY (hh->elf.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->elf.root.u.def.section;
+ stub_name = hh->elf.root.root.string;
+ hsh = hppa_stub_hash_lookup (&htab->stub_hash_table,
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->elf.root.u.def.value;
+ hsh->target_section = hh->elf.root.u.def.section;
+ hsh->stub_type = hppa_stub_export;
+ hsh->h = hh;
stub_changed = 1;
}
else
@@ -2764,11 +2792,11 @@ elf32_hppa_size_stubs
{
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;
@@ -2795,7 +2823,7 @@ elf32_hppa_size_stubs
sym_sec = NULL;
sym_value = 0;
destination = 0;
- hash = NULL;
+ hh = NULL;
if (r_indx < symtab_hdr->sh_info)
{
/* It's a local symbol. */
@@ -2817,35 +2845,33 @@ elf32_hppa_size_stubs
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->elf.root.type == bfd_link_hash_indirect
+ || hh->elf.root.type == bfd_link_hash_warning)
+ hh = hppa_elf_hash_entry (hh->elf.root.u.i.link);
- if (hash->elf.root.type == bfd_link_hash_defined
- || hash->elf.root.type == bfd_link_hash_defweak)
+ if (hh->elf.root.type == bfd_link_hash_defined
+ || hh->elf.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->elf.root.u.def.section;
+ sym_value = hh->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)
+ else if (hh->elf.root.type == bfd_link_hash_undefweak)
{
if (! info->shared)
continue;
}
- else if (hash->elf.root.type == bfd_link_hash_undefined)
+ else if (hh->elf.root.type == bfd_link_hash_undefined)
{
if (! (info->unresolved_syms_in_objects == RM_IGNORE
- && (ELF_ST_VISIBILITY (hash->elf.other)
+ && (ELF_ST_VISIBILITY (hh->elf.other)
== STV_DEFAULT)
- && hash->elf.type != STT_PARISC_MILLI))
+ && hh->elf.type != STT_PARISC_MILLI))
continue;
}
else
@@ -2856,7 +2882,7 @@ elf32_hppa_size_stubs
}
/* 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;
@@ -2865,38 +2891,38 @@ elf32_hppa_size_stubs
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->stub_hash_table,
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;
+ hsh->target_value = sym_value;
+ hsh->target_section = sym_sec;
+ hsh->stub_type = stub_type;
if (info->shared)
{
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->h = hh;
stub_changed = TRUE;
}
@@ -3072,7 +3098,7 @@ hppa_record_segment_addr (bfd *abfd ATTR
{
struct elf32_hppa_link_hash_table *htab;
- htab = (struct elf32_hppa_link_hash_table *) data;
+ htab = (struct elf32_hppa_link_hash_table*) data;
if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
{
@@ -3096,27 +3122,27 @@ hppa_record_segment_addr (bfd *abfd ATTR
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;
- int val;
+ struct elf32_hppa_stub_hash_entry *hsh = NULL;
+ int val;
if (r_type == R_PARISC_NONE)
return bfd_reloc_ok;
@@ -3157,25 +3183,25 @@ final_link_relocate (asection *input_sec
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
+ || (hh != NULL
+ && hh->elf.plt.offset != (bfd_vma) -1
+ && hh->elf.dynindx != -1
+ && !hh->plabel
&& (info->shared
- || !h->elf.def_regular
- || h->elf.root.type == bfd_link_hash_defweak)))
+ || !hh->elf.def_regular
+ || hh->elf.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->elf.root.type == bfd_link_hash_undefweak)
{
/* It's OK if undefined weak. Calls to undefined weak
symbols behave as if the "called" function
@@ -3225,7 +3251,7 @@ final_link_relocate (asection *input_sec
(_("%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,
+ offset,
howto->name,
insn);
}
@@ -3342,16 +3368,16 @@ final_link_relocate (asection *input_sec
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;
}
@@ -3370,8 +3396,8 @@ final_link_relocate (asection *input_sec
(_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
input_bfd,
input_section,
- (long) rel->r_offset,
- stub_entry->root.string);
+ offset,
+ hsh->root.string);
bfd_set_error (bfd_error_bad_value);
return bfd_reloc_notsupported;
}
@@ -3420,7 +3446,7 @@ elf32_hppa_relocate_section (bfd *output
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)
@@ -3431,23 +3457,23 @@ elf32_hppa_relocate_section (bfd *output
htab = hppa_link_hash_table (info);
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);
@@ -3458,8 +3484,8 @@ elf32_hppa_relocate_section (bfd *output
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;
@@ -3468,36 +3494,36 @@ elf32_hppa_relocate_section (bfd *output
/* 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;
+ struct elf_link_hash_entry *eh;
bfd_boolean unresolved_reloc;
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,
+ eh, 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->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))
+ (info, eh->root.root.string, input_bfd,
+ input_section, rela->r_offset, FALSE))
return FALSE;
warned_undef = TRUE;
}
}
- h = (struct elf32_hppa_link_hash_entry *) hh;
+ hh = hppa_elf_hash_entry (eh);
}
/* Do any required modifications to the relocation value, and
@@ -3515,14 +3541,14 @@ elf32_hppa_relocate_section (bfd *output
/* 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;
+ off = hh->elf.got.offset;
dyn = htab->elf.dynamic_sections_created;
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
- &h->elf))
+ &hh->elf))
{
/* If we aren't going to call finish_dynamic_symbol,
then we need to handle initialisation of the .got
@@ -3534,7 +3560,7 @@ elf32_hppa_relocate_section (bfd *output
off &= ~1;
else
{
- h->elf.got.offset |= 1;
+ hh->elf.got.offset |= 1;
do_got = 1;
}
}
@@ -3568,15 +3594,15 @@ elf32_hppa_relocate_section (bfd *output
object because the symbol index is zero. */
Elf_Internal_Rela outrel;
bfd_byte *loc;
- asection *s = htab->srelgot;
+ asection *sec = 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);
+ loc = sec->contents;
+ loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
}
else
@@ -3608,14 +3634,13 @@ elf32_hppa_relocate_section (bfd *output
{
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;
+ off = hh->elf.plt.offset;
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared,
- &h->elf))
+ &hh->elf))
{
/* In a non-shared link, adjust_dynamic_symbols
isn't called for symbols forced local. We
@@ -3624,7 +3649,7 @@ elf32_hppa_relocate_section (bfd *output
off &= ~1;
else
{
- h->elf.plt.offset |= 1;
+ hh->elf.plt.offset |= 1;
do_plt = 1;
}
}
@@ -3690,9 +3715,9 @@ elf32_hppa_relocate_section (bfd *output
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->elf.root.type != bfd_link_hash_undefweak
+ && hh->elf.root.type != bfd_link_hash_undefined))
{
relocation = (off
+ htab->splt->output_offset
@@ -3732,20 +3757,20 @@ elf32_hppa_relocate_section (bfd *output
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)
+ && (hh == NULL
+ || ELF_ST_VISIBILITY (hh->elf.other) == STV_DEFAULT
+ || hh->elf.root.type != bfd_link_hash_undefweak)
&& (IS_ABSOLUTE_RELOC (r_type)
- || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
+ || !SYMBOL_CALLS_LOCAL (info, &hh->elf)))
|| (!info->shared
- && h != NULL
- && h->elf.dynindx != -1
- && !h->elf.non_got_ref
+ && hh != NULL
+ && hh->elf.dynindx != -1
+ && !hh->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)))
+ && hh->elf.def_dynamic
+ && !hh->elf.def_regular)
+ || hh->elf.root.type == bfd_link_hash_undefweak
+ || hh->elf.root.type == bfd_link_hash_undefined)))
{
Elf_Internal_Rela outrel;
bfd_boolean skip;
@@ -3756,28 +3781,28 @@ elf32_hppa_relocate_section (bfd *output
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
+ input_section->output_section->vma);
-
+
if (skip)
{
memset (&outrel, 0, sizeof (outrel));
}
- else if (h != NULL
- && h->elf.dynindx != -1
+ else if (hh != NULL
+ && hh->elf.dynindx != -1
&& (plabel
|| !IS_ABSOLUTE_RELOC (r_type)
|| !info->shared
|| !info->symbolic
- || !h->elf.def_regular))
+ || !hh->elf.def_regular))
{
- outrel.r_info = ELF32_R_INFO (h->elf.dynindx, r_type);
+ outrel.r_info = ELF32_R_INFO (hh->elf.dynindx, r_type);
}
else /* It's a local symbol, or one marked to become local. */
{
@@ -3826,14 +3851,14 @@ elf32_hppa_relocate_section (bfd *output
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->elf.root.root.string;
else
{
sym_name = bfd_elf_string_from_elf_section (input_bfd,
@@ -3847,15 +3872,15 @@ elf32_hppa_relocate_section (bfd *output
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"),
input_bfd,
input_section,
- (long) rel->r_offset,
+ (long) rela->r_offset,
howto->name,
sym_name);
bfd_set_error (bfd_error_bad_value);
@@ -3865,8 +3890,8 @@ elf32_hppa_relocate_section (bfd *output
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)))
+ (info, (hh ? &hh->elf.root : NULL), sym_name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rela->r_offset)))
return FALSE;
}
}
@@ -3880,20 +3905,20 @@ elf32_hppa_relocate_section (bfd *output
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 (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
@@ -3904,37 +3929,37 @@ elf32_hppa_finish_dynamic_symbol (bfd *o
<__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
+ rela.r_offset = (eh->plt.offset
+ htab->splt->output_offset
+ htab->splt->output_section->vma);
- if (h->dynindx != -1)
+ 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);
+ bfd_elf32_swap_reloca_out (htab->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. */
@@ -3942,12 +3967,12 @@ elf32_hppa_finish_dynamic_symbol (bfd *o
}
}
- if (h->got.offset != (bfd_vma) -1)
+ if (eh->got.offset != (bfd_vma) -1)
{
/* This symbol has an entry in the global offset table. Set it
up. */
- rel.r_offset = ((h->got.offset &~ (bfd_vma) 1)
+ rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
+ htab->sgot->output_offset
+ htab->sgot->output_section->vma);
@@ -3957,54 +3982,55 @@ elf32_hppa_finish_dynamic_symbol (bfd *o
global offset table will already have been initialized in the
relocate_section function. */
if (info->shared
- && (info->symbolic || h->dynindx == -1)
- && h->def_regular)
+ && (info->symbolic || eh->dynindx == -1)
+ && eh->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);
+ 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 ((h->got.offset & 1) != 0)
+ if ((eh->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;
+
+ bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1));
+ rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
+ rela.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);
+ 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;
+ sec = 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);
+ 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->root.root.string[0] == '_'
+ && (strcmp (eh->root.root.string, "_DYNAMIC") == 0
+ || strcmp (eh->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0))
{
sym->st_shndx = SHN_ABS;
}