/* BFD backend for hp-ux 9000/300
- Copyright (C) 1990, 1991, 1994 Free Software Foundation, Inc.
+ Copyright (C) 1990, 91, 94, 95, 97, 1999 Free Software Foundation, Inc.
Written by Glenn Engel.
This file is part of BFD, the Binary File Descriptor library.
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. */
/*
mkobject
This should also be fixed. */
-#define ARCH 32
#define TARGETNAME "a.out-hp300hpux"
#define MY(OP) CAT(hp300hpux_,OP)
#define DEFAULT_ARCH bfd_arch_m68k
#define MY_get_section_contents aout_32_get_section_contents
-#define MY_close_and_cleanup aout_32_close_and_cleanup
#define MY_slurp_armap bfd_slurp_bsd_armap_f2
/***********************************************/
#define MY_canonicalize_reloc hp300hpux_canonicalize_reloc
#define MY_write_object_contents hp300hpux_write_object_contents
+#define MY_read_minisymbols _bfd_generic_read_minisymbols
+#define MY_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
+
#define MY_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
#define MY_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define MY_final_link_callback unused
#define MY_bfd_final_link _bfd_generic_final_link
+/* Until and unless we convert the slurp_reloc and slurp_symtab
+ routines in this file, we can not use the default aout
+ free_cached_info routine which assumes that the relocs and symtabs
+ were allocated using malloc. */
+#define MY_bfd_free_cached_info bfd_true
+
#define hp300hpux_write_syms aout_32_write_syms
#define MY_callback MY(callback)
+#define MY_exec_hdr_flags 0x2
+
#define NAME_swap_exec_header_in NAME(hp300hpux_32_,swap_exec_header_in)
#define HP_SYMTYPE_UNDEFINED 0x00
#define NAME(x,y) CAT3(hp300hpux,_32_,y)
#define ARCH_SIZE 32
+
+/* aoutx.h requires definitions for BMAGIC and QMAGIC. */
+#define BMAGIC HPUX_DOT_O_MAGIC
+#define QMAGIC 0314
+
#include "aoutx.h"
/* Since the hpux symbol table has nlist elements interspersed with
/* Set parameters about this a.out file that are machine-dependent.
This routine is called from some_aout_object_p just before it returns. */
-static bfd_target *
+static const bfd_target *
MY (callback) (abfd)
bfd *abfd;
{
obj_datasec (abfd)->vma = N_DATADDR (*execp);
obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
+ obj_textsec (abfd)->lma = obj_textsec (abfd)->vma;
+ obj_datasec (abfd)->lma = obj_datasec (abfd)->vma;
+ obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma;
+
/* The file offsets of the sections */
obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
obj_datasec (abfd)->filepos = N_DATOFF (*execp);
#endif
if (adata (abfd).magic == undecided_magic)
- NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
+ NAME (aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
execp->a_syms = 0;
execp->a_entry = bfd_get_start_address (abfd);
obj_reloc_entry_size (abfd));
N_SET_MACHTYPE (*execp, 0xc);
- N_SET_FLAGS (*execp, 0x2);
+ N_SET_FLAGS (*execp, aout_backend_info (abfd)->exec_hdr_flags);
- NAME (aout, swap_exec_header_out) (abfd, execp, &exec_bytes);
+ NAME (aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
/* update fields not covered by default swap_exec_header_out */
/* this is really the sym table size but we store it in drelocs */
bfd_h_put_32 (abfd, bfd_get_symcount (abfd) * 12, exec_bytes.e_drelocs);
- bfd_seek (abfd, 0L, false);
- bfd_write ((PTR) & exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
+ if (bfd_seek (abfd, 0L, false) != 0
+ || (bfd_write ((PTR) & exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
+ != EXEC_BYTES_SIZE))
+ return false;
/* Write out the symbols, and then the relocs. We must write out
the symbols first so that we know the symbol indices. */
if (bfd_get_symcount (abfd) != 0)
{
- bfd_seek (abfd, (long) (N_TRELOFF (*execp)), false);
-
- if (!NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd)))
+ if (bfd_seek (abfd, (long) (N_TRELOFF (*execp)), false) != 0)
return false;
- bfd_seek (abfd, (long) (N_DRELOFF (*execp)), false);
-
- if (!NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
+ if (!NAME (aout,squirt_out_relocs) (abfd, obj_textsec (abfd)))
+ return false;
+ if (bfd_seek (abfd, (long) (N_DRELOFF (*execp)), false) != 0)
+ return false;
+ if (!NAME (aout,squirt_out_relocs) (abfd, obj_datasec (abfd)))
return false;
}
static void
convert_sym_type (sym_pointer, cache_ptr, abfd)
- struct external_nlist *sym_pointer;
+ struct external_nlist *sym_pointer ATTRIBUTE_UNUSED;
aout_symbol_type *cache_ptr;
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
{
int name_type;
int new_type;
break;
default:
- fprintf (stderr, "unknown symbol type encountered: %x", name_type);
+ abort ();
+ break;
}
if (name_type & HP_SYMTYPE_EXTERNAL)
new_type |= N_EXT;
if (name_type & HP_SECONDARY_SYMBOL)
- new_type = (new_type & ~N_TYPE) | N_INDR;
+ {
+ switch (new_type)
+ {
+ default:
+ abort ();
+ case N_UNDF | N_EXT:
+ /* If the value is nonzero, then just treat this as a
+ common symbol. I don't know if this is correct in
+ all cases, but it is more correct than treating it as
+ a weak undefined symbol. */
+ if (cache_ptr->symbol.value == 0)
+ new_type = N_WEAKU;
+ break;
+ case N_ABS | N_EXT:
+ new_type = N_WEAKA;
+ break;
+ case N_TEXT | N_EXT:
+ new_type = N_WEAKT;
+ break;
+ case N_DATA | N_EXT:
+ new_type = N_WEAKD;
+ break;
+ case N_BSS | N_EXT:
+ new_type = N_WEAKB;
+ break;
+ }
+ }
}
cache_ptr->type = new_type;
*/
void
- NAME (aout, swap_exec_header_in) (abfd, raw_bytes, execp)
+NAME (aout,swap_exec_header_in) (abfd, raw_bytes, execp)
bfd *abfd;
struct external_exec *raw_bytes;
struct internal_exec *execp;
rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
if (rawptr == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return;
- }
+ return;
abfd->tdata.aout_data = rawptr;
obj_aout_subformat (abfd) = gnu_encap_format;
}
char *strings;
aout_symbol_type *cached;
unsigned num_syms = 0;
- unsigned num_secondary = 0;
/* If there's no work to be done, don't do any */
if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
return true;
symbol_bytes = exec_hdr (abfd)->a_syms;
- if (symbol_bytes == 0)
- {
- bfd_set_error (bfd_error_no_symbols);
- return false;
- }
strings = (char *) bfd_alloc (abfd,
symbol_bytes + SYM_EXTRA_BYTES);
if (!strings)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
syms = (struct external_nlist *) (strings + SYM_EXTRA_BYTES);
- bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET);
- if (bfd_read ((PTR) syms, symbol_bytes, 1, abfd) != symbol_bytes)
+ if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
+ || bfd_read ((PTR) syms, symbol_bytes, 1, abfd) != symbol_bytes)
{
bfd_release (abfd, syms);
return false;
/* first, march thru the table and figure out how many symbols there are */
for (sym_pointer = syms; sym_pointer < sym_end; sym_pointer++, num_syms++)
{
- if (bfd_get_8 (abfd, sym_pointer->e_type) & HP_SECONDARY_SYMBOL)
- num_secondary++;
/* skip over the embedded symbol. */
sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
sym_pointer->e_length[0]);
}
/* now that we know the symbol count, update the bfd header */
- bfd_get_symcount (abfd) = num_syms + num_secondary;
+ bfd_get_symcount (abfd) = num_syms;
- cached = (aout_symbol_type *)
- bfd_zalloc (abfd, (bfd_size_type) (bfd_get_symcount (abfd) *
- sizeof (aout_symbol_type)));
- if (!cached)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ cached = ((aout_symbol_type *)
+ bfd_zalloc (abfd,
+ bfd_get_symcount (abfd) * sizeof (aout_symbol_type)));
+ if (cached == NULL && bfd_get_symcount (abfd) != 0)
+ return false;
/* as we march thru the hp symbol table, convert it into a list of
null terminated strings to hold the symbol names. Make sure any
assignment to the strings pointer is done after we're thru using
the nlist so we don't overwrite anything important. */
- num_secondary = 0;
/* OK, now walk the new symtable, cacheing symbol properties */
{
cache_ptr->symbol.value = GET_SWORD (abfd, sym_pointer->e_value);
cache_ptr->desc = bfd_get_16 (abfd, sym_pointer->e_almod);
cache_ptr->type = bfd_get_8 (abfd, sym_pointer->e_type);
- cache_ptr->symbol.udata = 0;
+ cache_ptr->symbol.udata.p = NULL;
length = bfd_get_8 (abfd, sym_pointer->e_length);
cache_ptr->other = length; /* other not used, save length here */
cache_save = *cache_ptr;
convert_sym_type (sym_pointer, cache_ptr, abfd);
- if (!translate_from_native_sym_flags (sym_pointer, cache_ptr, abfd))
+ if (!translate_from_native_sym_flags (abfd, cache_ptr))
return false;
/********************************************************/
else
cache_ptr->symbol.name = (char *) NULL;
- /**********************************************************/
- /* this is a bit of a kludge, but a secondary hp symbol */
- /* gets translated into a gnu indirect symbol. When this */
- /* happens, we need to create a "dummy" record to which */
- /* we can point the indirect symbol to. */
- /**********************************************************/
- if ((cache_ptr->type | N_EXT) == (N_INDR | N_EXT))
- {
- aout_symbol_type *cache_ptr2 = cached + num_syms + num_secondary;
-
- num_secondary++;
-
- /* aoutx.h assumes the "next" value is the indirect sym */
- /* since we don't want to disturb the order by inserting */
- /* a new symbol, we tack on the created secondary syms */
- /* at the end. */
- cache_ptr->symbol.value = (bfd_vma) (cache_ptr2);
- *cache_ptr2 = cache_save;
- cache_ptr2->symbol.name = strings;
- memcpy (strings, cache_ptr->symbol.name, length);
- strcpy (strings + length, ":secondry"); /* 9 max chars + null */
- strings += length + 10;
- cache_ptr2->type &= ~HP_SECONDARY_SYMBOL; /* clear secondary */
- convert_sym_type (sym_pointer, cache_ptr2, abfd);
- if (!translate_from_native_sym_flags (sym_pointer, cache_ptr2,
- abfd))
- return false;
- }
-
/* skip over the embedded symbol. */
sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
length);
void
-MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
bfd *abfd;
struct hp300hpux_reloc *bytes;
arelent *cache_ptr;
asymbol **symbols;
+ bfd_size_type symcount ATTRIBUTE_UNUSED;
{
int r_index;
int r_extern = 0;
case HP_RSEGMENT_NOOP:
break;
default:
- fprintf (stderr, "illegal relocation segment type: %x\n",
- (bytes->r_type[0]));
+ abort ();
+ break;
}
switch (bytes->r_length[0])
r_length = 2;
break;
default:
- fprintf (stderr, "illegal relocation length: %x\n", bytes->r_length[0]);
- r_length = 0;
+ abort ();
+ break;
}
cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
return false;
doit:
- bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
+ if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
+ return false;
each_size = obj_reloc_entry_size (abfd);
count = reloc_size / each_size;
reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t) (count * sizeof
(arelent)));
- if (!reloc_cache)
- {
- nomem:
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ if (!reloc_cache && count != 0)
+ return false;
relocs = (PTR) bfd_alloc (abfd, reloc_size);
- if (!relocs)
+ if (!relocs && reloc_size != 0)
{
bfd_release (abfd, reloc_cache);
- goto nomem;
+ return false;
}
if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
for (; counter < count; counter++, rptr++, cache_ptr++)
{
- MY (swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
+ MY (swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols,
+ bfd_get_symcount (abfd));
}
/* call aout_32 versions if the input file was generated by gcc */
/************************************************************************/
-unsigned int aout_32_get_symtab PARAMS ((bfd * abfd, asymbol ** location));
-unsigned int aout_32_get_symtab_upper_bound PARAMS ((bfd * abfd));
+long aout_32_get_symtab PARAMS ((bfd * abfd, asymbol ** location));
+long aout_32_get_symtab_upper_bound PARAMS ((bfd * abfd));
-unsigned int aout_32_canonicalize_reloc PARAMS ((bfd * abfd, sec_ptr section,
- arelent ** relptr,
- asymbol ** symbols));
+long aout_32_canonicalize_reloc PARAMS ((bfd * abfd, sec_ptr section,
+ arelent ** relptr,
+ asymbol ** symbols));
-unsigned int
+long
MY (get_symtab) (abfd, location)
bfd *abfd;
asymbol **location;
return aout_32_get_symtab (abfd, location);
if (!MY (slurp_symbol_table) (abfd))
- return 0;
+ return -1;
for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
*(location++) = (asymbol *) (symbase++);
return bfd_get_symcount (abfd);
}
-unsigned int
+long
MY (get_symtab_upper_bound) (abfd)
bfd *abfd;
{
if (obj_aout_subformat (abfd) == gnu_encap_format)
return aout_32_get_symtab_upper_bound (abfd);
if (!MY (slurp_symbol_table) (abfd))
- return 0;
+ return -1;
return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
}
-unsigned int
+long
MY (canonicalize_reloc) (abfd, section, relptr, symbols)
bfd *abfd;
sec_ptr section;
return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
if (!(tblptr || MY (slurp_reloc_table) (abfd, section, symbols)))
- return 0;
+ return -1;
if (section->flags & SEC_CONSTRUCTOR)
{
else
{
tblptr = section->relocation;
- if (!tblptr)
- return 0;
for (count = 0; count++ < section->reloc_count;)
{
projects / external / binutils.git / blobdiff