/* BFD back-end for HP PA-RISC ELF files.
- Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
+ Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
Written by
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
#include "libbfd.h"
#include "obstack.h"
-#include "libelf.h"
+#include "elf-bfd.h"
/* The internal type of a symbol table extension entry. */
typedef unsigned long symext_entryS;
static bfd_reloc_status_type hppa_elf_reloc
PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd*, char **));
-static CONST reloc_howto_type * elf_hppa_reloc_type_lookup
+static reloc_howto_type * elf_hppa_reloc_type_lookup
PARAMS ((bfd *, bfd_reloc_code_real_type));
static boolean elf32_hppa_set_section_contents
PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
static boolean elf32_hppa_backend_symbol_table_processing
- PARAMS ((bfd *, elf_symbol_type *, int));
+ PARAMS ((bfd *, elf_symbol_type *, unsigned int));
static void elf32_hppa_backend_begin_write_processing
PARAMS ((bfd *, struct bfd_link_info *));
const char **, flagword *, asection **, bfd_vma *));
static bfd_reloc_status_type elf32_hppa_bfd_final_link_relocate
- PARAMS ((const reloc_howto_type *, bfd *, bfd *, asection *,
+ PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
bfd_byte *, bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *,
asection *, const char *, int));
bfd_hash_allocate (table,
sizeof (struct elf32_hppa_stub_hash_entry)));
if (ret == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
/* Call the allocation method of the superclass. */
ret = ((struct elf32_hppa_stub_hash_entry *)
bfd_hash_allocate (table,
sizeof (struct elf32_hppa_args_hash_entry)));
if (ret == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
/* Call the allocation method of the superclass. */
ret = ((struct elf32_hppa_args_hash_entry *)
ret = ((struct elf32_hppa_link_hash_table *)
bfd_alloc (abfd, sizeof (struct elf32_hppa_link_hash_table)));
if (ret == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
_bfd_elf_link_hash_newfunc))
{
for (; rel < relend; rel++)
{
int r_type;
- const reloc_howto_type *howto;
- long r_symndx;
+ reloc_howto_type *howto;
+ unsigned long r_symndx;
struct elf_link_hash_entry *h;
Elf_Internal_Sym *sym;
asection *sym_sec;
indx = r_symndx - symtab_hdr->sh_info;
h = elf_sym_hashes (input_bfd)[indx];
- if (h->root.type == bfd_link_hash_defined)
+ 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;
+ if (h->root.type == bfd_link_hash_defined
+ || h->root.type == bfd_link_hash_defweak)
{
sym_sec = h->root.u.def.section;
relocation = (h->root.u.def.value
+ sym_sec->output_offset
+ sym_sec->output_section->vma);
}
- else if (h->root.type == bfd_link_hash_weak)
+ else if (h->root.type == bfd_link_hash_undefweak)
relocation = 0;
else
{
(info, h->root.root.string, input_bfd,
input_section, rel->r_offset)))
return false;
- relocation = 0;
+ break;
}
}
sym_name = h->root.root.string;
else
{
- sym_name = elf_string_from_elf_section (input_bfd,
- symtab_hdr->sh_link,
- sym->st_name);
+ sym_name = bfd_elf_string_from_elf_section (input_bfd,
+ symtab_hdr->sh_link,
+ sym->st_name);
if (sym_name == NULL)
return false;
if (*sym_name == '\0')
{
switch (r)
{
+ /* This can happen for DP relative relocs if $global$ is
+ undefined. This is a panic situation so we don't try
+ to continue. */
+ case bfd_reloc_undefined:
+ case bfd_reloc_notsupported:
+ if (!((*info->callbacks->undefined_symbol)
+ (info, "$global$", input_bfd,
+ input_section, rel->r_offset)))
+ return false;
+ return false;
case bfd_reloc_dangerous:
{
/* We use this return value to indicate that we performed
relocation with modifications based on format and field. */
elf32_hppa_reloc_type **
-hppa_elf_gen_reloc_type (abfd, base_type, format, field)
+hppa_elf_gen_reloc_type (abfd, base_type, format, field, ignore)
bfd *abfd;
elf32_hppa_reloc_type base_type;
int format;
int field;
+ int ignore;
{
elf32_hppa_reloc_type *finaltype;
elf32_hppa_reloc_type **final_types;
if (!strcmp (section->name, ".PARISC.symextn") && !symext_chain_size)
return true;
else
- return bfd_elf32_set_section_contents (abfd, section, location,
- offset, count);
+ return _bfd_elf_set_section_contents (abfd, section, location,
+ offset, count);
}
/* Translate from an elf into field into a howto relocation pointer. */
elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
input_section, contents, offset, value,
addend, info, sym_sec, sym_name, is_local)
- const reloc_howto_type *howto;
+ reloc_howto_type *howto;
bfd *input_bfd;
bfd *output_bfd;
asection *input_section;
if (h == NULL)
return bfd_reloc_notsupported;
+ /* If $global$ isn't a defined symbol, then we're still in deep
+ trouble. */
+ if (h->root.type != bfd_link_hash_defined)
+ return bfd_reloc_undefined;
+
sec = h->root.u.def.section;
elf32_hppa_hash_table (info)->global_value = (h->root.u.def.value
+ sec->output_section->vma
case R_PARISC_DPREL21L:
r_field = e_lrsel;
if (sym_sec->flags & SEC_CODE)
- insn &= ~0x03e00000;
+ {
+ if ((insn & 0xfc000000) >> 26 == 0xa
+ && (insn & 0x03e00000) >> 21 == 0x1b)
+ insn &= ~0x03e00000;
+ }
else
value -= elf32_hppa_hash_table (info)->global_value;
goto do_basic_type_1;
len = strlen (sym_name) + 1;
if (is_local)
len += 9;
- new_name = malloc (len);
+ new_name = bfd_malloc (len);
if (!new_name)
- {
- bfd_set_error (bfd_error_no_memory);
- return bfd_reloc_notsupported;
- }
+ return bfd_reloc_notsupported;
strcpy (new_name, sym_name);
/* Local symbols have unique IDs. */
len = strlen (new_name);
len += 23;
- stub_name = malloc (len);
+ stub_name = bfd_malloc (len);
if (!stub_name)
- {
- bfd_set_error (bfd_error_no_memory);
- return bfd_reloc_notsupported;
- }
+ return bfd_reloc_notsupported;
elf32_hppa_name_of_stub (caller_args, callee_args,
location, value, stub_name);
strcat (stub_name, new_name);
/* Return the address of the howto table entry to perform the CODE
relocation for an ARCH machine. */
-static CONST reloc_howto_type *
+static reloc_howto_type *
elf_hppa_reloc_type_lookup (abfd, code)
bfd *abfd;
bfd_reloc_code_real_type code;
if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
len += 9;
- new_name = malloc (len);
+ new_name = bfd_malloc (len);
if (new_name == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
strcpy (new_name, name);
if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
/* Allocate memory and initialize this entry. */
symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
if (!symextP)
- {
- bfd_set_error (bfd_error_no_memory);
- abort(); /* FIXME */
- }
+ abort(); /* FIXME */
symextP[0].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_SYMNDX, sym_idx);
symextP[0].next = &symextP[1];
symextn_contents = (bfd_byte *) bfd_zalloc (abfd,
symextn_sec->_raw_size);
if (!symextn_contents)
- {
- bfd_set_error (bfd_error_no_memory);
- abort(); /* FIXME */
- }
+ abort(); /* FIXME */
/* Fill in the contents of the symbol extension chain. */
for (i = 0, symextP = symext_root; symextP; symextP = symextP->next, ++i)
elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
bfd *abfd;
elf_symbol_type *esyms;
- int symcnt;
+ unsigned int symcnt;
{
Elf32_Internal_Shdr *symextn_hdr =
bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
/* Allocate a buffer of the appropriate size for the symextn section. */
symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
if (!symextn_hdr->contents)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
/* Read in the symextn section. */
if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
return true;
}
- contents = (bfd_byte *) malloc (symextn_sec->_raw_size);
+ contents = (bfd_byte *) bfd_malloc ((size_t) symextn_sec->_raw_size);
if (contents == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
/* How gross. We turn off SEC_HAS_CONTENTS for the input symbol extension
sections to keep the generic ELF/BFD code from trying to do anything
hdr = elf_elfsections (input_bfd)[local_syms[current_index].st_shndx];
sym_sec = hdr->bfd_section;
- sym_name = elf_string_from_elf_section (input_bfd,
+ sym_name = bfd_elf_string_from_elf_section (input_bfd,
symtab_hdr->sh_link,
local_syms[current_index].st_name);
len = strlen (sym_name) + 10;
- new_name = malloc (len);
+ new_name = bfd_malloc (len);
if (new_name == NULL)
{
- bfd_set_error (bfd_error_no_memory);
free (contents);
return false;
}
size = bfd_section_size (stub_bfd, stub_sec);
stub_sec->contents = (unsigned char *) bfd_zalloc (stub_bfd, size);
if (stub_sec->contents == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
table = elf32_hppa_hash_table(info)->stub_hash_table;
table->location = stub_sec->contents;
struct bfd_link_info *link_info;
{
bfd *input_bfd;
- asection *section, *stub_sec;
+ asection *section, *stub_sec = 0;
Elf_Internal_Shdr *symtab_hdr;
- Elf_Internal_Sym *local_syms, *isym;
+ Elf_Internal_Sym *local_syms, *isym, **all_local_syms;
Elf32_External_Sym *ext_syms, *esym;
- unsigned int bfd_count = 0;
+ unsigned int i, index, bfd_count = 0;
struct elf32_hppa_stub_hash_table *stub_hash_table = 0;
struct elf32_hppa_args_hash_table *args_hash_table = 0;
/* Create and initialize the stub hash table. */
stub_hash_table = ((struct elf32_hppa_stub_hash_table *)
- malloc (sizeof (struct elf32_hppa_stub_hash_table)));
+ bfd_malloc (sizeof (struct elf32_hppa_stub_hash_table)));
if (!stub_hash_table)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
if (!elf32_hppa_stub_hash_table_init (stub_hash_table, stub_bfd,
elf32_hppa_stub_hash_newfunc))
/* Likewise for the argument location hash table. */
args_hash_table = ((struct elf32_hppa_args_hash_table *)
- malloc (sizeof (struct elf32_hppa_args_hash_table)));
+ bfd_malloc (sizeof (struct elf32_hppa_args_hash_table)));
if (!args_hash_table)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
if (!elf32_hppa_args_hash_table_init (args_hash_table,
elf32_hppa_args_hash_newfunc))
we need to read in the local symbols in parallel and save them for
later use; so hold pointers to the local symbols in an array. */
all_local_syms
- = (Elf_Internal_Sym **) malloc (sizeof (Elf_Internal_Sym *) * bfd_count);
+ = (Elf_Internal_Sym **) bfd_malloc (sizeof (Elf_Internal_Sym *)
+ * bfd_count);
if (all_local_syms == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
memset (all_local_syms, 0, sizeof (Elf_Internal_Sym *) * bfd_count);
/* Walk over all the input BFDs adding entries to the args hash table
for all the external functions. */
- for (input_bfd = link_info->input_bfds, i = 0;
+ for (input_bfd = link_info->input_bfds, index = 0;
input_bfd != NULL;
- input_bfd = input_bfd->link_next, i++)
+ input_bfd = input_bfd->link_next, index++)
{
/* We'll need the symbol table in a second. */
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
/* We need an array of the local symbols attached to the input bfd.
Unfortunately, we're going to have to read & swap them in. */
local_syms
- = (Elf_Internal_Sym *)malloc (symtab_hdr->sh_info
- * sizeof (Elf_Internal_Sym));
+ = (Elf_Internal_Sym *) bfd_malloc (symtab_hdr->sh_info
+ * sizeof (Elf_Internal_Sym));
if (local_syms == NULL)
{
- bfd_set_error (bfd_error_no_memory);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
- all_local_symbols[i] = local_syms;
+ all_local_syms[index] = local_syms;
ext_syms
- = (Elf32_External_Sym *)malloc (symtab_hdr->sh_info
- * sizeof (Elf32_External_Sym));
+ = (Elf32_External_Sym *) bfd_malloc (symtab_hdr->sh_info
+ * sizeof (Elf32_External_Sym));
if (ext_syms == NULL)
{
- bfd_set_error (bfd_error_no_memory);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
!= (symtab_hdr->sh_info * sizeof (Elf32_External_Sym)))
{
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
free (ext_syms);
goto error_return;
}
local_syms) == false)
{
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
}
if (link_info->relocateable)
{
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
return true;
}
/* Now that we have argument location information for all the global
functions we can start looking for stubs. */
- for (input_bfd = link_info->input_bfds, i = 0;
+ for (input_bfd = link_info->input_bfds, index = 0;
input_bfd != NULL;
- input_bfd = input_bfd->link_next, i++)
+ input_bfd = input_bfd->link_next, index++)
{
- unsigned int i;
-
/* We'll need the symbol table in a second. */
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
if (symtab_hdr->sh_info == 0)
continue;
- local_syms = all_local_symbols[i];
+ local_syms = all_local_syms[index];
/* Walk over each section attached to the input bfd. */
for (section = input_bfd->sections;
/* Allocate space for the external relocations. */
external_relocs
- = (Elf32_External_Rela *) malloc (section->reloc_count * sizeof (Elf32_External_Rela));
+ = ((Elf32_External_Rela *)
+ bfd_malloc (section->reloc_count
+ * sizeof (Elf32_External_Rela)));
if (external_relocs == NULL)
{
- bfd_set_error (bfd_error_no_memory);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
/* Likewise for the internal relocations. */
internal_relocs
- = (Elf_Internal_Rela *) malloc (section->reloc_count * sizeof (Elf_Internal_Rela));
+ = ((Elf_Internal_Rela *)
+ bfd_malloc (section->reloc_count * sizeof (Elf_Internal_Rela)));
if (internal_relocs == NULL)
{
- bfd_set_error (bfd_error_no_memory);
free (external_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
free (external_relocs);
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
irelaend = irela + section->reloc_count;
for (; irela < irelaend; irela++)
{
- long r_type, callee_args, caller_args, r_index, size_of_stub;
+ long r_type, callee_args, caller_args, size_of_stub;
+ unsigned long r_index;
struct elf_link_hash_entry *hash;
struct elf32_hppa_stub_hash_entry *stub_hash;
struct elf32_hppa_args_hash_entry *args_hash;
bfd_set_error (bfd_error_bad_value);
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
sym = local_syms + r_index;
hdr = elf_elfsections (input_bfd)[sym->st_shndx];
sym_sec = hdr->bfd_section;
- sym_name = elf_string_from_elf_section (input_bfd,
- symtab_hdr->sh_link,
- sym->st_name);
+ sym_name = bfd_elf_string_from_elf_section (input_bfd,
+ symtab_hdr->sh_link,
+ sym->st_name);
sym_value = (ELF_ST_TYPE (sym->st_info) == STT_SECTION
? 0 : sym->st_value);
destination = (sym_value
/* Tack on an ID so we can uniquely identify this local
symbol in the stub or arg info hash tables. */
- new_name = malloc (strlen (sym_name) + 10);
+ new_name = bfd_malloc (strlen (sym_name) + 10);
if (new_name == 0)
{
- bfd_set_error (bfd_error_bad_value);
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
index = r_index - symtab_hdr->sh_info;
hash = elf_sym_hashes (input_bfd)[index];
- if (hash->root.type == bfd_link_hash_defined)
+ if (hash->root.type == bfd_link_hash_defined
+ || hash->root.type == bfd_link_hash_defweak)
{
sym_sec = hash->root.u.def.section;
sym_name = hash->root.root.string;
bfd_set_error (bfd_error_bad_value);
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
}
len = strlen (sym_name);
len += 23;
- stub_name = malloc (len);
+ stub_name = bfd_malloc (len);
if (!stub_name)
{
- bfd_set_error (bfd_error_no_memory);
-
/* Because sym_name was mallocd above for local
symbols. */
if (r_index < symtab_hdr->sh_info)
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
elf32_hppa_name_of_stub (caller_args, callee_args,
stub_name, true, true);
if (stub_hash == NULL)
{
- bfd_set_error (bfd_error_no_memory);
free (stub_name);
free (internal_relocs);
for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
goto error_return;
}
/* We're done with the internal relocs, free them. */
free (internal_relocs);
}
- /* We're done with the local symbols, free them. */
- for (i = 0; i < bfd_count; i++)
- if (all_local_symbols[i])
- free (all_local_symbols[i]);
- free (all_local_symbols);
}
+ /* We're done with the local symbols, free them. */
+ for (i = 0; i < bfd_count; i++)
+ if (all_local_syms[i])
+ free (all_local_syms[i]);
+ free (all_local_syms);
return true;
error_return:
elf32_hppa_hash_table(link_info)->args_hash_table = NULL;
free (args_hash_table);
}
+ /* Set the size of the stub section to zero since we're never going
+ to create them. Avoids losing when we try to get its contents
+ too. */
+ bfd_set_section_size (stub_bfd, stub_sec, 0);
return false;
}