/* BFD back-end for Intel 960 b.out binaries.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000
+ Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.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,
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
- /* Now fill in fields in the raw data, from the fields in the exec struct. */
+ /* Now fill in fields in the raw data, from the fields in the exec struct. */
bfd_h_put_32 (abfd, execp->a_info , bytes->e_info);
PUT_WORD (abfd, execp->a_text , bytes->e_text);
PUT_WORD (abfd, execp->a_data , bytes->e_data);
bytes->e_relaxable[0] = execp->a_relaxable;
}
-
static const bfd_target *
b_out_object_p (abfd)
bfd *abfd;
return aout_32_some_aout_object_p (abfd, &anexec, b_out_callback);
}
-
/* Finish up the opening of a b.out file for reading. Fill in all the
fields that are not handled by common code. */
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);
obj_textsec (abfd)->rel_filepos = N_TROFF(*execp);
obj_datasec (abfd)->rel_filepos = N_DROFF(*execp);
- adata(abfd).page_size = 1; /* Not applicable. */
- adata(abfd).segment_size = 1; /* Not applicable. */
+ adata(abfd).page_size = 1; /* Not applicable. */
+ adata(abfd).segment_size = 1; /* Not applicable. */
adata(abfd).exec_bytes_size = EXEC_BYTES_SIZE;
if (execp->a_relaxable)
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;
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;
/* Now write out reloc info, followed by syms and strings */
if (bfd_get_symcount (abfd) != 0)
{
- if (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;
- if (bfd_seek (abfd, (file_ptr)(N_TROFF(*exec_hdr(abfd))), SEEK_SET) != 0)
+ 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;
- if (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;
\f
/** 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
-
#define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
/* Magic to turn callx into calljx */
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;
word += value + reloc_entry->addend;
- bfd_put_32(abfd, word, dst);
+ bfd_put_32 (abfd, word, dst);
return bfd_reloc_ok;
}
-
/* Magic to turn call into callj */
static bfd_reloc_status_type
callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx,
/* The next symbol should be an N_BALNAME. */
BFD_ASSERT(IS_BALNAME(balsym->other));
-
+
/* We are calling a leaf, so replace the call instruction with a
bal. */
word = BAL | ((word
- output_addr (input_section))
& BAL_MASK);
}
- bfd_put_32(abfd, word, (bfd_byte *) data + dstidx);
+ bfd_put_32 (abfd, word, (bfd_byte *) data + dstidx);
return bfd_reloc_ok;
}
static reloc_howto_type howto_reloc_pcrel13 =
HOWTO(PCREL13, 0, 2, 13, true, 0, complain_overflow_signed,0,"pcrel13", true, 0x00001fff,0x00001fff,false);
-
static reloc_howto_type howto_reloc_abs32codeshrunk =
HOWTO(ABS32CODE_SHRUNK, 0, 2, 24, true, 0, complain_overflow_signed, 0,"callx->callj", true, 0x00ffffff, 0x00ffffff,false);
static reloc_howto_type *
b_out_bfd_reloc_type_lookup (abfd, code)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
bfd_reloc_code_real_type code;
{
switch (code)
return false;
doit:
- if (bfd_seek (abfd, (file_ptr)(asect->rel_filepos), SEEK_SET) != 0)
+ 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 && 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) {
if (relocs != NULL)
free ((char*)relocs);
- bfd_set_error (bfd_error_no_memory);
return false;
}
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;
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];
}
}
}
-
if (relocs != NULL)
free (relocs);
asect->relocation = reloc_cache;
asect->reloc_count = count;
-
return true;
}
-
static boolean
b_out_squirt_out_relocs (abfd, section)
bfd *abfd;
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;
/* Fill in symbol */
r_extern = 1;
- r_idx = stoi((*(g->sym_ptr_ptr))->flags);
+ r_idx = (*g->sym_ptr_ptr)->udata.i;
}
}
else
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 );
if (! aout_32_make_sections (abfd))
return false;
- obj_textsec (abfd)->filepos = sizeof(struct internal_exec);
+ obj_textsec (abfd)->filepos = sizeof (struct internal_exec);
obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
+ obj_textsec (abfd)->_raw_size;
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:
static int
b_out_sizeof_headers (ignore_abfd, ignore)
- bfd *ignore_abfd;
- boolean ignore;
+ bfd *ignore_abfd ATTRIBUTE_UNUSED;
+ boolean ignore ATTRIBUTE_UNUSED;
{
- return sizeof(struct internal_exec);
+ return sizeof (struct internal_exec);
}
-
-
/************************************************************************/
static bfd_vma
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_defweak))
{
if (! ((*link_info->callbacks->undefined_symbol)
(link_info, bfd_asymbol_name (symbol),
- input_section->owner, input_section, reloc->address)))
+ input_section->owner, input_section, reloc->address,
+ true)))
abort ();
value = 0;
}
gap = value - (dot - shrink);
-
if (-1<<23 < (long)gap && (long)gap < 1<<23 )
{
/* Change the reloc type from 32bitcode possible 24, to 24bit
{
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 =
}
static bfd_byte *
-b_out_bfd_get_relocated_section_contents (in_abfd, link_info, link_order,
+b_out_bfd_get_relocated_section_contents (output_bfd, link_info, link_order,
data, relocateable, symbols)
- bfd *in_abfd;
+ bfd *output_bfd;
struct bfd_link_info *link_info;
struct bfd_link_order *link_order;
bfd_byte *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;
/* 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,
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, false);
+ callj_callback (input_bfd, link_info, reloc, data,
+ src_address, dst_address, input_section,
+ false);
src_address+=4;
dst_address+=4;
break;
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,
+ callj_callback (input_bfd, link_info, reloc, data,
src_address + 4, dst_address, input_section,
true);
dst_address+=4;
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);
+ 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;
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);
- 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;
break;
default:
- abort();
+ abort ();
}
}
}
#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 b_out_bfd_merge_sections bfd_generic_merge_sections
+
+#define aout_32_get_section_contents_in_window \
+ _bfd_generic_get_section_contents_in_window
+extern const bfd_target b_out_vec_little_host;
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,
BFD_JUMP_TABLE_LINK (b_out),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ & b_out_vec_little_host,
+
(PTR) 0,
};
-
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 */
BFD_JUMP_TABLE_LINK (b_out),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ & b_out_vec_big_host,
+
(PTR) 0
};