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;
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 *));
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))
{
{
int r_type;
reloc_howto_type *howto;
- long r_symndx;
+ 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];
+ 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)
{
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;
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);
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
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;
/* 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
/* 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_syms[i])
free (all_local_syms[i]);
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_syms[i])
free (all_local_syms[i]);
/* 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_syms[i])
free (all_local_syms[i]);
/* 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_syms[i])
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;
/* 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_syms[i])
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)
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++)