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)
{
(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')
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. */
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);
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, **all_local_syms;
Elf32_External_Sym *ext_syms, *esym;
/* 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;
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_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++)
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;
}
projects / deliverable / binutils-gdb.git / blobdiff