void
DEFUN(bout_swap_exec_header_out,(abfd, execp, raw_bytes),
bfd *abfd AND
- struct internal_exec *execp AND
+ struct internal_exec *execp AND
struct external_exec *raw_bytes)
{
struct external_exec *bytes = (struct external_exec *)raw_bytes;
unsigned long bss_start;
/* Architecture and machine type */
- bfd_set_arch_mach(abfd,
+ bfd_set_arch_mach(abfd,
bfd_arch_i960, /* B.out only used on i960 */
bfd_mach_i960_core /* Default */
);
bfd_write ((PTR) &swapped_hdr, 1, EXEC_BYTES_SIZE, abfd);
/* Now write out reloc info, followed by syms and strings */
- if (bfd_get_symcount (abfd) != 0)
+ if (bfd_get_symcount (abfd) != 0)
{
bfd_seek (abfd, (file_ptr)(N_SYMOFF(*exec_hdr(abfd))), SEEK_SET);
#define BAL_MASK 0x00ffffff
#define CALL 0x09000000
#define PCREL13_MASK 0x1fff
+
+
+#define output_addr(sec) ((sec)->output_offset+(sec)->output_section->vma)
+
/* Magic to turn callx into calljx */
-static bfd_reloc_status_type
+static bfd_reloc_status_type
calljx_callback (abfd, link_info, reloc_entry, src, dst, input_section)
bfd *abfd;
struct bfd_link_info *link_info;
value = get_value (reloc_entry, link_info, input_section);
- if (IS_CALLNAME (symbol->other))
+ if (IS_CALLNAME (symbol->other))
{
aout_symbol_type *balsym = symbol+1;
int inst = bfd_get_32 (abfd, (bfd_byte *) src-4);
bfd_put_32 (abfd, inst, (bfd_byte *) dst-4);
symbol = balsym;
value = (symbol->symbol.value
- + symbol->symbol.section->output_section->vma
- + symbol->symbol.section->output_offset);
+ + output_addr (symbol->symbol.section));
}
word += value + reloc_entry->addend;
/* Magic to turn call into callj */
-static bfd_reloc_status_type
+static bfd_reloc_status_type
callj_callback (abfd, link_info, reloc_entry, data, srcidx, dstidx,
input_section)
bfd *abfd;
unsigned int dstidx;
asection *input_section;
{
- int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
+ int word = bfd_get_32 (abfd, (bfd_byte *) data + srcidx);
asymbol *symbol_in = *(reloc_entry->sym_ptr_ptr);
aout_symbol_type *symbol = aout_symbol (symbol_in);
bfd_vma value;
value = get_value (reloc_entry, link_info, input_section);
- if (IS_OTHER(symbol->other))
- {
- /* Call to a system procedure - replace code with system
- procedure number */
- word = CALLS | (symbol->other - 1);
-
- }
-
- else if (IS_CALLNAME(symbol->other))
- {
- aout_symbol_type *balsym = symbol+1;
- /* 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 & BAL_MASK) +
- balsym->symbol.section->output_offset +
- balsym->symbol.section->output_section->vma+
- balsym->symbol.value + reloc_entry->addend - dstidx -
- ( input_section->output_section->vma + input_section->output_offset))
- & BAL_MASK);
-
-
- }
- else
- {
+ if (IS_OTHER(symbol->other))
+ {
+ /* Call to a system procedure - replace code with system
+ procedure number. */
+ word = CALLS | (symbol->other - 1);
+ }
+ else if (IS_CALLNAME(symbol->other))
+ {
+ aout_symbol_type *balsym = symbol+1;
- word = (CALL
- | (((word & BAL_MASK)
- + value
- + reloc_entry->addend
- - dstidx
- - (input_section->output_section->vma
- + input_section->output_offset))
- & BAL_MASK));
- }
+ /* 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 (balsym->symbol.section)
+ + balsym->symbol.value + reloc_entry->addend
+ - dstidx
+ - output_addr (input_section))
+ & BAL_MASK);
+ }
+ else
+ {
+ word = CALL | (((word & BAL_MASK)
+ + value
+ + reloc_entry->addend
+ - dstidx
+ - output_addr (input_section))
+ & BAL_MASK);
+ }
bfd_put_32(abfd, word, (bfd_byte *) data + dstidx);
return bfd_reloc_ok;
}
/* type rshift size bitsize pcrel bitpos absolute overflow check*/
#define ABS32CODE 0
-#define ABS32CODE_SHRUNK 1
+#define ABS32CODE_SHRUNK 1
#define PCREL24 2
#define CALLJ 3
#define ABS32 4
HOWTO(PCREL13, 0, 2, 13, true, 0, complain_overflow_signed,0,"pcrel13", true, 0x00001fff,0x00001fff,false);
-static reloc_howto_type howto_reloc_abs32codeshrunk =
+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 howto_reloc_abs32code =
bfd_seek (abfd, (file_ptr)(asect->rel_filepos), SEEK_SET);
count = reloc_size / sizeof (struct relocation_info);
- relocs = (struct relocation_info *) bfd_xmalloc (reloc_size);
+ relocs = (struct relocation_info *) malloc (reloc_size);
if (!relocs) {
bfd_error = no_memory;
return false;
}
- reloc_cache = (arelent *) bfd_xmalloc ((count+1) * sizeof (arelent));
+ reloc_cache = (arelent *) malloc ((count+1) * sizeof (arelent));
if (!reloc_cache) {
free ((char*)relocs);
bfd_error = no_memory;
}
-
+
if (abfd->xvec->header_byteorder_big_p) {
/* big-endian bit field allocation order */
pcrel_mask = 0x80;
for (rptr = relocs, cache_ptr = reloc_cache, counter = 0;
counter < count;
- counter++, rptr++, cache_ptr++)
+ counter++, rptr++, cache_ptr++)
{
unsigned char *raw = (unsigned char *)rptr;
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 (abfd->xvec->header_byteorder_big_p)
{
symnum = (raw[4] << 16) | (raw[5] << 8) | raw[6];
- }
+ }
else
{
symnum = (raw[6] << 16) | (raw[5] << 8) | raw[4];
}
- if (raw[7] & extern_mask)
+ if (raw[7] & extern_mask)
{
/* if this is set then the r_index is a index into the symbol table;
* if the bit is not set then r_index contains a section map.
*/
cache_ptr->sym_ptr_ptr = symbols + symnum;
cache_ptr->addend = 0;
- } else
+ } else
{
/* in a.out symbols are relative to the beginning of the
* file rather than sections ?
BFD_ASSERT(0);
break;
}
-
+
}
/* the i960 only has a few relocation types:
else
cache_ptr->howto = &howto_reloc_pcrel24;
}
- else
+ else
{
- if (raw[7] & incode_mask)
+ if (raw[7] & incode_mask)
{
cache_ptr->howto = &howto_reloc_abs32code;
}
- else
+ else
{
cache_ptr->howto = &howto_reloc_abs32;
}
}
- if (cache_ptr->address < prev_addr)
+ if (cache_ptr->address < prev_addr)
{
/* Ouch! this reloc is out of order, insert into the right place
*/
{
cursor[1] = cursor[0];
cursor--;
- }
+ }
cursor[1] = tmp;
}
- else
+ else
{
prev_addr = cache_ptr->address;
}
bfd *abfd;
asection *section;
{
-
arelent **generic;
int r_extern = 0;
int r_idx;
- int incode_mask;
+ int incode_mask;
int len_1;
unsigned int count = section->reloc_count;
struct relocation_info *native, *natptr;
int extern_mask, pcrel_mask, len_2, callj_mask;
if (count == 0) return true;
generic = section->orelocation;
- native = ((struct relocation_info *) bfd_xmalloc (natsize));
+ native = ((struct relocation_info *) malloc (natsize));
if (!native) {
bfd_error = no_memory;
return false;
}
- if (abfd->xvec->header_byteorder_big_p)
+ if (abfd->xvec->header_byteorder_big_p)
{
/* Big-endian bit field allocation order */
pcrel_mask = 0x80;
len_1 = 0x20;
callj_mask = 0x02;
incode_mask = 0x08;
- }
- else
+ }
+ else
{
/* Little-endian bit field allocation order */
pcrel_mask = 0x01;
incode_mask = 0x10;
}
- for (natptr = native; count > 0; --count, ++natptr, ++generic)
+ for (natptr = native; count > 0; --count, ++natptr, ++generic)
{
arelent *g = *generic;
unsigned char *raw = (unsigned char *)natptr;
asection *output_section = sym->section->output_section;
- bfd_h_put_32(abfd, g->address, raw);
- /* Find a type in the output format which matches the input howto -
+ bfd_h_put_32(abfd, g->address, raw);
+ /* Find a type in the output format which matches the input howto -
* at the moment we assume input format == output format FIXME!!
*/
r_idx = 0;
/* FIXME: Need callj stuff here, and to check the howto entries to
be sure they are real for this architecture. */
- if (g->howto== &howto_reloc_callj)
+ if (g->howto== &howto_reloc_callj)
{
raw[7] = callj_mask + pcrel_mask + len_2;
}
- else if (g->howto == &howto_reloc_pcrel24)
+ else if (g->howto == &howto_reloc_pcrel24)
{
raw[7] = pcrel_mask + len_2;
}
- else if (g->howto == &howto_reloc_pcrel13)
+ else if (g->howto == &howto_reloc_pcrel13)
{
raw[7] = pcrel_mask + len_1;
}
- else if (g->howto == &howto_reloc_abs32code)
+ else if (g->howto == &howto_reloc_abs32code)
{
raw[7] = len_2 + incode_mask;
}
/* 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)
+ || output_section == &bfd_und_section)
{
if (bfd_abs_section.symbol == sym)
r_idx = 0;
r_extern = 0;
}
- else
+ else
{
/* Fill in symbol */
r_idx = stoi((*(g->sym_ptr_ptr))->flags);
}
}
- else
+ else
{
/* Just an ordinary section */
r_extern = 0;
- r_idx = output_section->target_index;
+ r_idx = output_section->target_index;
}
if (abfd->xvec->header_byteorder_big_p) {
raw[6] = (unsigned char) (r_idx >> 16);
raw[5] = (unsigned char) (r_idx>> 8);
raw[4] = (unsigned char) (r_idx );
- }
+ }
if (r_extern)
- raw[7] |= extern_mask;
+ raw[7] |= extern_mask;
}
if (bfd_write ((PTR) native, 1, natsize, abfd) != natsize) {
((exec_hdr(abfd)->a_trsize / sizeof (struct relocation_info))
+1));
+ if (asect == obj_bsssec (abfd))
+ return 0;
+
bfd_error = invalid_operation;
return 0;
}
}
obj_textsec (abfd)->filepos = sizeof(struct internal_exec);
- obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
+ obj_datasec(abfd)->filepos = obj_textsec(abfd)->filepos
+ obj_textsec (abfd)->_raw_size;
}
return false;
}
-static int
+static int
DEFUN(b_out_sizeof_headers,(ignore_abfd, ignore),
bfd *ignore_abfd AND
boolean ignore)
/************************************************************************/
-static bfd_vma
+static bfd_vma
get_value (reloc, link_info, input_section)
arelent *reloc;
struct bfd_link_info *link_info;
false, false, true);
if (h != (struct bfd_link_hash_entry *) NULL
&& h->type == bfd_link_hash_defined)
- value = (h->u.def.value
- + h->u.def.section->output_section->vma
- + h->u.def.section->output_offset);
+ 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)
value = h->u.c.size;
value = 0;
}
}
- else
+ else
{
- value = (symbol->value
- + symbol->section->output_offset
- + symbol->section->output_section->vma);
+ value = symbol->value + output_addr (symbol->section);
}
/* Add the value contained in the relocation */
value += reloc->addend;
-
+
return value;
}
asection *input_section AND
bfd_vma value)
{
-
+
/* Find all symbols past this point, and make them know
what's happened */
- while (*s)
+ while (*s)
{
asymbol *p = *s;
- if (p->section == input_section)
+ if (p->section == input_section)
{
/* This was pointing into this section, so mangle it */
if (p->value > value)
}
}
s++;
-
- }
+
+ }
}
-#if 1
+
/* This routine works out if the thing we want to get to can be
reached with a 24bit offset instead of a 32 bit one.
If it can, then it changes the amode */
-static int
+static int
abs32code (input_section, symbols, r, shrink, link_info)
asection *input_section;
asymbol **symbols;
struct bfd_link_info *link_info;
{
bfd_vma value = get_value (r, link_info, input_section);
- bfd_vma dot = input_section->output_section->vma + input_section->output_offset + r->address;
+ bfd_vma dot = output_addr (input_section) + r->address;
bfd_vma gap;
-
+
/* See if the address we're looking at within 2^23 bytes of where
we are, if so then we can use a small branch rather than the
jump we were going to */
gap = value - (dot - shrink);
-
+
if (-1<<23 < (long)gap && (long)gap < 1<<23 )
- {
+ {
/* Change the reloc type from 32bitcode possible 24, to 24bit
possible 32 */
r->howto = &howto_reloc_abs32codeshrunk;
/* The place to relc moves back by four bytes */
r->address -=4;
-
+
/* This will be four bytes smaller in the long run */
shrink += 4 ;
perform_slip(symbols, 4, input_section, r->address-shrink +4);
- }
- return shrink;
+ }
+ return shrink;
}
-static int
+static int
DEFUN(aligncode,(input_section, symbols, r, shrink),
asection *input_section AND
asymbol **symbols AND
arelent *r AND
- unsigned int shrink)
+ unsigned int shrink)
{
- bfd_vma dot = input_section->output_section->vma + input_section->output_offset + r->address;
+ bfd_vma dot = output_addr (input_section) + r->address;
bfd_vma gap;
bfd_vma old_end;
bfd_vma new_end;
shrink_delta = (old_end - new_end) - shrink;
if (shrink_delta)
- {
+ {
/* Change the reloc so that it knows how far to align to */
r->howto = howto_done_align_table + (r->howto - howto_align_table);
/* Encode the stuff into the addend - for future use we need to
know how big the reloc used to be */
- r->addend = old_end ;
+ 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 );
shrink += shrink_delta;
- }
- return shrink;
+ }
+ return shrink;
}
-static boolean
+static boolean
b_out_relax_section (abfd, i, link_info, symbols)
bfd *abfd;
asection *i;
struct bfd_link_info *link_info;
asymbol **symbols;
{
-
+
/* Get enough memory to hold the stuff */
bfd *input_bfd = i->owner;
asection *input_section = i;
int shrink = 0 ;
boolean new = false;
-
+
bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
input_section);
- arelent **reloc_vector = (arelent **)alloca(reloc_size);
- /* Get the relocs and think about them */
- if (bfd_canonicalize_reloc(input_bfd,
- input_section,
- reloc_vector,
- symbols))
- {
- arelent **parent;
- for (parent = reloc_vector; *parent; parent++)
+ if (reloc_size)
{
- arelent *r = *parent;
- switch (r->howto->type) {
- case ALIGNER:
- /* An alignment reloc */
- shrink = aligncode(input_section, symbols, r,shrink);
- new=true;
- break;
- case ABS32CODE:
- /* A 32bit reloc in an addressing mode */
- shrink = abs32code (input_section, symbols, r, shrink, link_info);
- new=true;
- break;
- case ABS32CODE_SHRUNK:
- shrink+=4;
- break;
- }
+ arelent **reloc_vector = (arelent **)alloca(reloc_size);
+
+ /* Get the relocs and think about them */
+ if (bfd_canonicalize_reloc(input_bfd, input_section, reloc_vector,
+ symbols))
+ {
+ arelent **parent;
+ for (parent = reloc_vector; *parent; parent++)
+ {
+ arelent *r = *parent;
+ switch (r->howto->type)
+ {
+ case ALIGNER:
+ /* An alignment reloc */
+ shrink = aligncode(input_section, symbols, r,shrink);
+ new=true;
+ break;
+ case ABS32CODE:
+ /* A 32bit reloc in an addressing mode */
+ shrink = abs32code (input_section, symbols, r, shrink, link_info);
+ new=true;
+ break;
+ case ABS32CODE_SHRUNK:
+ shrink+=4;
+ break;
+ }
+ }
+ }
}
- }
- input_section->_cooked_size = input_section->_raw_size - shrink;
+ input_section->_cooked_size = input_section->_raw_size - shrink;
return new;
}
-#endif
static bfd_byte *
b_out_get_relocated_section_contents (in_abfd, link_info, link_order, data,
relocateable, symbols)
bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
input_section);
arelent **reloc_vector = (arelent **)alloca(reloc_size);
-
+
/* If producing relocateable output, don't bother to relax. */
if (relocateable)
return bfd_generic_get_relocated_section_contents (in_abfd, link_info,
data, relocateable,
symbols);
+ input_section->reloc_done = 1;
+
/* read in the section */
- bfd_get_section_contents(input_bfd,
- input_section,
- data,
- 0,
- input_section->_raw_size);
-
-
- if (bfd_canonicalize_reloc(input_bfd,
+ BFD_ASSERT (true == bfd_get_section_contents(input_bfd,
+ input_section,
+ data,
+ 0,
+ input_section->_raw_size));
+
+ if (bfd_canonicalize_reloc(input_bfd,
input_section,
reloc_vector,
symbols) )
- {
- arelent **parent = reloc_vector;
- arelent *reloc ;
-
-
-
- unsigned int dst_address = 0;
- unsigned int src_address = 0;
- unsigned int run;
- unsigned int idx;
-
- /* Find how long a run we can do */
- while (dst_address < link_order->size)
{
-
- reloc = *parent;
- if (reloc)
- {
- /* Note that the relaxing didn't tie up the addresses in the
- relocation, so we use the original address to work out the
- run of non-relocated data */
- run = reloc->address - src_address;
- parent++;
-
- }
- else
- {
- run = link_order->size - dst_address;
- }
- /* Copy the bytes */
- for (idx = 0; idx < run; idx++)
- {
- data[dst_address++] = data[src_address++];
- }
-
- /* Now do the relocation */
-
- if (reloc)
- {
- switch (reloc->howto->type)
+ arelent **parent = reloc_vector;
+ arelent *reloc ;
+
+ unsigned int dst_address = 0;
+ unsigned int src_address = 0;
+ unsigned int run;
+ unsigned int idx;
+
+ /* Find how long a run we can do */
+ while (dst_address < link_order->size)
{
- case ABS32CODE:
- calljx_callback (in_abfd, 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);
- src_address+=4;
- dst_address+=4;
- break;
- case CALLJ:
- callj_callback (in_abfd, link_info, reloc, data, src_address,
- dst_address, input_section);
- src_address+=4;
- dst_address+=4;
- break;
- case ALIGNDONE:
- src_address = reloc->addend;
- dst_address = (dst_address + reloc->howto->size) & ~reloc->howto->size;
- 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, src_address + 4,
- dst_address, input_section);
- dst_address+=4;
- src_address+=8;
- break;
- case PCREL24:
- {
- long int word = bfd_get_32(in_abfd, data+src_address);
- bfd_vma value;
-
- value = get_value (reloc, link_info, input_section);
- word = ((word & ~BAL_MASK)
- | (((word & BAL_MASK)
- + value
- - (input_section->output_section->vma
- + input_section->output_offset)
- + reloc->addend)
- & BAL_MASK));
-
- bfd_put_32(in_abfd,word, data+dst_address);
- dst_address+=4;
- src_address+=4;
-
- }
- break;
-
- case PCREL13:
- {
- long int word = bfd_get_32(in_abfd, data+src_address);
- bfd_vma value;
-
- value = get_value (reloc, link_info, input_section);
- word = ((word & ~PCREL13_MASK)
- | (((word & PCREL13_MASK)
- + value
- + reloc->addend
- - (input_section->output_section->vma
- + input_section->output_offset))
- & PCREL13_MASK));
-
- bfd_put_32(in_abfd,word, data+dst_address);
- dst_address+=4;
- src_address+=4;
-
- }
- break;
-
- default:
-
- abort();
+ reloc = *parent;
+ if (reloc)
+ {
+ /* Note that the relaxing didn't tie up the addresses in the
+ relocation, so we use the original address to work out the
+ run of non-relocated data */
+ BFD_ASSERT (reloc->address >= src_address);
+ run = reloc->address - src_address;
+ parent++;
+ }
+ else
+ {
+ run = link_order->size - dst_address;
+ }
+ /* Copy the bytes */
+ for (idx = 0; idx < run; idx++)
+ {
+ data[dst_address++] = data[src_address++];
+ }
+
+ /* Now do the relocation */
+
+ if (reloc)
+ {
+ switch (reloc->howto->type)
+ {
+ case ABS32CODE:
+ calljx_callback (in_abfd, 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);
+ src_address+=4;
+ dst_address+=4;
+ break;
+ case CALLJ:
+ callj_callback (in_abfd, link_info, reloc, data, src_address,
+ dst_address, input_section);
+ src_address+=4;
+ dst_address+=4;
+ break;
+ case ALIGNDONE:
+ BFD_ASSERT (reloc->addend >= src_address);
+ BFD_ASSERT (reloc->addend <= input_section->_raw_size);
+ src_address = reloc->addend;
+ dst_address = ((dst_address + reloc->howto->size)
+ & ~reloc->howto->size);
+ 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,
+ src_address + 4, dst_address, input_section);
+ dst_address+=4;
+ src_address+=8;
+ break;
+ case PCREL24:
+ {
+ long int word = bfd_get_32(in_abfd, data+src_address);
+ bfd_vma value;
+
+ value = get_value (reloc, link_info, input_section);
+ word = ((word & ~BAL_MASK)
+ | (((word & BAL_MASK)
+ + value
+ - output_addr (input_section)
+ + reloc->addend)
+ & BAL_MASK));
+
+ bfd_put_32(in_abfd,word, data+dst_address);
+ dst_address+=4;
+ src_address+=4;
+
+ }
+ break;
+
+ case PCREL13:
+ {
+ long int word = bfd_get_32(in_abfd, data+src_address);
+ bfd_vma value;
+
+ value = get_value (reloc, link_info, input_section);
+ word = ((word & ~PCREL13_MASK)
+ | (((word & PCREL13_MASK)
+ + value
+ + reloc->addend
+ - output_addr (input_section))
+ & PCREL13_MASK));
+
+ bfd_put_32(in_abfd,word, data+dst_address);
+ dst_address+=4;
+ src_address+=4;
+
+ }
+ break;
+
+ default:
+ abort();
+ }
+ }
}
- }
}
- }
return data;
}
/***********************************************************************/
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | WP_TEXT | BFD_IS_RELAXABLE ),
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
- '_', /* symbol leading char */
+ '_', /* 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,
+ 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_getl64, bfd_getl_signed_64, bfd_putl64,
+ bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
-
- {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
- bfd_generic_archive_p, _bfd_dummy_target},
- {bfd_false, b_out_mkobject, /* bfd_set_format */
- _bfd_generic_mkarchive, bfd_false},
- {bfd_false, b_out_write_object_contents, /* bfd_write_contents */
- _bfd_write_archive_contents, bfd_false},
+
+ {_bfd_dummy_target, b_out_object_p, /* bfd_check_format */
+ bfd_generic_archive_p, _bfd_dummy_target},
+ {bfd_false, b_out_mkobject, /* bfd_set_format */
+ _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),
(PTR) 0
};
projects / external / binutils.git / commitdiff