#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_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 0415
+#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 *
-DEFUN(MY(callback),(abfd),
- bfd *abfd)
+MY (callback) (abfd)
+ bfd *abfd;
{
struct internal_exec *execp = exec_hdr (abfd);
/* Calculate the file positions of the parts of a newly read aout header */
- obj_textsec (abfd)->_raw_size = N_TXTSIZE(*execp);
+ obj_textsec (abfd)->_raw_size = N_TXTSIZE (*execp);
/* The virtual memory addresses of the sections */
- obj_textsec (abfd)->vma = N_TXTADDR(*execp);
- obj_datasec (abfd)->vma = N_DATADDR(*execp);
- obj_bsssec (abfd)->vma = N_BSSADDR(*execp);
+ obj_textsec (abfd)->vma = N_TXTADDR (*execp);
+ obj_datasec (abfd)->vma = N_DATADDR (*execp);
+ obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
/* The file offsets of the sections */
obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
obj_datasec (abfd)->filepos = N_DATOFF (*execp);
/* The file offsets of the relocation info */
- obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
- obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
+ obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
+ obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
obj_sym_filepos (abfd) = N_SYMOFF (*execp);
/* Determine the architecture and machine type of the object file. */
#ifdef SET_ARCH_MACH
- SET_ARCH_MACH(abfd, *execp);
+ SET_ARCH_MACH (abfd, *execp);
#else
- bfd_default_set_arch_mach(abfd, DEFAULT_ARCH, 0);
+ bfd_default_set_arch_mach (abfd, DEFAULT_ARCH, 0);
#endif
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- {
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ {
/* The file offsets of the relocation info */
- obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF(*execp);
- obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF(*execp);
+ obj_textsec (abfd)->rel_filepos = N_GNU_TRELOFF (*execp);
+ obj_datasec (abfd)->rel_filepos = N_GNU_DRELOFF (*execp);
/* The file offsets of the string table and symbol table. */
- obj_sym_filepos (abfd) = N_GNU_SYMOFF(*execp);
+ obj_sym_filepos (abfd) = N_GNU_SYMOFF (*execp);
obj_str_filepos (abfd) = (obj_sym_filepos (abfd) + execp->a_syms);
abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
bfd_get_symcount (abfd) = execp->a_syms / 12;
obj_symbol_entry_size (abfd) = 12;
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
- }
+ }
return abfd->xvec;
}
-extern boolean aout_32_write_syms PARAMS ((bfd *abfd));
+extern boolean aout_32_write_syms PARAMS ((bfd * abfd));
static boolean
-DEFUN(MY(write_object_contents),(abfd),
- bfd *abfd)
+MY (write_object_contents) (abfd)
+ bfd *abfd;
{
- struct external_exec exec_bytes;
- struct internal_exec *execp = exec_hdr (abfd);
- bfd_size_type text_size; /* dummy vars */
- file_ptr text_end;
+ struct external_exec exec_bytes;
+ struct internal_exec *execp = exec_hdr (abfd);
+ bfd_size_type text_size; /* dummy vars */
+ file_ptr text_end;
- memset (&exec_bytes, 0, sizeof (exec_bytes));
+ memset (&exec_bytes, 0, sizeof (exec_bytes));
#if CHOOSE_RELOC_SIZE
- CHOOSE_RELOC_SIZE(abfd);
+ CHOOSE_RELOC_SIZE (abfd);
#else
- obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
+ obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
#endif
- if (adata(abfd).magic == undecided_magic)
- NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
- execp->a_syms = 0;
+ if (adata (abfd).magic == undecided_magic)
+ NAME (aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
+ execp->a_syms = 0;
- execp->a_entry = bfd_get_start_address (abfd);
+ execp->a_entry = bfd_get_start_address (abfd);
- execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
- obj_reloc_entry_size (abfd));
- execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
- obj_reloc_entry_size (abfd));
+ execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
+ obj_reloc_entry_size (abfd));
+ execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
+ obj_reloc_entry_size (abfd));
- N_SET_MACHTYPE(*execp, 0xc);
- N_SET_FLAGS (*execp, 0x2);
+ N_SET_MACHTYPE (*execp, 0xc);
+ 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 */
+ /* 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);
+ /* 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
+ /* 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)
- {
- /* Skip the relocs to where we want to put the symbols. */
- if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
- SEEK_SET) != 0)
- return false;
- }
-
- if (! MY(write_syms) (abfd))
- return false;
-
- if (bfd_get_symcount (abfd) != 0)
- {
- bfd_seek (abfd, (long)(N_TRELOFF(*execp)), false);
+ if (bfd_get_symcount (abfd) != 0)
+ {
+ /* Skip the relocs to where we want to put the symbols. */
+ if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp) + execp->a_drsize,
+ SEEK_SET) != 0)
+ return false;
+ }
- if (!NAME(aout,squirt_out_relocs) (abfd, obj_textsec (abfd))) return false;
- bfd_seek (abfd, (long)(N_DRELOFF(*execp)), false);
+ if (!MY (write_syms) (abfd))
+ return false;
- if (!NAME(aout,squirt_out_relocs)(abfd, obj_datasec (abfd))) return false;
+ if (bfd_get_symcount (abfd) != 0)
+ {
+ if (bfd_seek (abfd, (long) (N_TRELOFF (*execp)), false) != 0)
+ return false;
+ 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;
}
- return true;
-}
+ return true;
+}
/* convert the hp symbol type to be the same as aout64.h usage so we */
/* can piggyback routines in aoutx.h. */
static void
-DEFUN(convert_sym_type,(sym_pointer, cache_ptr, abfd),
- struct external_nlist *sym_pointer AND
- aout_symbol_type *cache_ptr AND
- bfd *abfd)
+convert_sym_type (sym_pointer, cache_ptr, abfd)
+ struct external_nlist *sym_pointer;
+ aout_symbol_type *cache_ptr;
+ bfd *abfd;
{
- int name_type;
- int new_type;
+ int name_type;
+ int new_type;
- name_type = (cache_ptr->type);
- new_type = 0;
+ name_type = (cache_ptr->type);
+ new_type = 0;
- if ((name_type & HP_SYMTYPE_ALIGN) != 0)
+ if ((name_type & HP_SYMTYPE_ALIGN) != 0)
{
- /* iou_error ("aligned symbol encountered: %s", name);*/
- name_type = 0;
+ /* iou_error ("aligned symbol encountered: %s", name);*/
+ name_type = 0;
}
- if (name_type == HP_SYMTYPE_FILENAME)
- new_type = N_FN;
- else
- {
- switch (name_type & HP_SYMTYPE_TYPE)
- {
- case HP_SYMTYPE_UNDEFINED:
- new_type = N_UNDF;
- break;
-
- case HP_SYMTYPE_ABSOLUTE:
- new_type = N_ABS;
- break;
-
- case HP_SYMTYPE_TEXT:
- new_type = N_TEXT;
- break;
-
- case HP_SYMTYPE_DATA:
- new_type = N_DATA;
- break;
-
- case HP_SYMTYPE_BSS:
- new_type = N_BSS;
- break;
-
- case HP_SYMTYPE_COMMON:
- new_type = N_COMM;
- break;
-
- default:
- fprintf (stderr, "unknown symbol type encountered: %x", name_type);
- }
- if (name_type & HP_SYMTYPE_EXTERNAL)
- new_type |= N_EXT;
-
- if (name_type & HP_SECONDARY_SYMBOL)
- new_type = (new_type & ~N_TYPE) | N_INDR;
- }
- cache_ptr->type = new_type;
+ if (name_type == HP_SYMTYPE_FILENAME)
+ new_type = N_FN;
+ else
+ {
+ switch (name_type & HP_SYMTYPE_TYPE)
+ {
+ case HP_SYMTYPE_UNDEFINED:
+ new_type = N_UNDF;
+ break;
+
+ case HP_SYMTYPE_ABSOLUTE:
+ new_type = N_ABS;
+ break;
+
+ case HP_SYMTYPE_TEXT:
+ new_type = N_TEXT;
+ break;
+
+ case HP_SYMTYPE_DATA:
+ new_type = N_DATA;
+ break;
+
+ case HP_SYMTYPE_BSS:
+ new_type = N_BSS;
+ break;
+
+ case HP_SYMTYPE_COMMON:
+ new_type = N_COMM;
+ break;
+
+ default:
+ fprintf (stderr, "unknown symbol type encountered: %x", name_type);
+ }
+ if (name_type & HP_SYMTYPE_EXTERNAL)
+ new_type |= N_EXT;
+
+ if (name_type & HP_SECONDARY_SYMBOL)
+ new_type = (new_type & ~N_TYPE) | N_INDR;
+ }
+ cache_ptr->type = new_type;
}
*/
void
-DEFUN(NAME(aout,swap_exec_header_in),(abfd, raw_bytes, execp),
- bfd *abfd AND
- struct external_exec *raw_bytes AND
- struct internal_exec *execp)
+NAME (aout,swap_exec_header_in) (abfd, raw_bytes, execp)
+ bfd *abfd;
+ struct external_exec *raw_bytes;
+ struct internal_exec *execp;
{
- struct external_exec *bytes = (struct external_exec *)raw_bytes;
+ struct external_exec *bytes = (struct external_exec *) raw_bytes;
/* The internal_exec structure has some fields that are unused in this
configuration (IE for i960), so ensure that all such uninitialized
are memcmp'd, and thus the contents do matter. */
memset (execp, 0, sizeof (struct internal_exec));
/* Now fill in fields in the execp, from the bytes in the raw data. */
- execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
- execp->a_text = GET_WORD (abfd, bytes->e_text);
- execp->a_data = GET_WORD (abfd, bytes->e_data);
- execp->a_bss = GET_WORD (abfd, bytes->e_bss);
- execp->a_syms = GET_WORD (abfd, bytes->e_syms);
- execp->a_entry = GET_WORD (abfd, bytes->e_entry);
+ execp->a_info = bfd_h_get_32 (abfd, bytes->e_info);
+ execp->a_text = GET_WORD (abfd, bytes->e_text);
+ execp->a_data = GET_WORD (abfd, bytes->e_data);
+ execp->a_bss = GET_WORD (abfd, bytes->e_bss);
+ execp->a_syms = GET_WORD (abfd, bytes->e_syms);
+ execp->a_entry = GET_WORD (abfd, bytes->e_entry);
execp->a_trsize = GET_WORD (abfd, bytes->e_trsize);
execp->a_drsize = GET_WORD (abfd, bytes->e_drsize);
/* to be set. */
/***************************************************************/
do
- {
+ {
long syms;
- struct aout_data_struct *rawptr;
- if (bfd_h_get_32 (abfd, bytes->e_passize) != 0) break;
- if (bfd_h_get_32 (abfd, bytes->e_syms) != 0) break;
- if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0) break;
+ struct aout_data_struct *rawptr;
+ if (bfd_h_get_32 (abfd, bytes->e_passize) != 0)
+ break;
+ if (bfd_h_get_32 (abfd, bytes->e_syms) != 0)
+ break;
+ if (bfd_h_get_32 (abfd, bytes->e_supsize) != 0)
+ break;
syms = bfd_h_get_32 (abfd, bytes->e_drelocs);
- if (syms == 0) break;
+ if (syms == 0)
+ break;
/* OK, we've passed the test as best as we can determine */
execp->a_syms = syms;
/* allocate storage for where we will store this result */
- rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
+ rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, sizeof (*rawptr));
- if (rawptr == NULL) {
- bfd_error = no_memory;
- return;
- }
+ if (rawptr == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return;
+ }
abfd->tdata.aout_data = rawptr;
- obj_aout_subformat(abfd) = gnu_encap_format;
- } while (0);
+ obj_aout_subformat (abfd) = gnu_encap_format;
+ }
+ while (0);
}
*/
boolean
-DEFUN(MY(slurp_symbol_table),(abfd),
- bfd *abfd)
+MY (slurp_symbol_table) (abfd)
+ bfd *abfd;
{
bfd_size_type symbol_bytes;
struct external_nlist *syms;
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_error = no_symbols;
- return false;
- }
+ 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);
+ strings = (char *) bfd_alloc (abfd,
+ symbol_bytes + SYM_EXTRA_BYTES);
if (!strings)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
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;
- }
+ }
- sym_end = (struct external_nlist *) (((char *)syms) + symbol_bytes);
+ sym_end = (struct external_nlist *) (((char *) syms) + symbol_bytes);
/* 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++;
+ {
+ 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]);
- }
+ 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 + num_secondary;
cached = (aout_symbol_type *)
- bfd_zalloc(abfd, (bfd_size_type)(bfd_get_symcount (abfd) *
- sizeof(aout_symbol_type)));
+ bfd_zalloc (abfd, (bfd_size_type) (bfd_get_symcount (abfd) *
+ sizeof (aout_symbol_type)));
if (!cached)
{
- bfd_error = no_memory;
+ bfd_set_error (bfd_error_no_memory);
return false;
}
num_secondary = 0;
/* OK, now walk the new symtable, cacheing symbol properties */
- {
- aout_symbol_type *cache_ptr = cached;
- aout_symbol_type cache_save;
- /* Run through table and copy values */
- for (sym_pointer = syms, cache_ptr = cached;
- sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+ {
+ aout_symbol_type *cache_ptr = cached;
+ aout_symbol_type cache_save;
+ /* Run through table and copy values */
+ for (sym_pointer = syms, cache_ptr = cached;
+ sym_pointer < sym_end; sym_pointer++, cache_ptr++)
+ {
+ unsigned int length;
+ cache_ptr->symbol.the_bfd = abfd;
+ 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;
+ 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 (abfd, cache_ptr))
+ return false;
+
+ /********************************************************/
+ /* for hpux, the 'lenght' value indicates the length of */
+ /* the symbol name which follows the nlist entry. */
+ /********************************************************/
+ if (length)
{
- unsigned int length;
- cache_ptr->symbol.the_bfd = abfd;
- 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;
- 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))
+ /**************************************************************/
+ /* the hp string is not null terminated so we create a new one*/
+ /* by copying the string to overlap the just vacated nlist */
+ /* structure before it in memory. */
+ /**************************************************************/
+ cache_ptr->symbol.name = strings;
+ memcpy (strings, sym_pointer + 1, length);
+ strings[length] = '\0';
+ strings += length + 1;
+ }
+ 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 (abfd, cache_ptr2))
return false;
-
- /********************************************************/
- /* for hpux, the 'lenght' value indicates the length of */
- /* the symbol name which follows the nlist entry. */
- /********************************************************/
- if (length)
- {
- /**************************************************************/
- /* the hp string is not null terminated so we create a new one*/
- /* by copying the string to overlap the just vacated nlist */
- /* structure before it in memory. */
- /**************************************************************/
- cache_ptr->symbol.name = strings;
- memcpy(strings, sym_pointer+1, length);
- strings[length] = '\0';
- strings += length + 1;
- }
- 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);
}
- }
- obj_aout_symbols (abfd) = cached;
+ /* skip over the embedded symbol. */
+ sym_pointer = (struct external_nlist *) (((char *) sym_pointer) +
+ length);
+ }
+ }
+
+ obj_aout_symbols (abfd) = cached;
return true;
}
void
-DEFUN(MY(swap_std_reloc_in), (abfd, bytes, cache_ptr, symbols),
- bfd *abfd AND
- struct hp300hpux_reloc *bytes AND
- arelent *cache_ptr AND
- asymbol **symbols)
+MY (swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols)
+ bfd *abfd;
+ struct hp300hpux_reloc *bytes;
+ arelent *cache_ptr;
+ asymbol **symbols;
{
int r_index;
int r_extern = 0;
unsigned int r_length;
int r_pcrel = 0;
- struct aoutdata *su = &(abfd->tdata.aout_data->a);
+ struct aoutdata *su = &(abfd->tdata.aout_data->a);
cache_ptr->address = bfd_h_get_32 (abfd, bytes->r_address);
- r_index = bfd_h_get_16(abfd, bytes->r_index);
+ r_index = bfd_h_get_16 (abfd, bytes->r_index);
switch (bytes->r_type[0])
- {
- case HP_RSEGMENT_TEXT:
+ {
+ case HP_RSEGMENT_TEXT:
r_index = N_TEXT;
break;
- case HP_RSEGMENT_DATA:
+ case HP_RSEGMENT_DATA:
r_index = N_DATA;
break;
- case HP_RSEGMENT_BSS:
+ case HP_RSEGMENT_BSS:
r_index = N_BSS;
break;
- case HP_RSEGMENT_EXTERNAL:
+ case HP_RSEGMENT_EXTERNAL:
r_extern = 1;
break;
- case HP_RSEGMENT_PCREL:
+ case HP_RSEGMENT_PCREL:
r_extern = 1;
r_pcrel = 1;
break;
- case HP_RSEGMENT_RDLT:
+ case HP_RSEGMENT_RDLT:
break;
- case HP_RSEGMENT_RPLT:
+ case HP_RSEGMENT_RPLT:
break;
- case HP_RSEGMENT_NOOP:
+ case HP_RSEGMENT_NOOP:
break;
- default:
+ default:
fprintf (stderr, "illegal relocation segment type: %x\n",
(bytes->r_type[0]));
- }
+ }
switch (bytes->r_length[0])
{
r_length = 2;
break;
default:
- fprintf (stderr, "illegal relocation length: %x\n",bytes->r_length[0] );
+ fprintf (stderr, "illegal relocation length: %x\n", bytes->r_length[0]);
r_length = 0;
}
- cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
+ cache_ptr->howto = howto_table_std + r_length + 4 * r_pcrel;
/* FIXME-soon: Roll baserel, jmptable, relative bits into howto setting */
/* This macro uses the r_index value computed above */
if (r_pcrel && r_extern)
- {
- /* The GNU linker assumes any offset from beginning of section */
- /* is already incorporated into the image while the HP linker */
- /* adds this in later. Add it in now... */
- MOVE_ADDRESS( - cache_ptr->address);
- }
+ {
+ /* The GNU linker assumes any offset from beginning of section */
+ /* is already incorporated into the image while the HP linker */
+ /* adds this in later. Add it in now... */
+ MOVE_ADDRESS (-cache_ptr->address);
+ }
else
- {
- MOVE_ADDRESS(0);
- }
+ {
+ MOVE_ADDRESS (0);
+ }
}
boolean
-DEFUN(MY(slurp_reloc_table),(abfd, asect, symbols),
- bfd *abfd AND
- sec_ptr asect AND
- asymbol **symbols)
+MY (slurp_reloc_table) (abfd, asect, symbols)
+ bfd *abfd;
+ sec_ptr asect;
+ asymbol **symbols;
{
unsigned int count;
bfd_size_type reloc_size;
unsigned int counter;
arelent *cache_ptr;
- if (asect->relocation) return true;
+ if (asect->relocation)
+ return true;
- if (asect->flags & SEC_CONSTRUCTOR) return true;
+ if (asect->flags & SEC_CONSTRUCTOR)
+ return true;
- if (asect == obj_datasec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_drsize;
- goto doit;
- }
+ if (asect == obj_datasec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_drsize;
+ goto doit;
+ }
- if (asect == obj_textsec (abfd)) {
- reloc_size = exec_hdr(abfd)->a_trsize;
- goto doit;
- }
+ if (asect == obj_textsec (abfd))
+ {
+ reloc_size = exec_hdr (abfd)->a_trsize;
+ goto doit;
+ }
- bfd_error = invalid_operation;
+ bfd_set_error (bfd_error_invalid_operation);
return false;
- doit:
- bfd_seek (abfd, asect->rel_filepos, SEEK_SET);
+doit:
+ 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_error = no_memory;
- return false;
- }
+ reloc_cache = (arelent *) bfd_zalloc (abfd, (size_t) (count * sizeof
+ (arelent)));
+ if (!reloc_cache && count != 0)
+ {
+ nomem:
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
relocs = (PTR) bfd_alloc (abfd, reloc_size);
- if (!relocs) {
- bfd_release (abfd, reloc_cache);
- goto nomem;
- }
+ if (!relocs && reloc_size != 0)
+ {
+ bfd_release (abfd, reloc_cache);
+ goto nomem;
+ }
- if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size) {
- bfd_release (abfd, relocs);
- bfd_release (abfd, reloc_cache);
- bfd_error = system_call_error;
- return false;
- }
+ if (bfd_read (relocs, 1, reloc_size, abfd) != reloc_size)
+ {
+ bfd_release (abfd, relocs);
+ bfd_release (abfd, reloc_cache);
+ return false;
+ }
- rptr = (struct hp300hpux_reloc*) relocs;
- counter = 0;
- cache_ptr = reloc_cache;
+ rptr = (struct hp300hpux_reloc *) relocs;
+ counter = 0;
+ cache_ptr = reloc_cache;
- for (; counter < count; counter++, rptr++, cache_ptr++) {
- MY(swap_std_reloc_in)(abfd, rptr, cache_ptr, symbols);
+ for (; counter < count; counter++, rptr++, cache_ptr++)
+ {
+ MY (swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols);
}
- bfd_release (abfd,relocs);
+ bfd_release (abfd, relocs);
asect->relocation = reloc_cache;
asect->reloc_count = count;
return true;
/* 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
-DEFUN(MY(get_symtab),(abfd, location),
- bfd *abfd AND
- asymbol **location)
+long
+MY (get_symtab) (abfd, location)
+ bfd *abfd;
+ asymbol **location;
{
- unsigned int counter = 0;
- aout_symbol_type *symbase;
+ unsigned int counter = 0;
+ aout_symbol_type *symbase;
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- return aout_32_get_symtab(abfd,location);
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_get_symtab (abfd, location);
- if (!MY(slurp_symbol_table)(abfd)) return 0;
+ if (!MY (slurp_symbol_table) (abfd))
+ return -1;
- for (symbase = obj_aout_symbols(abfd); counter++ < bfd_get_symcount (abfd);)
- *(location++) = (asymbol *)( symbase++);
- *location++ =0;
- return bfd_get_symcount (abfd);
+ for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
+ *(location++) = (asymbol *) (symbase++);
+ *location++ = 0;
+ return bfd_get_symcount (abfd);
}
- unsigned int
-DEFUN(MY(get_symtab_upper_bound),(abfd),
- bfd *abfd)
+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;
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_get_symtab_upper_bound (abfd);
+ if (!MY (slurp_symbol_table) (abfd))
+ return -1;
- return (bfd_get_symcount (abfd)+1) * (sizeof (aout_symbol_type *));
+ return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
}
-unsigned int
-DEFUN(MY(canonicalize_reloc),(abfd, section, relptr, symbols),
- bfd *abfd AND
- sec_ptr section AND
- arelent **relptr AND
- asymbol **symbols)
+long
+MY (canonicalize_reloc) (abfd, section, relptr, symbols)
+ bfd *abfd;
+ sec_ptr section;
+ arelent **relptr;
+ asymbol **symbols;
{
arelent *tblptr = section->relocation;
unsigned int count;
- if (obj_aout_subformat(abfd) == gnu_encap_format)
- return aout_32_canonicalize_reloc(abfd,section,relptr,symbols);
+ if (obj_aout_subformat (abfd) == gnu_encap_format)
+ return aout_32_canonicalize_reloc (abfd, section, relptr, symbols);
- if (!(tblptr || MY(slurp_reloc_table)(abfd, section, symbols)))
- return 0;
+ if (!(tblptr || MY (slurp_reloc_table) (abfd, section, symbols)))
+ return -1;
- if (section->flags & SEC_CONSTRUCTOR) {
- arelent_chain *chain = section->constructor_chain;
- for (count = 0; count < section->reloc_count; count ++) {
- *relptr ++ = &chain->relent;
- chain = chain->next;
+ if (section->flags & SEC_CONSTRUCTOR)
+ {
+ arelent_chain *chain = section->constructor_chain;
+ for (count = 0; count < section->reloc_count; count++)
+ {
+ *relptr++ = &chain->relent;
+ chain = chain->next;
+ }
}
- }
- else {
- tblptr = section->relocation;
- if (!tblptr) return 0;
+ else
+ {
+ tblptr = section->relocation;
- for (count = 0; count++ < section->reloc_count;)
- {
- *relptr++ = tblptr++;
- }
- }
+ for (count = 0; count++ < section->reloc_count;)
+ {
+ *relptr++ = tblptr++;
+ }
+ }
*relptr = 0;
return section->reloc_count;
projects / deliverable / binutils-gdb.git / blobdiff