X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fbout.c;h=4ef10f52057e6f3345759bb1ed3a60f4ae41ba21;hb=8066d1a2839e6eb0b1b5cddde033311ec887a486;hp=a0ef5ef7abb0e12b8806228c27bf8af2863ab07f;hpb=5c8444f8f80fee5a32dfecbc0e408640c57c6809;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/bout.c b/bfd/bout.c index a0ef5ef7ab..4ef10f5205 100644 --- a/bfd/bout.c +++ b/bfd/bout.c @@ -1,5 +1,5 @@ /* BFD back-end for Intel 960 b.out binaries. - Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. + Copyright 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc. Written by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -16,7 +16,7 @@ GNU General Public License for more details. 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" @@ -35,21 +35,21 @@ static int aligncode PARAMS ((bfd *abfd, asection *input_section, 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 ((bfd *, asection *, arelent *, unsigned int, struct bfd_link_info *)); -static boolean b_out_relax_section PARAMS ((bfd *, asection *, - struct bfd_link_info *, - boolean *)); -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 **)); @@ -114,7 +114,7 @@ bout_swap_exec_header_out (abfd, execp, raw_bytes) } -static bfd_target * +static const bfd_target * b_out_object_p (abfd) bfd *abfd; { @@ -123,7 +123,8 @@ b_out_object_p (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; } @@ -142,7 +143,7 @@ b_out_object_p (abfd) /* 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; { @@ -168,12 +169,17 @@ b_out_callback (abfd) obj_textsec (abfd)->vma = execp->a_tload; obj_datasec (abfd)->vma = execp->a_dload; + obj_textsec (abfd)->lma = obj_textsec (abfd)->vma; + obj_datasec (abfd)->lma = obj_datasec (abfd)->vma; + /* And reload the sizes, since the aout module zaps them */ obj_textsec (abfd)->_raw_size = execp->a_text; bss_start = execp->a_dload + execp->a_data; /* BSS = end of data section */ obj_bsssec (abfd)->vma = align_power (bss_start, execp->a_balign); + obj_bsssec (abfd)->lma = obj_bsssec (abfd)->vma; + /* The file positions of the sections */ obj_textsec (abfd)->filepos = N_TXTOFF(*execp); obj_datasec (abfd)->filepos = N_DATOFF(*execp); @@ -203,32 +209,56 @@ b_out_mkobject (abfd) struct bout_data_struct *rawptr; rawptr = (struct bout_data_struct *) bfd_zalloc (abfd, sizeof (struct bout_data_struct)); - if (rawptr == NULL) { - bfd_set_error (bfd_error_no_memory); - return false; - } + if (rawptr == NULL) + return false; 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; } +static int +b_out_symbol_cmp (a, b) + struct aout_symbol **a, **b; +{ + asection *sec; + bfd_vma av, bv; + + /* Primary key is address */ + sec = bfd_get_section (&(*a)->symbol); + av = sec->output_section->vma + sec->output_offset + (*a)->symbol.value; + sec = bfd_get_section (&(*b)->symbol); + bv = sec->output_section->vma + sec->output_offset + (*b)->symbol.value; + + if (av < bv) + return -1; + if (av > bv) + return 1; + + /* Secondary key puts CALLNAME syms last and BALNAME syms first, so + that they have the best chance of being contiguous. */ + if (IS_BALNAME ((*a)->other) || IS_CALLNAME ((*b)->other)) + return -1; + if (IS_CALLNAME ((*a)->other) || IS_BALNAME ((*b)->other)) + return 1; + + return 0; +} + static boolean b_out_write_object_contents (abfd) bfd *abfd; { 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; @@ -250,21 +280,53 @@ b_out_write_object_contents (abfd) 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); + /* Make sure {CALL,BAL}NAME symbols remain adjacent on output + by sorting. This is complicated by the fact that stabs are + also ordered. Solve this by shifting all stabs to the end + in order, then sorting the rest. */ + + asymbol **outsyms, **p, **q; + + outsyms = bfd_get_outsymbols (abfd); + p = outsyms + bfd_get_symcount (abfd); + + for (q = p--; p >= outsyms; p--) + { + if ((*p)->flags & BSF_DEBUGGING) + { + asymbol *t = *--q; + *q = *p; + *p = t; + } + } + + if (q > outsyms) + qsort (outsyms, q - outsyms, sizeof(asymbol*), b_out_symbol_cmp); + + /* Back to your regularly scheduled program. */ + + 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; } @@ -273,11 +335,12 @@ b_out_write_object_contents (abfd) /** Some reloc hackery */ -#define CALLS 0x66003800 /* Template for 'calls' instruction */ -#define BAL 0x0b000000 /* Template for 'bal' instruction */ -#define BALX 0x85000000 /* Template for 'balx' instruction */ -#define BAL_MASK 0x00ffffff -#define CALL 0x09000000 +#define CALLS 0x66003800 /* Template for 'calls' instruction */ +#define BAL 0x0b000000 /* Template for 'bal' instruction */ +#define BAL_MASK 0x00ffffff +#define BALX 0x85f00000 /* Template for 'balx' instruction */ +#define BALX_MASK 0x0007ffff +#define CALL 0x09000000 #define PCREL13_MASK 0x1fff @@ -306,7 +369,7 @@ calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section) int inst = bfd_get_32 (abfd, (bfd_byte *) src-4); /* The next symbol should be an N_BALNAME */ BFD_ASSERT (IS_BALNAME (balsym->other)); - inst &= BAL_MASK; + inst &= BALX_MASK; inst |= BALX; bfd_put_32 (abfd, inst, (bfd_byte *) dst-4); symbol = balsym; @@ -324,7 +387,7 @@ calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section) /* 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; @@ -332,6 +395,7 @@ callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx, 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); @@ -362,12 +426,21 @@ callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx, - 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); } @@ -419,8 +492,8 @@ static reloc_howto_type howto_done_align_table[] = { 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; { @@ -431,6 +504,7 @@ b_out_reloc_type_lookup (abfd, 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; @@ -472,6 +546,11 @@ b_out_slurp_reloc_table (abfd, asect, symbols) goto doit; } + if (asect == obj_bsssec (abfd)) { + reloc_size = 0; + goto doit; + } + bfd_set_error (bfd_error_invalid_operation); return false; @@ -480,27 +559,26 @@ b_out_slurp_reloc_table (abfd, asect, symbols) return false; count = reloc_size / sizeof (struct relocation_info); - relocs = (struct relocation_info *) malloc (reloc_size); - if (!relocs && reloc_size != 0) { - bfd_set_error (bfd_error_no_memory); + relocs = (struct relocation_info *) bfd_malloc (reloc_size); + if (!relocs && reloc_size != 0) return false; - } - reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent)); + reloc_cache = (arelent *) bfd_malloc ((count+1) * sizeof (arelent)); if (!reloc_cache) { - free ((char*)relocs); - bfd_set_error (bfd_error_no_memory); + if (relocs != NULL) + free ((char*)relocs); return false; } if (bfd_read ((PTR) relocs, 1, reloc_size, abfd) != reloc_size) { free (reloc_cache); - free (relocs); + if (relocs != NULL) + free (relocs); return false; } - if (abfd->xvec->header_byteorder_big_p) { + if (bfd_header_big_endian (abfd)) { /* big-endian bit field allocation order */ pcrel_mask = 0x80; extern_mask = 0x10; @@ -526,7 +604,7 @@ b_out_slurp_reloc_table (abfd, asect, symbols) unsigned int symnum; cache_ptr->address = bfd_h_get_32 (abfd, raw + 0); cache_ptr->howto = 0; - if (abfd->xvec->header_byteorder_big_p) + if (bfd_header_big_endian (abfd)) { symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6]; } @@ -586,7 +664,7 @@ b_out_slurp_reloc_table (abfd, asect, symbols) 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 { @@ -650,7 +728,8 @@ b_out_slurp_reloc_table (abfd, asect, symbols) } - free (relocs); + if (relocs != NULL) + free (relocs); asect->relocation = reloc_cache; asect->reloc_count = count; @@ -675,13 +754,11 @@ b_out_squirt_out_relocs (abfd, section) int extern_mask, pcrel_mask, len_2, callj_mask; if (count == 0) return true; generic = section->orelocation; - native = ((struct relocation_info *) malloc (natsize)); - if (!native && natsize != 0) { - bfd_set_error (bfd_error_no_memory); + native = ((struct relocation_info *) bfd_malloc (natsize)); + if (!native && natsize != 0) return false; - } - if (abfd->xvec->header_byteorder_big_p) + if (bfd_header_big_endian (abfd)) { /* Big-endian bit field allocation order */ pcrel_mask = 0x80; @@ -751,11 +828,11 @@ b_out_squirt_out_relocs (abfd, section) 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 */ @@ -767,7 +844,7 @@ b_out_squirt_out_relocs (abfd, section) /* Fill in symbol */ r_extern = 1; - r_idx = stoi((*(g->sym_ptr_ptr))->flags); + r_idx = (*g->sym_ptr_ptr)->udata.i; } } else @@ -777,7 +854,7 @@ b_out_squirt_out_relocs (abfd, section) r_idx = output_section->target_index; } - if (abfd->xvec->header_byteorder_big_p) { + if (bfd_header_big_endian (abfd)) { raw[4] = (unsigned char) (r_idx >> 16); raw[5] = (unsigned char) (r_idx >> 8); raw[6] = (unsigned char) (r_idx ); @@ -807,19 +884,30 @@ b_out_canonicalize_reloc (abfd, section, relptr, symbols) 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 -1; - tblptr = section->relocation; - if (!tblptr) - return -1; + 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; } @@ -834,6 +922,9 @@ b_out_get_reloc_upper_bound (abfd, asect) 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)) @@ -854,18 +945,15 @@ b_out_get_reloc_upper_bound (abfd, asect) 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 @@ -873,7 +961,8 @@ b_out_set_section_contents (abfd, section, location, offset, count) } /* 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; @@ -899,6 +988,8 @@ b_out_set_arch_mach (abfd, arch, machine) case bfd_mach_i960_xa: case bfd_mach_i960_ca: case bfd_mach_i960_ka_sa: + case bfd_mach_i960_jx: + case bfd_mach_i960_hx: case 0: return true; default: @@ -932,7 +1023,7 @@ get_value (reloc, link_info, input_section) 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; @@ -941,10 +1032,12 @@ get_value (reloc, link_info, input_section) we convert b.out to use a specific final_link function and change the interface to bfd_relax_section to not require the generic symbols. */ - h = bfd_link_hash_lookup (link_info->hash, bfd_asymbol_name (symbol), - false, false, true); + h = bfd_wrapped_link_hash_lookup (input_section->owner, link_info, + 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) @@ -992,11 +1085,11 @@ perform_slip (abfd, slip, input_section, value) if (p->value > value) { p->value -=slip; - if (p->udata != NULL) + if (p->udata.p != NULL) { struct generic_link_hash_entry *h; - h = (struct generic_link_hash_entry *) p->udata; + 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); @@ -1093,7 +1186,7 @@ aligncode (abfd, input_section, r, shrink) } static boolean -b_out_relax_section (abfd, i, link_info, again) +b_out_bfd_relax_section (abfd, i, link_info, again) bfd *abfd; asection *i; struct bfd_link_info *link_info; @@ -1118,12 +1211,9 @@ b_out_relax_section (abfd, i, link_info, again) { long reloc_count; - reloc_vector = (arelent **) malloc (reloc_size); + reloc_vector = (arelent **) bfd_malloc (reloc_size); if (reloc_vector == NULL && reloc_size != 0) - { - bfd_set_error (bfd_error_no_memory); - goto error_return; - } + goto error_return; /* Get the relocs and think about them */ reloc_count = @@ -1167,9 +1257,9 @@ b_out_relax_section (abfd, i, link_info, again) } static bfd_byte * -b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, - relocateable, symbols) - bfd *in_abfd; +b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order, + data, relocateable, symbols) + bfd *output_bfd; struct bfd_link_info *link_info; struct bfd_link_order *link_order; bfd_byte *data; @@ -1179,8 +1269,8 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, /* Get enough memory to hold the stuff */ bfd *input_bfd = link_order->u.indirect.section->owner; asection *input_section = link_order->u.indirect.section; - long 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; @@ -1189,26 +1279,23 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, /* If producing relocateable output, don't bother to relax. */ if (relocateable) - return bfd_generic_get_relocated_section_contents (in_abfd, link_info, + return bfd_generic_get_relocated_section_contents (output_bfd, link_info, link_order, data, relocateable, symbols); - reloc_vector = (arelent **) malloc (reloc_size); + reloc_vector = (arelent **) bfd_malloc (reloc_size); if (reloc_vector == NULL && reloc_size != 0) - { - bfd_set_error (bfd_error_no_memory); - goto error_return; - } + goto error_return; input_section->reloc_done = 1; /* read in the section */ - BFD_ASSERT (true == bfd_get_section_contents(input_bfd, - input_section, - data, - 0, - input_section->_raw_size)); + BFD_ASSERT (true == bfd_get_section_contents (input_bfd, + input_section, + data, + 0, + input_section->_raw_size)); reloc_count = bfd_canonicalize_reloc (input_bfd, input_section, @@ -1256,23 +1343,24 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, switch (reloc->howto->type) { case ABS32CODE: - calljx_callback (in_abfd, link_info, reloc, + calljx_callback (input_bfd, link_info, reloc, src_address + data, dst_address + data, input_section); src_address+=4; dst_address+=4; break; case ABS32: - bfd_put_32(in_abfd, - (bfd_get_32 (in_abfd, data+src_address) - + get_value (reloc, link_info, input_section)), - data+dst_address); + bfd_put_32 (input_bfd, + (bfd_get_32 (input_bfd, data + src_address) + + get_value (reloc, link_info, input_section)), + data + dst_address); src_address+=4; dst_address+=4; break; case CALLJ: - callj_callback (in_abfd, link_info, reloc, data, src_address, - dst_address, input_section); + callj_callback (input_bfd, link_info, reloc, data, + src_address, dst_address, input_section, + false); src_address+=4; dst_address+=4; break; @@ -1286,14 +1374,16 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, case ABS32CODE_SHRUNK: /* 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); + callj_callback (input_bfd, link_info, reloc, data, + src_address + 4, dst_address, input_section, + true); dst_address+=4; src_address+=8; break; case PCREL24: { - long int word = bfd_get_32(in_abfd, data+src_address); + long int word = bfd_get_32 (input_bfd, + data + src_address); bfd_vma value; value = get_value (reloc, link_info, input_section); @@ -1304,7 +1394,7 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, + reloc->addend) & BAL_MASK)); - bfd_put_32(in_abfd,word, data+dst_address); + bfd_put_32 (input_bfd, word, data + dst_address); dst_address+=4; src_address+=4; @@ -1313,7 +1403,8 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, case PCREL13: { - long int word = bfd_get_32(in_abfd, data+src_address); + long int word = bfd_get_32 (input_bfd, + data + src_address); bfd_vma value; value = get_value (reloc, link_info, input_section); @@ -1324,7 +1415,7 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, - output_addr (input_section)) & PCREL13_MASK)); - bfd_put_32(in_abfd,word, data+dst_address); + bfd_put_32 (input_bfd, word, data + dst_address); dst_address+=4; src_address+=4; @@ -1349,55 +1440,31 @@ b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data, /* 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 +#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 -bfd_target b_out_vec_big_host = +#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 +#define b_out_bfd_gc_sections bfd_generic_gc_sections + +#define aout_32_get_section_contents_in_window \ + _bfd_generic_get_section_contents_in_window + +const bfd_target b_out_vec_big_host = { "b.out.big", /* name */ bfd_target_aout_flavour, - false, /* data byte order is little */ - true, /* hdr byte order is big */ + BFD_ENDIAN_LITTLE, /* data byte order is little */ + BFD_ENDIAN_BIG, /* hdr byte order is big */ (HAS_RELOC | EXEC_P | /* object flags */ HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ), - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), '_', /* symbol leading char */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - 2, /* minumum alignment power */ bfd_getl64, bfd_getl_signed_64, bfd_putl64, bfd_getl32, bfd_getl_signed_32, bfd_putl32, @@ -1412,25 +1479,33 @@ bfd_target b_out_vec_big_host = {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, - false, /* data byte order is little */ - false, /* header byte order is little */ + BFD_ENDIAN_LITTLE, /* data byte order is little */ + BFD_ENDIAN_LITTLE, /* header byte order is little */ (HAS_RELOC | EXEC_P | /* object flags */ HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ), - (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */ + (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA), '_', /* symbol leading char */ ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ - 2, /* minum align */ bfd_getl64, bfd_getl_signed_64, bfd_putl64, bfd_getl32, bfd_getl_signed_32, bfd_putl32, bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ @@ -1444,6 +1519,16 @@ bfd_target b_out_vec_little_host = _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 };