diff options
| -rw-r--r-- | bfd/ChangeLog | 32 | ||||
| -rw-r--r-- | bfd/elf32-hppa.c | 1253 |
2 files changed, 673 insertions, 612 deletions
diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 3ce3aef..ab57ca3 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,35 @@ +2005-06-21 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. + 2005-06-20 H.J. Lu <hongjiu.lu@intel.com> PR 1025 diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c index cdae72a..6ec8ec5 100644 --- a/bfd/elf32-hppa.c +++ b/bfd/elf32-hppa.c @@ -113,6 +113,27 @@ : 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" + + Always remember to use GNU Coding Style. */ + #define PLT_ENTRY_SIZE 8 #define GOT_ENTRY_SIZE 4 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" @@ -277,6 +298,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 +331,17 @@ stub_hash_newfunc (struct bfd_hash_entry *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 +368,13 @@ hppa_link_hash_newfunc (struct bfd_hash_entry *entry, entry = _bfd_elf_link_hash_newfunc (entry, table, string); if (entry != NULL) { - struct elf32_hppa_link_hash_entry *eh; + struct elf32_hppa_link_hash_entry *hh; /* Initialize the local fields. */ - eh = (struct elf32_hppa_link_hash_entry *) entry; - eh->stub_cache = NULL; - eh->dyn_relocs = NULL; - eh->plabel = 0; + hh = hppa_elf_hash_entry (entry); + hh->stub_cache = NULL; + hh->dyn_relocs = NULL; + hh->plabel = 0; } return entry; @@ -360,55 +387,55 @@ hppa_link_hash_newfunc (struct bfd_hash_entry *entry, 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; - - return &ret->elf.root; + 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 &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 +443,22 @@ elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *hash) 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 +470,8 @@ hppa_stub_name (const asection *input_section, 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 +483,8 @@ hppa_stub_name (const asection *input_section, 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 +497,24 @@ hppa_get_stub_entry (const asection *input_section, 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 +532,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 +562,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 +572,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 +592,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 +608,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 +677,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 +692,28 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +728,12 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +750,7 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +762,7 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +805,12 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +820,10 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) { (*_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 +842,8 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +882,21 @@ hppa_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 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 +906,7 @@ hppa_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) size = 16; } - stub_entry->stub_sec->size += size; + hsh->stub_sec->size += size; return TRUE; } @@ -937,7 +964,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 +995,74 @@ elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) /* 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 +1077,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 +1089,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 +1104,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 +1134,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 +1142,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 +1171,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 +1188,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 +1231,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 +1259,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 +1299,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 +1341,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 +1375,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 +1435,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 +1445,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 +1488,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 +1531,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; - - for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) - if (p->sec == sec) + 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 (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 +1596,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 +1692,24 @@ elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 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 +1721,21 @@ elf32_hppa_hide_symbol (struct bfd_link_info *info, 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 +1746,27 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, 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 +1782,27 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, /* 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 +1822,34 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, /* We must generate a COPY reloc to tell the dynamic linker to copy the initial value out of the dynamic object and into the runtime process image. */ - if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) + if ((eh->root.u.def.section->flags & SEC_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 +1858,63 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info, 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 +1924,66 @@ allocate_plt_static (struct elf_link_hash_entry *h, void *inf) 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 +1994,69 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 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 +2070,16 @@ allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 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 +2087,20 @@ clobber_millicode_symbols (struct elf_link_hash_entry *h, /* 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 +2122,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2135,11 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, /* 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 +2163,28 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2197,15 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2222,14 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, } 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 +2252,12 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2265,29 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2296,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2307,14 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 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 +2604,60 @@ get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info) 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 +2795,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 +2826,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 +2848,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 +2885,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 +2894,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 +3101,7 @@ hppa_record_segment_addr (bfd *abfd ATTRIBUTE_UNUSED, { 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 +3125,27 @@ hppa_record_segment_addr (bfd *abfd ATTRIBUTE_UNUSED, 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 +3186,25 @@ final_link_relocate (asection *input_section, 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 +3254,7 @@ final_link_relocate (asection *input_section, (_("%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 +3371,16 @@ final_link_relocate (asection *input_section, 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 +3399,8 @@ final_link_relocate (asection *input_section, (_("%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 +3449,7 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3460,23 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3487,8 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3497,36 @@ elf32_hppa_relocate_section (bfd *output_bfd, /* 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 +3544,14 @@ elf32_hppa_relocate_section (bfd *output_bfd, /* 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 +3563,7 @@ elf32_hppa_relocate_section (bfd *output_bfd, off &= ~1; else { - h->elf.got.offset |= 1; + hh->elf.got.offset |= 1; do_got = 1; } } @@ -3568,15 +3597,15 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3637,13 @@ elf32_hppa_relocate_section (bfd *output_bfd, { 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 +3652,7 @@ elf32_hppa_relocate_section (bfd *output_bfd, off &= ~1; else { - h->elf.plt.offset |= 1; + hh->elf.plt.offset |= 1; do_plt = 1; } } @@ -3690,9 +3718,9 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3760,20 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3784,28 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3854,14 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3875,15 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3893,8 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3908,20 @@ elf32_hppa_relocate_section (bfd *output_bfd, 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 +3932,37 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd, <__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 +3970,12 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd, } } - 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 +3985,55 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd, 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; } |