espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-25 21:41:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

2000-12-08 Kazu Hirata <kazu@hxi.com>

Browse Source 
* elf64-alpha.c: Fix formatting.
	* elf64-hppa.c: Likewise.
	* elf64-mips.c: Likewise.
This commit is contained in:
Kazu Hirata
2000-12-09 01:54:51 +00:00
parent 40293bdaea
commit fe8bc63d5e
4 changed files with 73 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
bfd/ChangeLog
View File

@ -29,6 +29,7 @@
2000-12-08 Kazu Hirata <kazu@hxi.com> 2000-12-08 Kazu Hirata <kazu@hxi.com>
* coffgen.c: Fix formatting. * coffgen.c: Fix formatting.
* elf-m10300.c: Likewise.
* elf32-i386.c: Likewise. * elf32-i386.c: Likewise.
* elf32-i960.c: Likewise. * elf32-i960.c: Likewise.
* elf32-m68k.c: Likewise. * elf32-m68k.c: Likewise.
@ -37,8 +38,10 @@
* elf32-sh.c: Likewise. * elf32-sh.c: Likewise.
* elf32-sparc.c: Likewise. * elf32-sparc.c: Likewise.
* elf32-v850.c: Likewise. * elf32-v850.c: Likewise.
* elf64-alpha.c: Likewise.
* elf64-hppa.c: Likewise.
* elf64-mips.c: Likewise.
* elf64-sparc.c: Likewise. * elf64-sparc.c: Likewise.
* elf-m10300.c: Likewise.
2000-12-07 Kazu Hirata <kazu@hxi.com> 2000-12-07 Kazu Hirata <kazu@hxi.com>

69
bfd/elf64-alpha.c
View File

@ -34,7 +34,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#define NO_COFF_SYMBOLS #define NO_COFF_SYMBOLS
#define NO_COFF_LINENOS #define NO_COFF_LINENOS
/* Get the ECOFF swapping routines. Needed for the debug information. */ /* Get the ECOFF swapping routines. Needed for the debug information. */
#include "coff/internal.h" #include "coff/internal.h"
#include "coff/sym.h" #include "coff/sym.h"
#include "coff/symconst.h" #include "coff/symconst.h"
@ -711,7 +711,7 @@ static reloc_howto_type elf64_alpha_howto_table[] =
false), /* pcrel_offset */ false), /* pcrel_offset */
/* The high bits of a 32-bit displacement to the starting address of the /* The high bits of a 32-bit displacement to the starting address of the
current section (the relocation target is ignored); the low bits are current section (the relocation target is ignored); the low bits are
supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */ supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
/* XXX: Not implemented. */ /* XXX: Not implemented. */
HOWTO (R_ALPHA_IMMED_SCN_HI32, HOWTO (R_ALPHA_IMMED_SCN_HI32,
@ -762,7 +762,7 @@ static reloc_howto_type elf64_alpha_howto_table[] =
0, /* dst_mask */ 0, /* dst_mask */
false), /* pcrel_offset */ false), /* pcrel_offset */
/* Misc ELF relocations. */ /* Misc ELF relocations. */
/* A dynamic relocation to copy the target into our .dynbss section. */ /* A dynamic relocation to copy the target into our .dynbss section. */
/* Not generated, as all Alpha objects use PIC, so it is not needed. It /* Not generated, as all Alpha objects use PIC, so it is not needed. It
@ -979,7 +979,7 @@ static const struct elf_reloc_map elf64_alpha_reloc_map[] =
/* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
the explicit !<reloc>!sequence relocations, and are mapped into the normal the explicit !<reloc>!sequence relocations, and are mapped into the normal
relocations at the end of processing. */ relocations at the end of processing. */
{BFD_RELOC_ALPHA_USER_LITERAL, R_ALPHA_LITERAL}, {BFD_RELOC_ALPHA_USER_LITERAL, R_ALPHA_LITERAL},
{BFD_RELOC_ALPHA_USER_LITUSE_BASE, R_ALPHA_LITUSE}, {BFD_RELOC_ALPHA_USER_LITUSE_BASE, R_ALPHA_LITUSE},
{BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, R_ALPHA_LITUSE}, {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, R_ALPHA_LITUSE},
@ -1022,7 +1022,7 @@ elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
cache_ptr->howto = &elf64_alpha_howto_table[r_type]; cache_ptr->howto = &elf64_alpha_howto_table[r_type];
} }
/* These functions do relaxation for Alpha ELF. /* These functions do relaxation for Alpha ELF.
Currently I'm only handling what I can do with existing compiler Currently I'm only handling what I can do with existing compiler
and assembler support, which means no instructions are removed, and assembler support, which means no instructions are removed,
@ -1062,11 +1062,11 @@ struct alpha_relax_info
}; };
static Elf_Internal_Rela * elf64_alpha_relax_with_lituse static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
PARAMS((struct alpha_relax_info *info, bfd_vma symval, PARAMS((struct alpha_relax_info *info, bfd_vma symval,
Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend)); Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
static boolean elf64_alpha_relax_without_lituse static boolean elf64_alpha_relax_without_lituse
PARAMS((struct alpha_relax_info *info, bfd_vma symval, PARAMS((struct alpha_relax_info *info, bfd_vma symval,
Elf_Internal_Rela *irel)); Elf_Internal_Rela *irel));
static bfd_vma elf64_alpha_relax_opt_call static bfd_vma elf64_alpha_relax_opt_call
@ -1125,7 +1125,7 @@ elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
flags |= 1 << urel->r_addend; flags |= 1 << urel->r_addend;
} }
/* A little preparation for the loop... */ /* A little preparation for the loop... */
disp = symval - info->gp; disp = symval - info->gp;
for (urel = irel+1, i = 0; i < count; ++i, ++urel) for (urel = irel+1, i = 0; i < count; ++i, ++urel)
@ -1161,7 +1161,7 @@ elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
if (fits16) if (fits16)
{ {
/* Take the op code and dest from this insn, take the base /* Take the op code and dest from this insn, take the base
register from the literal insn. Leave the offset alone. */ register from the literal insn. Leave the offset alone. */
insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000); insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
R_ALPHA_GPRELLOW); R_ALPHA_GPRELLOW);
@ -1224,12 +1224,12 @@ elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
{ {
Elf_Internal_Rela *xrel; Elf_Internal_Rela *xrel;
/* Preserve branch prediction call stack when possible. */ /* Preserve branch prediction call stack when possible. */
if ((insn & INSN_JSR_MASK) == INSN_JSR) if ((insn & INSN_JSR_MASK) == INSN_JSR)
insn = (OP_BSR << 26) | (insn & 0x03e00000); insn = (OP_BSR << 26) | (insn & 0x03e00000);
else else
insn = (OP_BR << 26) | (insn & 0x03e00000); insn = (OP_BR << 26) | (insn & 0x03e00000);
urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
R_ALPHA_BRADDR); R_ALPHA_BRADDR);
urel->r_addend = irel->r_addend; urel->r_addend = irel->r_addend;
@ -1243,7 +1243,7 @@ elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
/* Kill any HINT reloc that might exist for this insn. */ /* Kill any HINT reloc that might exist for this insn. */
xrel = (elf64_alpha_find_reloc_at_ofs xrel = (elf64_alpha_find_reloc_at_ofs
(info->relocs, info->relend, urel->r_offset, (info->relocs, info->relend, urel->r_offset,
R_ALPHA_HINT)); R_ALPHA_HINT));
if (xrel) if (xrel)
xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE); xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
@ -1258,7 +1258,7 @@ elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
This does depend on every place a gp could be reloaded will This does depend on every place a gp could be reloaded will
be, which currently happens for all code produced by gcc, but be, which currently happens for all code produced by gcc, but
not necessarily by hand-coded assembly, or if sibling calls not necessarily by hand-coded assembly, or if sibling calls
are enabled in gcc. are enabled in gcc.
Perhaps conditionalize this on a flag being set in the target Perhaps conditionalize this on a flag being set in the target
object file's header, and have gcc set it? */ object file's header, and have gcc set it? */
@ -1308,18 +1308,18 @@ elf64_alpha_relax_opt_call (info, symval)
return symval; return symval;
/* If the symbol is marked STD_GP, we are being told the function does /* If the symbol is marked STD_GP, we are being told the function does
a normal ldgp in the first two words. */ a normal ldgp in the first two words. */
else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD) else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
; ;
/* Otherwise, we may be able to identify a GP load in the first two /* Otherwise, we may be able to identify a GP load in the first two
words, which we can then skip. */ words, which we can then skip. */
else else
{ {
Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp; Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
bfd_vma ofs; bfd_vma ofs;
/* Load the relocations from the section that the target symbol is in. */ /* Load the relocations from the section that the target symbol is in. */
if (info->sec == info->tsec) if (info->sec == info->tsec)
{ {
tsec_relocs = info->relocs; tsec_relocs = info->relocs;
@ -1341,7 +1341,7 @@ elf64_alpha_relax_opt_call (info, symval)
/* Recover the symbol's offset within the section. */ /* Recover the symbol's offset within the section. */
ofs = (symval - info->tsec->output_section->vma ofs = (symval - info->tsec->output_section->vma
- info->tsec->output_offset); - info->tsec->output_offset);
/* Look for a GPDISP reloc. */ /* Look for a GPDISP reloc. */
gpdisp = (elf64_alpha_find_reloc_at_ofs gpdisp = (elf64_alpha_find_reloc_at_ofs
(tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP)); (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
@ -1356,7 +1356,7 @@ elf64_alpha_relax_opt_call (info, symval)
free (tsec_free); free (tsec_free);
} }
/* We've now determined that we can skip an initial gp load. Verify /* We've now determined that we can skip an initial gp load. Verify
that the call and the target use the same gp. */ that the call and the target use the same gp. */
if (info->link_info->hash->creator != info->tsec->owner->xvec if (info->link_info->hash->creator != info->tsec->owner->xvec
|| info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj) || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
@ -1417,7 +1417,7 @@ elf64_alpha_relax_without_lituse (info, symval, irel)
Any such memory load insn may be substituted by a load directly Any such memory load insn may be substituted by a load directly
off the GP. This allows the memory load insn to be issued before off the GP. This allows the memory load insn to be issued before
the calculated GP register would otherwise be ready. the calculated GP register would otherwise be ready.
Any such jsr insn can be replaced by a bsr if it is in range. Any such jsr insn can be replaced by a bsr if it is in range.
@ -1469,7 +1469,7 @@ elf64_alpha_relax_section (abfd, sec, link_info, again)
if (! link_info->keep_memory) if (! link_info->keep_memory)
free_relocs = internal_relocs; free_relocs = internal_relocs;
memset(&info, 0, sizeof(info)); memset(&info, 0, sizeof (info));
info.abfd = abfd; info.abfd = abfd;
info.sec = sec; info.sec = sec;
info.link_info = link_info; info.link_info = link_info;
@ -1552,8 +1552,8 @@ elf64_alpha_relax_section (abfd, sec, link_info, again)
info.tsec = bfd_abs_section_ptr; info.tsec = bfd_abs_section_ptr;
else if (isym.st_shndx == SHN_COMMON) else if (isym.st_shndx == SHN_COMMON)
info.tsec = bfd_com_section_ptr; info.tsec = bfd_com_section_ptr;
else else
continue; /* who knows. */ continue; /* who knows. */
info.h = NULL; info.h = NULL;
info.other = isym.st_other; info.other = isym.st_other;
@ -1971,7 +1971,7 @@ elf64_alpha_read_ecoff_info (abfd, section, debug)
char *ext_hdr = NULL; char *ext_hdr = NULL;
swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap; swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
memset (debug, 0, sizeof(*debug)); memset (debug, 0, sizeof (*debug));
ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size); ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
if (ext_hdr == NULL && swap->external_hdr_size != 0) if (ext_hdr == NULL && swap->external_hdr_size != 0)
@ -2565,7 +2565,7 @@ elf64_alpha_check_relocs (abfd, info, sec, relocs)
don't know whether we'll actually need a dynamic relocation don't know whether we'll actually need a dynamic relocation
entry for this reloc. So make a record of it. Once we entry for this reloc. So make a record of it. Once we
find out if this thing needs dynamic relocation we'll find out if this thing needs dynamic relocation we'll
expand the relocation sections by the appropriate amount. */ expand the relocation sections by the appropriate amount. */
struct alpha_elf_reloc_entry *rent; struct alpha_elf_reloc_entry *rent;
@ -3137,7 +3137,7 @@ elf64_alpha_calc_dynrel_sizes (h, info)
|| relent->rtype == R_ALPHA_REFQUAD) || relent->rtype == R_ALPHA_REFQUAD)
{ {
relent->srel->_raw_size += relent->srel->_raw_size +=
sizeof(Elf64_External_Rela) * relent->count; sizeof (Elf64_External_Rela) * relent->count;
} }
dynobj = elf_hash_table(info)->dynobj; dynobj = elf_hash_table(info)->dynobj;
@ -3212,7 +3212,7 @@ elf64_alpha_size_dynamic_sections (output_bfd, info)
i = alpha_elf_tdata(i)->got_link_next) i = alpha_elf_tdata(i)->got_link_next)
count += alpha_elf_tdata(i)->n_local_got_entries; count += alpha_elf_tdata(i)->n_local_got_entries;
srel->_raw_size += count * sizeof(Elf64_External_Rela); srel->_raw_size += count * sizeof (Elf64_External_Rela);
} }
} }
/* else we're not dynamic and by definition we don't need such things. */ /* else we're not dynamic and by definition we don't need such things. */
@ -3315,7 +3315,7 @@ elf64_alpha_size_dynamic_sections (output_bfd, info)
if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0) if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
|| ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0) || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
|| ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT, || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
sizeof(Elf64_External_Rela))) sizeof (Elf64_External_Rela)))
return false; return false;
if (reltext) if (reltext)
@ -3405,7 +3405,7 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
in which case we have to adjust according to where the in which case we have to adjust according to where the
section symbol winds up in the output section. */ section symbol winds up in the output section. */
/* The symbol associated with GPDISP and LITUSE is /* The symbol associated with GPDISP and LITUSE is
immaterial. Only the addend is significant. */ immaterial. Only the addend is significant. */
if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE) if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
continue; continue;
@ -3528,7 +3528,7 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
case R_ALPHA_OP_PSUB: case R_ALPHA_OP_PSUB:
case R_ALPHA_OP_PRSHIFT: case R_ALPHA_OP_PRSHIFT:
/* We hate these silly beasts. */ /* We hate these silly beasts. */
abort(); abort ();
case R_ALPHA_LITERAL: case R_ALPHA_LITERAL:
{ {
@ -3582,7 +3582,7 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
((Elf64_External_Rela *) ((Elf64_External_Rela *)
srelgot->contents) srelgot->contents)
+ srelgot->reloc_count++); + srelgot->reloc_count++);
BFD_ASSERT (sizeof(Elf64_External_Rela) BFD_ASSERT (sizeof (Elf64_External_Rela)
* srelgot->reloc_count * srelgot->reloc_count
<= srelgot->_cooked_size); <= srelgot->_cooked_size);
} }
@ -3687,7 +3687,7 @@ elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
((Elf64_External_Rela *) ((Elf64_External_Rela *)
srel->contents) srel->contents)
+ srel->reloc_count++); + srel->reloc_count++);
BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
<= srel->_cooked_size); <= srel->_cooked_size);
} }
goto default_reloc; goto default_reloc;
@ -3840,7 +3840,7 @@ elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
((Elf64_External_Rela *) ((Elf64_External_Rela *)
srel->contents) srel->contents)
+ srel->reloc_count++); + srel->reloc_count++);
BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
<= srel->_cooked_size); <= srel->_cooked_size);
} }
@ -3873,7 +3873,7 @@ elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
bfd_elf64_swap_reloca_out (output_bfd, &outrel, bfd_elf64_swap_reloca_out (output_bfd, &outrel,
((Elf64_External_Rela *)srel->contents ((Elf64_External_Rela *)srel->contents
+ srel->reloc_count++)); + srel->reloc_count++));
BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
<= srel->_cooked_size); <= srel->_cooked_size);
} }
} }
@ -4291,7 +4291,6 @@ elf64_alpha_final_link (abfd, info)
} }
#endif #endif
/* Build the external symbol information. */ /* Build the external symbol information. */
einfo.abfd = abfd; einfo.abfd = abfd;
einfo.info = info; einfo.info = info;
@ -4611,7 +4610,7 @@ elf64_alpha_final_link (abfd, info)
/* ECOFF swapping routines. These are used when dealing with the /* ECOFF swapping routines. These are used when dealing with the
.mdebug section, which is in the ECOFF debugging format. Copied .mdebug section, which is in the ECOFF debugging format. Copied
from elf32-mips.c. */ from elf32-mips.c. */
static const struct ecoff_debug_swap static const struct ecoff_debug_swap
elf64_alpha_ecoff_debug_swap = elf64_alpha_ecoff_debug_swap =
{ {

63
bfd/elf64-hppa.c
View File

@ -30,7 +30,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#define PLT_ENTRY_SIZE 0x10 #define PLT_ENTRY_SIZE 0x10
#define DLT_ENTRY_SIZE 0x8 #define DLT_ENTRY_SIZE 0x8
#define OPD_ENTRY_SIZE 0x20 #define OPD_ENTRY_SIZE 0x20
#define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl" #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
/* The stub is supposed to load the target address and target's DP /* The stub is supposed to load the target address and target's DP
@ -169,19 +169,17 @@ static struct elf64_hppa_dyn_hash_entry *elf64_hppa_dyn_hash_lookup
boolean create, boolean copy)); boolean create, boolean copy));
static void elf64_hppa_dyn_hash_traverse static void elf64_hppa_dyn_hash_traverse
PARAMS ((struct elf64_hppa_dyn_hash_table *table, PARAMS ((struct elf64_hppa_dyn_hash_table *table,
boolean (*func)(struct elf64_hppa_dyn_hash_entry *, PTR), boolean (*func) (struct elf64_hppa_dyn_hash_entry *, PTR),
PTR info)); PTR info));
static const char *get_dyn_name static const char *get_dyn_name
PARAMS ((asection *, struct elf_link_hash_entry *, PARAMS ((asection *, struct elf_link_hash_entry *,
const Elf_Internal_Rela *, char **, size_t *)); const Elf_Internal_Rela *, char **, size_t *));
/* This must follow the definitions of the various derived linker /* This must follow the definitions of the various derived linker
hash tables and shared functions. */ hash tables and shared functions. */
#include "elf-hppa.h" #include "elf-hppa.h"
static boolean elf64_hppa_object_p static boolean elf64_hppa_object_p
PARAMS ((bfd *)); PARAMS ((bfd *));
@ -203,7 +201,7 @@ static boolean elf64_hppa_size_dynamic_sections
static boolean elf64_hppa_finish_dynamic_symbol static boolean elf64_hppa_finish_dynamic_symbol
PARAMS ((bfd *, struct bfd_link_info *, PARAMS ((bfd *, struct bfd_link_info *,
struct elf_link_hash_entry *, Elf_Internal_Sym *)); struct elf_link_hash_entry *, Elf_Internal_Sym *));
static boolean elf64_hppa_finish_dynamic_sections static boolean elf64_hppa_finish_dynamic_sections
PARAMS ((bfd *, struct bfd_link_info *)); PARAMS ((bfd *, struct bfd_link_info *));
@ -266,7 +264,7 @@ elf64_hppa_dyn_hash_table_init (ht, abfd, new)
bfd *abfd ATTRIBUTE_UNUSED; bfd *abfd ATTRIBUTE_UNUSED;
new_hash_entry_func new; new_hash_entry_func new;
{ {
memset (ht, 0, sizeof(*ht)); memset (ht, 0, sizeof (*ht));
return bfd_hash_table_init (&ht->root, new); return bfd_hash_table_init (&ht->root, new);
} }
@ -289,7 +287,7 @@ elf64_hppa_new_dyn_hash_entry (entry, table, string)
/* Initialize our local data. All zeros, and definitely easier /* Initialize our local data. All zeros, and definitely easier
than setting 8 bit fields. */ than setting 8 bit fields. */
memset (ret, 0, sizeof(*ret)); memset (ret, 0, sizeof (*ret));
/* Call the allocation method of the superclass. */ /* Call the allocation method of the superclass. */
ret = ((struct elf64_hppa_dyn_hash_entry *) ret = ((struct elf64_hppa_dyn_hash_entry *)
@ -394,9 +392,8 @@ elf64_hppa_section_from_shdr (abfd, hdr, name)
return true; return true;
} }
/* Construct a string for use in the elf64_hppa_dyn_hash_table. The /* Construct a string for use in the elf64_hppa_dyn_hash_table. The
name describes what was once potentially anonymous memory. We name describes what was once potentially anonymous memory. We
allocate memory as necessary, possibly reusing PBUF/PLEN. */ allocate memory as necessary, possibly reusing PBUF/PLEN. */
static const char * static const char *
@ -503,7 +500,7 @@ get_reloc_section (abfd, hppa_info, sec)
return true; return true;
} }
/* Add a new entry to the list of dynamic relocations against DYN_H. /* Add a new entry to the list of dynamic relocations against DYN_H.
We use this to keep a record of all the FPTR relocations against a We use this to keep a record of all the FPTR relocations against a
particular symbol so that we can create FPTR relocations in the particular symbol so that we can create FPTR relocations in the
@ -572,7 +569,7 @@ elf64_hppa_check_relocs (abfd, info, sec, relocs)
/* If necessary, build a new table holding section symbols indices /* If necessary, build a new table holding section symbols indices
for this BFD. This is disgusting. */ for this BFD. This is disgusting. */
if (info->shared && hppa_info->section_syms_bfd != abfd) if (info->shared && hppa_info->section_syms_bfd != abfd)
{ {
unsigned long i; unsigned long i;
@ -669,7 +666,7 @@ elf64_hppa_check_relocs (abfd, info, sec, relocs)
} }
else else
sec_symndx = 0; sec_symndx = 0;
dlt = plt = stubs = NULL; dlt = plt = stubs = NULL;
buf = NULL; buf = NULL;
buf_len = 0; buf_len = 0;
@ -869,7 +866,7 @@ elf64_hppa_check_relocs (abfd, info, sec, relocs)
/* FPTRs are not allocated by the dynamic linker for PA64, though /* FPTRs are not allocated by the dynamic linker for PA64, though
it is possible that will change in the future. */ it is possible that will change in the future. */
/* This could be a local function that had its address taken, in /* This could be a local function that had its address taken, in
which case H will be NULL. */ which case H will be NULL. */
if (h) if (h)
@ -1085,7 +1082,7 @@ allocate_global_data_opd (dyn_h, data)
if (dyn_h->want_opd) if (dyn_h->want_opd)
{ {
struct elf_link_hash_entry *h = dyn_h->h; struct elf_link_hash_entry *h = dyn_h->h;
if (h) if (h)
while (h->root.type == bfd_link_hash_indirect while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning) || h->root.type == bfd_link_hash_warning)
@ -1362,7 +1359,7 @@ get_stub (abfd, info, hppa_info)
Should contain dynamic IPLT (and EPLT?) relocations. Should contain dynamic IPLT (and EPLT?) relocations.
.opd: .opd:
FPTRS FPTRS
.rela.opd: .rela.opd:
EPLT relocations for symbols exported from shared libraries. */ EPLT relocations for symbols exported from shared libraries. */
@ -1845,7 +1842,7 @@ elf64_hppa_link_output_symbol_hook (abfd, info, name, sym, input_sec)
{ {
/* Restore the saved value and section index. */ /* Restore the saved value and section index. */
sym->st_value = dyn_h->st_value; sym->st_value = dyn_h->st_value;
sym->st_shndx = dyn_h->st_shndx; sym->st_shndx = dyn_h->st_shndx;
} }
return true; return true;
@ -1918,13 +1915,13 @@ elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
else else
value = (h->root.u.def.value + h->root.u.def.section->vma); value = (h->root.u.def.value + h->root.u.def.section->vma);
/* Fill in the entry in the procedure linkage table. /* Fill in the entry in the procedure linkage table.
The format of a plt entry is The format of a plt entry is
<funcaddr> <__gp>. <funcaddr> <__gp>.
plt_offset is the offset within the PLT section at which to plt_offset is the offset within the PLT section at which to
install the PLT entry. install the PLT entry.
We are modifying the in-memory PLT contents here, so we do not add We are modifying the in-memory PLT contents here, so we do not add
in the output_offset of the PLT section. */ in the output_offset of the PLT section. */
@ -1967,7 +1964,7 @@ elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
/* Fix up the first ldd instruction. /* Fix up the first ldd instruction.
We are modifying the contents of the STUB section in memory, We are modifying the contents of the STUB section in memory,
so we do not need to include its output offset in this computation. so we do not need to include its output offset in this computation.
Note the plt_offset value is the value of the PLT entry relative to Note the plt_offset value is the value of the PLT entry relative to
the start of the PLT section. These instructions will reference the start of the PLT section. These instructions will reference
@ -1976,7 +1973,7 @@ elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
gp_offset contains the offset of __gp within the PLT section. */ gp_offset contains the offset of __gp within the PLT section. */
value = dyn_h->plt_offset - hppa_info->gp_offset; value = dyn_h->plt_offset - hppa_info->gp_offset;
insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset); insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset);
insn &= 0xffffc00e; insn &= 0xffffc00e;
insn |= ((value & 0x2000) >> 13); insn |= ((value & 0x2000) >> 13);
@ -1987,7 +1984,7 @@ elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
/* Fix up the second ldd instruction. */ /* Fix up the second ldd instruction. */
value = dyn_h->plt_offset - hppa_info->gp_offset + 8; value = dyn_h->plt_offset - hppa_info->gp_offset + 8;
insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8); insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8);
insn &= 0xffffc00e; insn &= 0xffffc00e;
insn |= ((value & 0x2000) >> 13); insn |= ((value & 0x2000) >> 13);
@ -2027,7 +2024,7 @@ elf64_hppa_finalize_opd (dyn_h, data)
{ {
bfd_vma value; bfd_vma value;
/* The first two words of an .opd entry are zero. /* The first two words of an .opd entry are zero.
We are modifying the contents of the OPD section in memory, so we We are modifying the contents of the OPD section in memory, so we
do not need to include its output offset in this computation. */ do not need to include its output offset in this computation. */
@ -2080,7 +2077,7 @@ elf64_hppa_finalize_opd (dyn_h, data)
(if we did, the data in the .opd would reference itself rather (if we did, the data in the .opd would reference itself rather
than the actual address of the function). Instead we have to use than the actual address of the function). Instead we have to use
a new dynamic symbol which has the same value as the original global a new dynamic symbol which has the same value as the original global
function symbol. function symbol.
We prefix the original symbol with a "." and use the new symbol in We prefix the original symbol with a "." and use the new symbol in
the EPLT relocation. This new symbol has already been recorded in the EPLT relocation. This new symbol has already been recorded in
@ -2152,7 +2149,7 @@ elf64_hppa_finalize_dlt (dyn_h, data)
bfd_vma value; bfd_vma value;
/* If we had an LTOFF_FPTR style relocation we want the DLT entry /* If we had an LTOFF_FPTR style relocation we want the DLT entry
to point to the FPTR entry in the .opd section. to point to the FPTR entry in the .opd section.
We include the OPD's output offset in this computation as We include the OPD's output offset in this computation as
we are referring to an absolute address in the resulting we are referring to an absolute address in the resulting
@ -2197,7 +2194,6 @@ elf64_hppa_finalize_dlt (dyn_h, data)
= _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner, = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
dyn_h->sym_indx); dyn_h->sym_indx);
/* Create a dynamic relocation for this entry. Do include the output /* Create a dynamic relocation for this entry. Do include the output
offset of the DLT entry since we need an absolute address in the offset of the DLT entry since we need an absolute address in the
resulting object file. */ resulting object file. */
@ -2269,7 +2265,7 @@ elf64_hppa_finalize_dynreloc (dyn_h, data)
break; break;
} }
/* Create a dynamic relocation for this entry. /* Create a dynamic relocation for this entry.
We need the output offset for the reloc's section because We need the output offset for the reloc's section because
we are creating an absolute address in the resulting object we are creating an absolute address in the resulting object
@ -2292,7 +2288,7 @@ elf64_hppa_finalize_dynreloc (dyn_h, data)
the .opd entry. At least that seems sensible until you the .opd entry. At least that seems sensible until you
realize there's no local dynamic symbols we can use for that realize there's no local dynamic symbols we can use for that
purpose. Thus the hair in the check_relocs routine. purpose. Thus the hair in the check_relocs routine.
We use a section symbol recorded by check_relocs as the We use a section symbol recorded by check_relocs as the
base symbol for the relocation. The addend is the difference base symbol for the relocation. The addend is the difference
between the section symbol and the address of the .opd entry. */ between the section symbol and the address of the .opd entry. */
@ -2313,7 +2309,7 @@ elf64_hppa_finalize_dynreloc (dyn_h, data)
/* Compute the difference between the start of the section /* Compute the difference between the start of the section
with the relocation and the opd entry. */ with the relocation and the opd entry. */
value -= value2; value -= value2;
/* The result becomes the addend of the relocation. */ /* The result becomes the addend of the relocation. */
rel.r_addend = value; rel.r_addend = value;
@ -2370,7 +2366,6 @@ elf64_hppa_finish_dynamic_sections (output_bfd, info)
elf64_hppa_finalize_dlt, elf64_hppa_finalize_dlt,
info); info);
sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
if (elf_hash_table (info)->dynamic_sections_created) if (elf_hash_table (info)->dynamic_sections_created)
@ -2453,11 +2448,10 @@ elf64_hppa_finish_dynamic_sections (output_bfd, info)
return true; return true;
} }
/* Return the number of additional phdrs we will need. /* Return the number of additional phdrs we will need.
The generic ELF code only creates PT_PHDRs for executables. The HP The generic ELF code only creates PT_PHDRs for executables. The HP
dynamic linker requires PT_PHDRs for dynamic libraries too. dynamic linker requires PT_PHDRs for dynamic libraries too.
This routine indicates that the backend needs one additional program This routine indicates that the backend needs one additional program
header for that case. header for that case.
@ -2484,10 +2478,10 @@ elf64_hppa_additional_program_headers (abfd)
specific backend. specific backend.
The generic ELF code only creates PT_PHDRs for executables. The HP The generic ELF code only creates PT_PHDRs for executables. The HP
dynamic linker requires PT_PHDRs for dynamic libraries too. dynamic linker requires PT_PHDRs for dynamic libraries too.
This allocates the PT_PHDR and initializes it in a manner suitable This allocates the PT_PHDR and initializes it in a manner suitable
for the HP linker. for the HP linker.
Note we do not have access to the link info structure here, so we have Note we do not have access to the link info structure here, so we have
to guess whether or not we are building a shared library based on the to guess whether or not we are building a shared library based on the
@ -2631,7 +2625,6 @@ const struct elf_size_info hppa64_elf_size_info =
#define elf_backend_link_output_symbol_hook \ #define elf_backend_link_output_symbol_hook \
elf64_hppa_link_output_symbol_hook elf64_hppa_link_output_symbol_hook
#define elf_backend_want_got_plt 0 #define elf_backend_want_got_plt 0
#define elf_backend_plt_readonly 0 #define elf_backend_plt_readonly 0
#define elf_backend_want_plt_sym 0 #define elf_backend_want_plt_sym 0

14
bfd/elf64-mips.c
View File

@ -623,7 +623,7 @@ static reloc_howto_type mips_elf64_howto_table_rel[] =
0, /* dst_mask */ 0, /* dst_mask */
false), /* pcrel_offset */ false), /* pcrel_offset */
/* Protected jump conversion. This is an optimization hint. No /* Protected jump conversion. This is an optimization hint. No
relocation is required for correctness. */ relocation is required for correctness. */
HOWTO (R_MIPS_JALR, /* type */ HOWTO (R_MIPS_JALR, /* type */
0, /* rightshift */ 0, /* rightshift */
@ -1177,7 +1177,7 @@ static reloc_howto_type mips_elf64_howto_table_rela[] =
0, /* dst_mask */ 0, /* dst_mask */
false), /* pcrel_offset */ false), /* pcrel_offset */
/* Protected jump conversion. This is an optimization hint. No /* Protected jump conversion. This is an optimization hint. No
relocation is required for correctness. */ relocation is required for correctness. */
HOWTO (R_MIPS_JALR, /* type */ HOWTO (R_MIPS_JALR, /* type */
0, /* rightshift */ 0, /* rightshift */
@ -1270,7 +1270,7 @@ mips_elf64_be_swap_reloc_in (abfd, src, dst)
{ {
Elf64_Mips_Internal_Rel mirel; Elf64_Mips_Internal_Rel mirel;
mips_elf64_swap_reloc_in (abfd, mips_elf64_swap_reloc_in (abfd,
(const Elf64_Mips_External_Rel *) src, (const Elf64_Mips_External_Rel *) src,
&mirel); &mirel);
@ -1292,7 +1292,7 @@ mips_elf64_be_swap_reloca_in (abfd, src, dst)
{ {
Elf64_Mips_Internal_Rela mirela; Elf64_Mips_Internal_Rela mirela;
mips_elf64_swap_reloca_in (abfd, mips_elf64_swap_reloca_in (abfd,
(const Elf64_Mips_External_Rela *) src, (const Elf64_Mips_External_Rela *) src,
&mirela); &mirela);
@ -1324,7 +1324,7 @@ mips_elf64_be_swap_reloc_out (abfd, src, dst)
mirel.r_ssym = STN_UNDEF; mirel.r_ssym = STN_UNDEF;
mirel.r_type3 = R_MIPS_NONE; mirel.r_type3 = R_MIPS_NONE;
mips_elf64_swap_reloc_out (abfd, &mirel, mips_elf64_swap_reloc_out (abfd, &mirel,
(Elf64_Mips_External_Rel *) dst); (Elf64_Mips_External_Rel *) dst);
} }
@ -1346,7 +1346,7 @@ mips_elf64_be_swap_reloca_out (abfd, src, dst)
mirela.r_ssym = STN_UNDEF; mirela.r_ssym = STN_UNDEF;
mirela.r_type3 = R_MIPS_NONE; mirela.r_type3 = R_MIPS_NONE;
mips_elf64_swap_reloca_out (abfd, &mirela, mips_elf64_swap_reloca_out (abfd, &mirela,
(Elf64_Mips_External_Rela *) dst); (Elf64_Mips_External_Rela *) dst);
} }
@ -2150,7 +2150,7 @@ const struct elf_size_info mips_elf64_size_info =
#define elf_backend_plt_header_size 0 #define elf_backend_plt_header_size 0
#define elf_backend_may_use_rel_p 1 #define elf_backend_may_use_rel_p 1
/* We don't set bfd_elf64_bfd_is_local_label_name because the 32-bit /* We don't set bfd_elf64_bfd_is_local_label_name because the 32-bit
MIPS-specific function only applies to IRIX5, which had no 64-bit MIPS-specific function only applies to IRIX5, which had no 64-bit
ABI. */ ABI. */
#define bfd_elf64_find_nearest_line _bfd_mips_elf_find_nearest_line #define bfd_elf64_find_nearest_line _bfd_mips_elf_find_nearest_line