/* BFD back-end for Intel 960 b.out binaries.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+ Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
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);
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)
{
+ /* 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;
\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
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;
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;
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;
}
- 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];
}
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 );
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);
}
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))
{
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;
#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
+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 */
BFD_JUMP_TABLE_LINK (b_out),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ & b_out_vec_little_host,
+
(PTR) 0,
};
{
"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 */
BFD_JUMP_TABLE_LINK (b_out),
BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
+ & b_out_vec_big_host,
+
(PTR) 0
};
projects / deliverable / binutils-gdb.git / blobdiff