/* BFD back-end for Intel 960 b.out binaries.
- Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
Written by Cygnus Support.
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. */
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "bfdlink.h"
+#include "genlink.h"
#include "bout.h"
#include "aout/stab_gnu.h"
#include "libaout.h" /* BFD a.out internal data structures */
+static int aligncode PARAMS ((bfd *abfd, asection *input_section,
+ arelent *r, unsigned int shrink));
+static void perform_slip PARAMS ((bfd *abfd, unsigned int slip,
+ asection *input_section, bfd_vma value));
static boolean b_out_squirt_out_relocs PARAMS ((bfd *abfd, asection *section));
-static bfd_target *b_out_callback PARAMS ((bfd *));
+static const bfd_target *b_out_callback PARAMS ((bfd *));
static bfd_reloc_status_type calljx_callback
PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR src, PTR dst,
asection *));
static bfd_reloc_status_type callj_callback
PARAMS ((bfd *, struct bfd_link_info *, arelent *, PTR data,
- unsigned int srcidx, unsigned int dstidx, asection *));
+ unsigned int srcidx, unsigned int dstidx, asection *, boolean));
static bfd_vma get_value PARAMS ((arelent *, struct bfd_link_info *,
asection *));
-static int abs32code PARAMS ((asection *, asymbol **, arelent *,
+static int abs32code PARAMS ((bfd *, asection *, arelent *,
unsigned int, struct bfd_link_info *));
-static boolean b_out_relax_section PARAMS ((bfd *, asection *,
- struct bfd_link_info *,
- asymbol **symbols));
-static bfd_byte *b_out_get_relocated_section_contents
+static boolean b_out_bfd_relax_section PARAMS ((bfd *, asection *,
+ struct bfd_link_info *,
+ boolean *));
+static bfd_byte *b_out_bfd_get_relocated_section_contents
PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
bfd_byte *, boolean, asymbol **));
stream memory image, into the internal exec_header structure. */
void
-DEFUN(bout_swap_exec_header_in,(abfd, raw_bytes, execp),
- bfd *abfd AND
- struct external_exec *raw_bytes AND
- struct internal_exec *execp)
+bout_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 internal_exec *execp,
struct external_exec *raw_bytes));
void
-DEFUN(bout_swap_exec_header_out,(abfd, execp, raw_bytes),
- bfd *abfd AND
- struct internal_exec *execp AND
- struct external_exec *raw_bytes)
+bout_swap_exec_header_out (abfd, execp, raw_bytes)
+ bfd *abfd;
+ struct internal_exec *execp;
+ struct external_exec *raw_bytes;
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
}
-static bfd_target *
+static const bfd_target *
b_out_object_p (abfd)
bfd *abfd;
{
if (bfd_read ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd)
!= EXEC_BYTES_SIZE) {
- bfd_set_error (bfd_error_wrong_format);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
/* Finish up the opening of a b.out file for reading. Fill in all the
fields that are not handled by common code. */
-static bfd_target *
+static const bfd_target *
b_out_callback (abfd)
bfd *abfd;
{
abfd->tdata.bout_data = rawptr;
exec_hdr (abfd) = &rawptr->e;
- /* For simplicity's sake we just make all the sections right here. */
obj_textsec (abfd) = (asection *)NULL;
obj_datasec (abfd) = (asection *)NULL;
obj_bsssec (abfd) = (asection *)NULL;
- bfd_make_section (abfd, ".text");
- bfd_make_section (abfd, ".data");
- bfd_make_section (abfd, ".bss");
-
return true;
}
{
struct external_exec swapped_hdr;
+ if (! aout_32_make_sections (abfd))
+ return false;
+
exec_hdr (abfd)->a_info = BMAGIC;
exec_hdr (abfd)->a_text = obj_textsec (abfd)->_raw_size;
bout_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
- bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
- bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd);
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
+ || (bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd)
+ != EXEC_BYTES_SIZE))
+ return false;
/* Now write out reloc info, followed by syms and strings */
if (bfd_get_symcount (abfd) != 0)
{
- bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET);
+ if (bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET)
+ != 0)
+ return false;
if (! aout_32_write_syms (abfd))
return false;
- bfd_seek (abfd, (file_ptr)(N_TROFF(*exec_hdr(abfd))), SEEK_SET);
+ if (bfd_seek (abfd, (file_ptr)(N_TROFF(*exec_hdr(abfd))), SEEK_SET) != 0)
+ return false;
if (!b_out_squirt_out_relocs (abfd, obj_textsec (abfd))) return false;
- bfd_seek (abfd, (file_ptr)(N_DROFF(*exec_hdr(abfd))), SEEK_SET);
+ if (bfd_seek (abfd, (file_ptr)(N_DROFF(*exec_hdr(abfd))), SEEK_SET)
+ != 0)
+ return false;
if (!b_out_squirt_out_relocs (abfd, obj_datasec (abfd))) return false;
}
/* Magic to turn call into callj */
static bfd_reloc_status_type
callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx,
- input_section)
+ input_section, shrinking)
bfd *abfd;
struct bfd_link_info *link_info;
arelent *reloc_entry;
unsigned int srcidx;
unsigned int dstidx;
asection *input_section;
+ boolean shrinking;
{
int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
- output_addr (input_section))
& BAL_MASK);
}
+ else if ((symbol->symbol.flags & BSF_SECTION_SYM) != 0)
+ {
+ /* A callj against a symbol in the same section is a fully
+ resolved relative call. We don't need to do anything here.
+ If the symbol is not in the same section, I'm not sure what
+ to do; fortunately, this case will probably never arise. */
+ BFD_ASSERT (! shrinking);
+ BFD_ASSERT (symbol->symbol.section == input_section);
+ }
else
{
word = CALL | (((word & BAL_MASK)
+ value
+ reloc_entry->addend
- - dstidx
+ - (shrinking ? dstidx : 0)
- output_addr (input_section))
& BAL_MASK);
}
HOWTO (ALIGNDONE, 0xf, 0xf, 0, false, 0, complain_overflow_dont, 0, "donealign128", false, 0, 0, false),
};
-static const reloc_howto_type *
-b_out_reloc_type_lookup (abfd, code)
+static reloc_howto_type *
+b_out_bfd_reloc_type_lookup (abfd, code)
bfd *abfd;
bfd_reloc_code_real_type code;
{
case BFD_RELOC_I960_CALLJ:
return &howto_reloc_callj;
case BFD_RELOC_32:
+ case BFD_RELOC_CTOR:
return &howto_reloc_abs32;
case BFD_RELOC_24_PCREL:
return &howto_reloc_pcrel24;
struct relocation_info *relocs;
arelent *reloc_cache;
- if (asect->relocation) return true;
- if (!aout_32_slurp_symbol_table (abfd)) return false;
+ if (asect->relocation)
+ return true;
+ if (!aout_32_slurp_symbol_table (abfd))
+ return false;
if (asect == obj_datasec (abfd)) {
reloc_size = exec_hdr(abfd)->a_drsize;
goto doit;
}
+ if (asect == obj_bsssec (abfd)) {
+ reloc_size = 0;
+ goto doit;
+ }
+
bfd_set_error (bfd_error_invalid_operation);
return false;
doit:
- bfd_seek (abfd, (file_ptr)(asect->rel_filepos), SEEK_SET);
+ if (bfd_seek (abfd, (file_ptr)(asect->rel_filepos), SEEK_SET) != 0)
+ return false;
count = reloc_size / sizeof (struct relocation_info);
relocs = (struct relocation_info *) malloc (reloc_size);
- if (!relocs) {
+ if (!relocs && reloc_size != 0) {
bfd_set_error (bfd_error_no_memory);
return false;
}
reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent));
if (!reloc_cache) {
- free ((char*)relocs);
+ if (relocs != NULL)
+ free ((char*)relocs);
bfd_set_error (bfd_error_no_memory);
return false;
}
if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) {
- bfd_set_error (bfd_error_system_call);
free (reloc_cache);
- free (relocs);
+ if (relocs != NULL)
+ free (relocs);
return false;
}
if (raw[7] & pcrel_mask)
{
cache_ptr->howto = &howto_align_table[(raw[7] >> length_shift) & 3];
- cache_ptr->sym_ptr_ptr = &bfd_abs_symbol;
+ cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
}
else
{
}
- free (relocs);
+ if (relocs != NULL)
+ free (relocs);
asect->relocation = reloc_cache;
asect->reloc_count = count;
if (count == 0) return true;
generic = section->orelocation;
native = ((struct relocation_info *) malloc (natsize));
- if (!native) {
+ if (!native && natsize != 0) {
bfd_set_error (bfd_error_no_memory);
return false;
}
if (r_idx != 0)
/* already mucked with r_extern, r_idx */;
else if (bfd_is_com_section (output_section)
- || output_section == &bfd_abs_section
- || output_section == &bfd_und_section)
+ || bfd_is_abs_section (output_section)
+ || bfd_is_und_section (output_section))
{
- if (bfd_abs_section.symbol == sym)
+ if (bfd_abs_section_ptr->symbol == sym)
{
/* Whoops, looked like an abs symbol, but is really an offset
from the abs section */
}
/* This is stupid. This function should be a boolean predicate */
-static unsigned int
+static long
b_out_canonicalize_reloc (abfd, section, relptr, symbols)
bfd *abfd;
sec_ptr section;
arelent **relptr;
asymbol **symbols;
{
- arelent *tblptr = section->relocation;
- unsigned int count = 0;
+ arelent *tblptr;
+ unsigned int count;
- if (!(tblptr || b_out_slurp_reloc_table (abfd, section, symbols))) return 0;
- tblptr = section->relocation;
- if (!tblptr) return 0;
+ if ((section->flags & SEC_CONSTRUCTOR) != 0)
+ {
+ arelent_chain *chain = section->constructor_chain;
+ for (count = 0; count < section->reloc_count; count++)
+ {
+ *relptr++ = &chain->relent;
+ chain = chain->next;
+ }
+ }
+ else
+ {
+ if (section->relocation == NULL
+ && ! b_out_slurp_reloc_table (abfd, section, symbols))
+ return -1;
- for (; count++ < section->reloc_count;)
- *relptr++ = tblptr++;
+ tblptr = section->relocation;
+ for (count = 0; count++ < section->reloc_count;)
+ *relptr++ = tblptr++;
+ }
- *relptr = 0;
+ *relptr = NULL;
return section->reloc_count;
}
-static unsigned int
+static long
b_out_get_reloc_upper_bound (abfd, asect)
bfd *abfd;
sec_ptr asect;
{
if (bfd_get_format (abfd) != bfd_object) {
bfd_set_error (bfd_error_invalid_operation);
- return 0;
+ return -1;
}
+ if (asect->flags & SEC_CONSTRUCTOR)
+ return sizeof (arelent *) * (asect->reloc_count + 1);
+
if (asect == obj_datasec (abfd))
return (sizeof (arelent *) *
((exec_hdr(abfd)->a_drsize / sizeof (struct relocation_info))
return 0;
bfd_set_error (bfd_error_invalid_operation);
- return 0;
+ return -1;
}
\f
static boolean
b_out_set_section_contents (abfd, section, location, offset, count)
bfd *abfd;
- sec_ptr section;
- unsigned char *location;
+ asection *section;
+ PTR location;
file_ptr offset;
- int count;
+ bfd_size_type count;
{
if (abfd->output_has_begun == false) { /* set by bfd.c handler */
- if ((obj_textsec (abfd) == NULL) || (obj_datasec (abfd) == NULL) /*||
- (obj_textsec (abfd)->_cooked_size == 0) || (obj_datasec (abfd)->_cooked_size == 0)*/) {
- bfd_set_error (bfd_error_invalid_operation);
+ if (! aout_32_make_sections (abfd))
return false;
- }
obj_textsec (abfd)->filepos = sizeof(struct internal_exec);
obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
}
/* regardless, once we know what we're doing, we might as well get going */
- bfd_seek (abfd, section->filepos + offset, SEEK_SET);
+ if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
+ return false;
if (count != 0) {
return (bfd_write ((PTR)location, 1, count, abfd) == count) ?true:false;
}
static int
-DEFUN(b_out_sizeof_headers,(ignore_abfd, ignore),
- bfd *ignore_abfd AND
- boolean ignore)
+b_out_sizeof_headers (ignore_abfd, ignore)
+ bfd *ignore_abfd;
+ boolean ignore;
{
return sizeof(struct internal_exec);
}
base of the section. To relocate, we find where the section will
live in the output and add that in */
- if (symbol->section == &bfd_und_section)
+ if (bfd_is_und_section (symbol->section))
{
struct bfd_link_hash_entry *h;
h = bfd_link_hash_lookup (link_info->hash, bfd_asymbol_name (symbol),
false, false, true);
if (h != (struct bfd_link_hash_entry *) NULL
- && h->type == bfd_link_hash_defined)
+ && (h->type == bfd_link_hash_defined
+ || h->type == bfd_link_hash_defweak))
value = h->u.def.value + output_addr (h->u.def.section);
else if (h != (struct bfd_link_hash_entry *) NULL
&& h->type == bfd_link_hash_common)
}
static void
-DEFUN(perform_slip,(s, slip, input_section, value),
- asymbol **s AND
- unsigned int slip AND
- asection *input_section AND
- bfd_vma value)
+perform_slip (abfd, slip, input_section, value)
+ bfd *abfd;
+ unsigned int slip;
+ asection *input_section;
+ bfd_vma value;
{
+ asymbol **s;
+
+ s = _bfd_generic_link_get_symbols (abfd);
+ BFD_ASSERT (s != (asymbol **) NULL);
/* Find all symbols past this point, and make them know
what's happened */
if (p->value > value)
{
p->value -=slip;
+ if (p->udata.p != NULL)
+ {
+ struct generic_link_hash_entry *h;
+
+ h = (struct generic_link_hash_entry *) p->udata.p;
+ BFD_ASSERT (h->root.type == bfd_link_hash_defined);
+ h->root.u.def.value -= slip;
+ BFD_ASSERT (h->root.u.def.value == p->value);
+ }
}
}
s++;
If it can, then it changes the amode */
static int
-abs32code (input_section, symbols, r, shrink, link_info)
+abs32code (abfd, input_section, r, shrink, link_info)
+ bfd *abfd;
asection *input_section;
- asymbol **symbols;
arelent *r;
unsigned int shrink;
struct bfd_link_info *link_info;
/* This will be four bytes smaller in the long run */
shrink += 4 ;
- perform_slip(symbols, 4, input_section, r->address-shrink +4);
+ perform_slip (abfd, 4, input_section, r->address-shrink + 4);
}
return shrink;
}
static int
-DEFUN(aligncode,(input_section, symbols, r, shrink),
- asection *input_section AND
- asymbol **symbols AND
- arelent *r AND
- unsigned int shrink)
+aligncode (abfd, input_section, r, shrink)
+ bfd *abfd;
+ asection *input_section;
+ arelent *r;
+ unsigned int shrink;
{
bfd_vma dot = output_addr (input_section) + r->address;
bfd_vma gap;
r->addend = old_end - dot + r->address;
/* This will be N bytes smaller in the long run, adjust all the symbols */
- perform_slip(symbols, shrink_delta, input_section, r->address - shrink );
+ perform_slip (abfd, shrink_delta, input_section, r->address - shrink);
shrink += shrink_delta;
}
return shrink;
}
static boolean
-b_out_relax_section (abfd, i, link_info, symbols)
+b_out_bfd_relax_section (abfd, i, link_info, again)
bfd *abfd;
asection *i;
struct bfd_link_info *link_info;
- asymbol **symbols;
+ boolean *again;
{
-
/* Get enough memory to hold the stuff */
bfd *input_bfd = i->owner;
asection *input_section = i;
int shrink = 0 ;
- boolean new = false;
arelent **reloc_vector = NULL;
+ long reloc_size = bfd_get_reloc_upper_bound(input_bfd,
+ input_section);
- bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
- input_section);
+ if (reloc_size < 0)
+ return false;
+
+ /* We only run this relaxation once. It might work to run it
+ multiple times, but it hasn't been tested. */
+ *again = false;
if (reloc_size)
{
+ long reloc_count;
+
reloc_vector = (arelent **) malloc (reloc_size);
- if (reloc_vector == NULL)
+ if (reloc_vector == NULL && reloc_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
}
/* Get the relocs and think about them */
- if (bfd_canonicalize_reloc(input_bfd, input_section, reloc_vector,
- symbols))
+ reloc_count =
+ bfd_canonicalize_reloc (input_bfd, input_section, reloc_vector,
+ _bfd_generic_link_get_symbols (input_bfd));
+ if (reloc_count < 0)
+ goto error_return;
+ if (reloc_count > 0)
{
arelent **parent;
for (parent = reloc_vector; *parent; parent++)
{
case ALIGNER:
/* An alignment reloc */
- shrink = aligncode(input_section, symbols, r,shrink);
- new=true;
+ shrink = aligncode (abfd, input_section, r, shrink);
break;
case ABS32CODE:
/* A 32bit reloc in an addressing mode */
- shrink = abs32code (input_section, symbols, r, shrink, link_info);
- new=true;
+ shrink = abs32code (input_bfd, input_section, r, shrink,
+ link_info);
break;
case ABS32CODE_SHRUNK:
shrink+=4;
if (reloc_vector != NULL)
free (reloc_vector);
- return new;
+ return true;
error_return:
if (reloc_vector != NULL)
free (reloc_vector);
}
static bfd_byte *
-b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data,
- relocateable, symbols)
+b_out_bfd_get_relocated_section_contents (in_abfd, link_info, link_order,
+ data, relocateable, symbols)
bfd *in_abfd;
struct bfd_link_info *link_info;
struct bfd_link_order *link_order;
/* Get enough memory to hold the stuff */
bfd *input_bfd = link_order->u.indirect.section->owner;
asection *input_section = link_order->u.indirect.section;
- bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
- input_section);
+ long reloc_size = bfd_get_reloc_upper_bound(input_bfd,
+ input_section);
arelent **reloc_vector = NULL;
+ long reloc_count;
+
+ if (reloc_size < 0)
+ goto error_return;
/* If producing relocateable output, don't bother to relax. */
if (relocateable)
symbols);
reloc_vector = (arelent **) malloc (reloc_size);
- if (reloc_vector == NULL)
+ if (reloc_vector == NULL && reloc_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
0,
input_section->_raw_size));
- if (bfd_canonicalize_reloc(input_bfd,
- input_section,
- reloc_vector,
- symbols) )
+ reloc_count = bfd_canonicalize_reloc (input_bfd,
+ input_section,
+ reloc_vector,
+ symbols);
+ if (reloc_count < 0)
+ goto error_return;
+ if (reloc_count > 0)
{
arelent **parent = reloc_vector;
arelent *reloc ;
break;
case CALLJ:
callj_callback (in_abfd, link_info, reloc, data, src_address,
- dst_address, input_section);
+ dst_address, input_section, false);
src_address+=4;
dst_address+=4;
break;
/* This used to be a callx, but we've found out that a
callj will reach, so do the right thing. */
callj_callback (in_abfd, link_info, reloc, data,
- src_address + 4, dst_address, input_section);
+ src_address + 4, dst_address, input_section,
+ true);
dst_address+=4;
src_address+=8;
break;
/* Build the transfer vectors for Big and Little-Endian B.OUT files. */
-/* We don't have core files. */
-#define aout_32_core_file_failing_command _bfd_dummy_core_file_failing_command
-#define aout_32_core_file_failing_signal _bfd_dummy_core_file_failing_signal
-#define aout_32_core_file_matches_executable_p \
- _bfd_dummy_core_file_matches_executable_p
-
-/* We use BSD-Unix generic archive files. */
-#define aout_32_openr_next_archived_file bfd_generic_openr_next_archived_file
-#define aout_32_generic_stat_arch_elt bfd_generic_stat_arch_elt
-#define aout_32_slurp_armap bfd_slurp_bsd_armap
-#define aout_32_slurp_extended_name_table _bfd_slurp_extended_name_table
-#define aout_32_write_armap bsd_write_armap
-#define aout_32_truncate_arname bfd_bsd_truncate_arname
-
-/* We override these routines from the usual a.out file routines. */
-#define aout_32_canonicalize_reloc b_out_canonicalize_reloc
-#define aout_32_get_reloc_upper_bound b_out_get_reloc_upper_bound
-#define aout_32_set_section_contents b_out_set_section_contents
-#define aout_32_set_arch_mach b_out_set_arch_mach
-#define aout_32_sizeof_headers b_out_sizeof_headers
-
-#define aout_32_bfd_debug_info_start bfd_void
-#define aout_32_bfd_debug_info_end bfd_void
-#define aout_32_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
-
-#define aout_32_bfd_get_relocated_section_contents b_out_get_relocated_section_contents
-#define aout_32_bfd_relax_section b_out_relax_section
-#define aout_32_bfd_reloc_type_lookup b_out_reloc_type_lookup
-#define aout_32_bfd_make_debug_symbol \
- ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
-#define aout_32_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
-#define aout_32_bfd_link_add_symbols _bfd_generic_link_add_symbols
-#define aout_32_bfd_final_link _bfd_generic_final_link
-
-bfd_target b_out_vec_big_host =
+#define aout_32_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
+#define aout_32_close_and_cleanup aout_32_bfd_free_cached_info
+
+#define b_out_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
+#define b_out_bfd_link_add_symbols _bfd_generic_link_add_symbols
+#define b_out_bfd_final_link _bfd_generic_final_link
+#define b_out_bfd_link_split_section _bfd_generic_link_split_section
+
+
+const bfd_target b_out_vec_big_host =
{
"b.out.big", /* name */
bfd_target_aout_flavour,
{bfd_false, b_out_write_object_contents, /* bfd_write_contents */
_bfd_write_archive_contents, bfd_false},
- JUMP_TABLE(aout_32),
+ BFD_JUMP_TABLE_GENERIC (aout_32),
+ BFD_JUMP_TABLE_COPY (_bfd_generic),
+ BFD_JUMP_TABLE_CORE (_bfd_nocore),
+ BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
+ BFD_JUMP_TABLE_SYMBOLS (aout_32),
+ BFD_JUMP_TABLE_RELOCS (b_out),
+ BFD_JUMP_TABLE_WRITE (b_out),
+ BFD_JUMP_TABLE_LINK (b_out),
+ BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
(PTR) 0,
};
-bfd_target b_out_vec_little_host =
+const bfd_target b_out_vec_little_host =
{
"b.out.little", /* name */
bfd_target_aout_flavour,
_bfd_generic_mkarchive, bfd_false},
{bfd_false, b_out_write_object_contents, /* bfd_write_contents */
_bfd_write_archive_contents, bfd_false},
- JUMP_TABLE(aout_32),
+
+ BFD_JUMP_TABLE_GENERIC (aout_32),
+ BFD_JUMP_TABLE_COPY (_bfd_generic),
+ BFD_JUMP_TABLE_CORE (_bfd_nocore),
+ BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_bsd),
+ BFD_JUMP_TABLE_SYMBOLS (aout_32),
+ BFD_JUMP_TABLE_RELOCS (b_out),
+ BFD_JUMP_TABLE_WRITE (b_out),
+ BFD_JUMP_TABLE_LINK (b_out),
+ BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+
(PTR) 0
};
projects / binutils.git / blobdiff