darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-25 13:09:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge Per Bothner's MIPS changes from 31 March 1991 (bfd-0.5.2-patch1a)

Browse Source 
and make the result compile and run on the DEC 3100.  It still has
trouble running but it can handle opening exec and symbol files in
ecoff format.
This commit is contained in:
John Gilmore 1991-05-02 23:10:23 +00:00
parent 9b4641a629
commit 23b0b55855
8 changed files with 149 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bfd/Makefile.in
View File

@ -37,7 +37,7 @@ BFD_LIBS = libbfd.o opncls.o bfd.o archive.o targets.o cache.o \
archures.o
BFD_BACKENDS = oasys.o ieee.o srec.o sunos.o icoff.o b.out.o \
m88k-bcs.o coffswap.o # trad-core.o
m88k-bcs.o coffswap.o ecoff.o # trad-core.o
BFD_H=$(INCDIR)/bfd.h
SYSDEP_H=$(INCDIR)/sysdep.h
@ -45,7 +45,7 @@ SYSDEP_H=$(INCDIR)/sysdep.h
# C source files that correspond to .o's.
CFILES = libbfd.c opncls.c bfd.c archive.c targets.c cache.c archures.c \
sunos.c icoff.c b.out.c srec.c oasys.c ieee.c m88k-bcs.c \
coffswap.c trad-core.c
coffswap.c ecoff.c trad-core.c
STAGESTUFF = $(TARGETLIB) $(OFILES)

1
bfd/aout.c
View File

@ -1926,4 +1926,3 @@ bfd_target aout_little_vec =
JUMP_TABLE(sunos4)
};

3
bfd/coff-code.h
View File

@ -160,7 +160,6 @@ static boolean
DEFUN(make_a_section_from_file,(abfd, hdr),
bfd *abfd AND
struct scnhdr *hdr)
{
asection *return_section;
@ -225,7 +224,7 @@ static boolean
DEFUN(coff_mkobject,(abfd),
bfd *abfd)
{
set_tdata (abfd, bfd_alloc (abfd,sizeof(coff_data_type)));
set_tdata (abfd, bfd_zalloc (abfd,sizeof(coff_data_type)));
if (coff_data(abfd) == 0) {
bfd_error = no_memory;
return false;

735
bfd/coff-mips.c
View File

@ -1,22 +1,38 @@
/* MIPS Extended-Coff handler for Binary File Diddling.
Written by Per Bothner.
FIXME, Needs Copyleft here. */
/* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Diddler.
BFD is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
BFD is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with BFD; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* This does not compile on anything but a MIPS yet (and I haven't been
able to test it there either since the latest merge!). So it stays
out by default. */
#ifdef ECOFF_BFD
#define MIPS 1
#include <stdio.h>
#include <string.h>
#include "bfd.h"
#include "libbfd.h"
#include "sysdep.h"
#include "libcoff.h" /* to allow easier abstraction-breaking */
#include "intel-coff.h"
#include "libcoff.h" /* to allow easier abstraction-breaking */
static reloc_howto_type howto_table[] =
{
@ -47,7 +63,7 @@ static reloc_howto_type howto_table[] =
{24},
{ R_IPRMED, 2, 2,22,1,0, true, true},
{26},
/* What do we do with this - ? */
/* FIXME: What do we do with this - ? */
#if 1
{ R_OPTCALL, 0,2,32,0,0, true, true},
#else
@ -63,9 +79,6 @@ static reloc_howto_type howto_table[] =
/* Support for Motorola 88k bcs coff as well as Intel 960 coff */
#include <stdio.h>
#include <string.h>
/* Align an address by rounding it up to a power of two. It leaves the
address unchanged if align == 0 (2^0 = alignment of 1 byte) */
@ -83,55 +96,18 @@ void fatal();
* peculiar to this particular implementation of coff
*/
static void
static boolean
ecoff_new_section_hook(abfd, section)
bfd *abfd;
asection *section;
{
section->output_file_alignment = DEFAULT_SECTION_ALIGNMENT;
section->subsection_alignment = section->output_file_alignment;
if (abfd->flags & D_PAGED)
{
/**
If the output object file is demand paged then the
text section starts at the filehdr, with the first
usefull bit of data at the end of the filehdr+opthdr+
scnhdrs. Since we don't know how many sections will
be put into the output file, we have to recalculate
the section pads after each additional section has
been created
**/
asection *ptr = abfd->sections;
unsigned int padding = FILHSZ + AOUTSZ +SCNHSZ * abfd->section_count;
padding = ALIGN(padding, ptr->output_file_alignment);
while (ptr)
{
ptr->start_pad = padding;
/* Only the first section is padded */
padding = 0;
ptr = ptr->next;
}
}
else
{
/* If the object is not demand paged, then all the sections
have no padding
*/
section->start_pad = 0;
}
return true;
}
/* actually it makes itself and its children from the file headers */
static boolean
make_a_section_from_file (abfd, hdr)
bfd *abfd;
bfd *abfd;
struct scnhdr *hdr;
{
asection *return_section ;
@ -147,7 +123,7 @@ bfd *abfd;
/* FIXME -- needs to call swapping routines */
#define assign(to, from) return_section->to = hdr->from
assign (vma, s_vaddr);
assign (original_vma, s_vaddr);
/* assign (vma, s_vaddr);*/
assign (size, s_size);
assign (filepos, s_scnptr);
assign (rel_filepos, s_relptr);
@ -186,7 +162,7 @@ ecoff_real_object_p (abfd, nscns, opthdr)
/* OK, now we know the format, read in the filehdr, soi-disant
"optional header", and all the sections.*/
readsize = sizeof(struct filehdr) + opthdr + (nscns * sizeof (struct scnhdr));
file_info = xmalloc (readsize);
file_info = (char*)bfd_alloc (abfd, readsize);
if (file_info == NULL) {
bfd_error = no_memory;
return 0;
@ -197,9 +173,10 @@ ecoff_real_object_p (abfd, nscns, opthdr)
sections = (struct scnhdr *) (file_info + sizeof (struct filehdr) + opthdr);
/* Now copy data as required; construct all asections etc */
tdata = (struct icofdata *) xmalloc (sizeof (struct icofdata) +
sizeof (AOUTHDR));
tdata = (struct icofdata *) bfd_zalloc (abfd, sizeof (struct icofdata) +
sizeof (AOUTHDR));
if (tdata == NULL) {
bfd_release (abfd, file_info);
bfd_error = no_memory;
return 0;
}
@ -213,44 +190,22 @@ ecoff_real_object_p (abfd, nscns, opthdr)
}
}
#ifdef I960
/* OK, now make a section for the tagbits if there were any */
#if 0
{
AOUTHDR *aouthdr; /* points into tdata! */
aouthdr = (AOUTHDR *) (((char *) tdata) + sizeof (struct icofdata));
if (aouthdr->tagentries != 0) {
asection *tag_section = (asection *) xmalloc (sizeof (asection));
if (tag_section == NULL) {
free (tdata);
return 0;
}
tag_section->size = aouthdr->tagentries * sizeof (TAGBITS);
tag_section->name = TAG_SECTION_NAME;
tag_section->filepos = readsize; /* not surprisingly */
/* Put this one first */
tag_section->next = abfd->sections;
abfd->sections = tag_section;
}
}
#endif
#endif
abfd->flags |= HAS_RELOC | HAS_LINENO | HAS_LOCALS;
abfd->flags |= HAS_RELOC | HAS_LINENO | HAS_LOCALS;
/* FIXME, the guess should be set by OR-ing info from the sections */
if ((filehdr->f_flags & F_RELFLG) != F_RELFLG) abfd->flags &= ~HAS_RELOC;
if ((filehdr->f_flags & F_EXEC) == F_EXEC) abfd->flags |= EXEC_P;
if ((filehdr->f_flags & F_LNNO) != F_LNNO) abfd->flags &= ~HAS_LINENO;
if ((filehdr->f_flags & F_LSYMS) != F_LSYMS) abfd->flags &= ~HAS_LOCALS;
abfd->tdata = tdata;
set_tdata (abfd, tdata);
bfd_get_symcount (abfd) = filehdr->f_nsyms;
if (filehdr->f_nsyms) abfd->flags |= HAS_SYMS;
tdata->sym_filepos = filehdr->f_symptr;
tdata->hdr = (struct aouthdr *)(file_info + sizeof (struct filehdr));
tdata->symbols = (esymbol *)NULL;
bfd_get_start_address (abfd) = exec_hdr (abfd)->entry;
/* FIXME, needs byte swapping */
tdata->hdr = *(struct aouthdr *)(file_info + sizeof (struct filehdr));
tdata->symbols = (coff_symbol_type *)NULL;
bfd_get_start_address (abfd) = exec_hdr (abfd).entry;
return abfd->xvec;
}
@ -275,7 +230,8 @@ ecoff_object_p (abfd)
return 0;
nscns = bfd_h_getshort (abfd, (unsigned char *)&nscns);
if (bfd_seek (abfd, ((sizeof (long)) * 3), true) < 0) return false;
if (bfd_seek (abfd,(file_ptr) ((sizeof (long)) * 3), true) < 0)
return 0;
if (bfd_read (&opthdr, 1, sizeof (opthdr), abfd) != sizeof (opthdr))
return 0;
opthdr = bfd_h_getshort (abfd, (unsigned char *)&opthdr);
@ -293,15 +249,12 @@ ecoff_mkobject (abfd)
bfd_error = no_error;
/* Use an intermediate variable for clarity */
rawptr = xmalloc (sizeof (struct icofdata) + sizeof (AOUTHDR));
rawptr = (char*)bfd_zalloc (abfd, sizeof (struct icofdata));
if (rawptr == NULL) {
bfd_error = no_memory;
return false;
}
abfd->tdata = (struct icofdata *) rawptr;
exec_hdr (abfd) = (AOUTHDR *) (rawptr + sizeof (struct icofdata));
set_tdata (abfd, rawptr);
return true;
}
@ -310,143 +263,38 @@ ecoff_count_linenumbers(abfd)
bfd *abfd;
{
unsigned int limit = bfd_get_symcount(abfd);
unsigned int i = 0;
esymbol **p = (esymbol **)(abfd->outsymbols);
unsigned int i;
asymbol **p;
{
asection *s = abfd->sections;
asection *s = abfd->sections->output_section;
while (s) {
if (s->lineno_count != 0) {
fatal("Bad initial state");
}
BFD_ASSERT(s->lineno_count == 0);
s = s->next;
}
}
while (i < limit)
for (p = abfd->outsymbols,i = 0; i < limit; i++, p++)
{
esymbol *q = *p;
if (q->c.lineno)
{
/* This symbol has a linenumber, increment the
* owning section's linenumber count */
alent *l = q->c.lineno;
q->c.section->lineno_count++;
l++;
while (l->line_number) {
q->c.section->lineno_count++;
asymbol *q_maybe = *p;
if (q_maybe->the_bfd->xvec->flavour == bfd_target_coff_flavour_enum) {
coff_symbol_type *q = coffsymbol(q_maybe);
if (q->lineno)
{
/* This symbol has a linenumber, increment the
* owning section's linenumber count */
alent *l = q->lineno;
q->symbol.section->output_section->lineno_count++;
l++;
while (l->line_number) {
q->symbol.section->output_section->lineno_count++;
l++;
}
}
}
p++;
i++;
}
}
}
/*
run through the internal symbol table and make all the
pointers and things within the table point to the right places
*/
static void
ecoff_mangle_symbols(abfd)
bfd *abfd;
{
esymbol **p = (esymbol **)(abfd->outsymbols);
unsigned int native_index = 0;
unsigned int last_file_index = 0;
unsigned int limit = bfd_get_symcount(abfd);
struct syment *last_file_symbol = (struct syment *)NULL;
while (limit--) {
esymbol *q = *p;
struct syment *native = q->native;
if(native) {
/* Alter the native representation */
native->n_value = q->c.value;
if (q->c.flags & BSF_FORT_COMM) {
native->n_scnum = 0;
}
else if (q->c.flags & BSF_DEBUGGING) {
native->n_scnum = -2;
}
else if (q->c.flags & BSF_UNDEFINED) {
native->n_scnum = 0;
}
else if (q->c.flags & BSF_ABSOLUTE) {
native->n_scnum = -1;
}
else {
native->n_scnum = q->c.section->index + 1;
}
if (native->n_numaux)
{
union auxent *a = (union auxent *)(native+1);
/* Relocate symbol indexes */
if (ISFCN(native->n_type))
{
a->x_sym.x_fcnary.x_fcn.x_endndx += last_file_index;
}
else if(native->n_sclass == C_BLOCK && q->c.name[1] == 'b')
{
a->x_sym.x_fcnary.x_fcn.x_endndx += last_file_index;
}
else if (native->n_sclass == C_STRTAG)
{
a->x_sym.x_fcnary.x_fcn.x_endndx += last_file_index;
}
else if (native->n_sclass == C_MOS || native->n_sclass == C_EOS || native->n_sclass == C_MOE)
{
a->x_sym.x_tagndx += last_file_index;
}
}
switch (native->n_sclass) {
case C_MOS:
case C_EOS:
case C_REGPARM:
case C_REG:
case 19: /*C_REGARG:FIXME */
/* Fix so that they have an absolute section */
native->n_scnum= -1;
break;
case C_FILE:
/* Chain all the .file symbols together */
if(last_file_symbol) {
last_file_symbol->n_value = native_index;
}
last_file_symbol = native;
last_file_index = native_index;
break;
case C_NULL:
case C_AUTO:
case C_EXT:
case C_EXTDEF:
case C_LABEL:
case C_ULABEL:
case C_USTATIC:
case C_STRTAG:
case C_FCN:
case C_BLOCK:
case C_STAT:
case C_LEAFPROC:
break;
default:
/* Bogus: This should be returning an error code, not printing
something out! */
/* warning("Unrecognised sclass %d", native->n_sclass); */
break;
}
native_index += 1 + native->n_numaux;
}
else {
native_index++;
}
p++;
}
}
static void
ecoff_write_symbols(abfd)
bfd *abfd;
@ -466,13 +314,11 @@ ecoff_make_empty_symbol(abfd, n)
bfd *abfd;
unsigned int n;
{
unsigned int j;
esymbol *new = (esymbol *)xmalloc(sizeof(esymbol) * n);
for (j= 0; j < n; j++) {
new[j].native = 0;
new[j].c.lineno = (alent *)NULL;
}
return (asymbol *)new;
coff_symbol_type *new = (coff_symbol_type *)xmalloc(sizeof(coff_symbol_type));
new->native = 0;
new->lineno = (alent *)NULL;
new->symbol.the_bfd = abfd;
return &new->symbol;
}
/*SUPPRESS 558*/
@ -490,23 +336,7 @@ static void
ecoff_compute_section_file_positions (abfd)
bfd *abfd;
{
file_ptr sofar = sizeof (struct filehdr) + sizeof (AOUTHDR);
asection *current;
sofar += abfd->section_count * sizeof (struct scnhdr);
for (current = abfd->sections; current != NULL; current = current->next) {
sofar = ALIGN(sofar, current->output_file_alignment);
current->filepos = sofar;
/* Only add sections which are loadable */
if (current->flags & SEC_LOAD) sofar += current->size;
#if 0
if(current->filepos & (current->alignment-1)) {
sofar += current->alignment - (current->filepos &(current->alignment-1));
current->filepos = (current->filepos + current->alignment) & -current->alignment;
}
#endif
}
obj_relocbase (abfd) = sofar;
abort();
}
boolean
@ -539,31 +369,6 @@ ecoff_close_and_cleanup (abfd)
return false;
}
static void *
buy_and_read(abfd, where, relative, size)
bfd *abfd;
int where;
boolean relative;
unsigned int size;
{
void *area = (void *)xmalloc(size);
if (!area) {
bfd_error = no_memory;
return 0;
}
bfd_seek(abfd, where, relative);
if (bfd_read(area, 1, size, abfd) != size){
bfd_error = system_call_error;
free(area);
return 0;
}
return area;
}
static
struct sec *section_from_bfd_index(abfd, index)
bfd *abfd;
@ -609,7 +414,7 @@ ecoff_symbol_name (abfd, idx)
bfd *abfd;
symindex idx;
{
return (obj_symbols (abfd) + idx)->c.name;
return (obj_symbols (abfd) + idx)->symbol.name;
}
static long
@ -617,7 +422,7 @@ ecoff_symbol_value (abfd, idx)
bfd *abfd;
symindex idx;
{
return (obj_symbols (abfd) + idx)->c.value;
return (obj_symbols (abfd) + idx)->symbol.value;
}
static symclass
@ -625,14 +430,7 @@ ecoff_classify_symbol (abfd, idx)
bfd *abfd;
symindex idx;
{
esymbol *sym = obj_symbols (abfd) + idx;
if ((sym->c.flags & BSF_FORT_COMM) != 0) return bfd_symclass_fcommon;
if ((sym->c.flags & BSF_GLOBAL) != 0) return bfd_symclass_global;
if ((sym->c.flags & BSF_DEBUGGING) != 0) return bfd_symclass_debugger;
if ((sym->c.flags & BSF_UNDEFINED) != 0) return bfd_symclass_undefined;
return bfd_symclass_unknown;
abort();
}
static boolean
@ -641,18 +439,7 @@ ecoff_symbol_hasclass (abfd, idx, class)
symindex idx;
symclass class;
{
esymbol *sym = obj_symbols (abfd) + idx;
switch (class) {
case bfd_symclass_fcommon: return (sym->c.flags & BSF_FORT_COMM) != 0;
case bfd_symclass_global: return (sym->c.flags & BSF_GLOBAL) != 0;
case bfd_symclass_debugger: return (sym->c.flags & BSF_DEBUGGING) != 0;
case bfd_symclass_undefined: return (sym->c.flags & BSF_UNDEFINED) != 0;
default: return false;
}
abort();
}
@ -671,198 +458,7 @@ static boolean
ecoff_slurp_symbol_table(abfd)
bfd *abfd;
{
struct syment *native_symbols;
esymbol *cached_area;
char *string_table = (char *)NULL;
unsigned int string_table_size;
unsigned int number_of_symbols = 0;
if (obj_symbols (abfd)) return true;
bfd_seek(abfd, obj_sym_filepos(abfd), false);
/* Read in the symbol table */
native_symbols =
(struct syment *)buy_and_read(abfd,
obj_sym_filepos(abfd),
false,
bfd_get_symcount(abfd) * sizeof(struct syment));
if (!native_symbols) {
return false;
}
/* Allocate enough room for all the symbols in cached form */
cached_area = (esymbol *)xmalloc(bfd_get_symcount(abfd) * sizeof(esymbol));
{
esymbol *dst = cached_area;
unsigned int last_native_index = bfd_get_symcount(abfd);
unsigned int this_index = 0;
while (this_index < last_native_index)
{
struct syment *src = native_symbols + this_index;
if (src->n_zeroes == 0) {
/* This symbol has a name in the string table */
/* Which means that we'll have to read it in */
/* Fetch the size of the string table which is straight after the
* symbol table
*/
if (string_table == (char *)NULL) {
if (bfd_read(&string_table_size, sizeof(string_table_size), 1, abfd) !=
sizeof(string_table_size)) {
fatal("Corrupt coff format");
}
else {
/* Read the string table */
string_table =
(char *)buy_and_read(abfd,0, true,
string_table_size - sizeof(string_table_size)) ;
}
}
dst->c.name = string_table + src->n_offset - 4;
}
else {
/* Otherwise we have to buy somewhere for this name */
dst->c.name = xmalloc (SYMNMLEN+1);
strncpy(dst->c.name, src->n_name, SYMNMLEN);
dst->c.name[SYMNMLEN+1] = '\0'; /* Be sure to terminate it */
}
/* We use the native name field to point to the cached field */
src->n_zeroes = (long)dst;
dst->c.section = section_from_bfd_index(abfd, src->n_scnum);
switch (src->n_sclass)
{
#ifdef I960
case C_LEAFPROC:
dst->c.value = src->n_value - dst->c.section->vma;
dst->c.flags = BSF_EXPORT | BSF_GLOBAL;
dst->c.flags |= BSF_NOT_AT_END;
break;
#endif
case C_EXT:
if (src->n_scnum == 0) {
if (src->n_value == 0)
{
dst->c.flags = BSF_UNDEFINED;
}
else {
dst->c.flags = BSF_FORT_COMM;
dst->c.value = src->n_value;
}
}
else {
/* Base the value as an index from the base of the section */
if (dst->c.section == (asection *)NULL)
{
dst->c.flags = BSF_EXPORT | BSF_GLOBAL | BSF_ABSOLUTE;
dst->c.value = src->n_value;
}
else
{
dst->c.flags = BSF_EXPORT | BSF_GLOBAL;
dst->c.value = src->n_value - dst->c.section->vma;
}
if (ISFCN(src->n_type)) {
/* A function ext does not go at the end of a file*/
dst->c.flags |= BSF_NOT_AT_END;
}
}
break;
case C_STAT : /* static */
case C_LABEL : /* label */
dst->c.flags = BSF_LOCAL;
/* Base the value as an index from the base of the section */
dst->c.value = src->n_value - dst->c.section->vma;
break;
case C_MOS : /* member of structure */
case C_EOS : /* end of structure */
case C_REGPARM : /* register parameter */
case C_REG : /* register variable */
case 19 : /* Intel specific REGARG FIXME */
case C_TPDEF : /* type definition */
case C_ARG:
case C_AUTO: /* automatic variable */
case C_FIELD: /* bit field */
case C_ENTAG : /* enumeration tag */
case C_MOE : /* member of enumeration */
case C_MOU : /* member of union */
case C_UNTAG : /* union tag */
dst->c.flags = BSF_DEBUGGING;
dst->c.value = src->n_value;
break;
case C_FILE : /* file name */
case C_STRTAG : /* structure tag */
dst->c.flags = BSF_DEBUGGING;
dst->c.value = src->n_value ;
break;
case C_BLOCK : /* ".bb" or ".eb" */
case C_FCN : /* ".bf" or ".ef" */
dst->c.flags = BSF_LOCAL;
/* Base the value as an index from the base of the section */
dst->c.value = src->n_value - dst->c.section->vma;
break;
case C_EFCN : /* physical end of function */
case C_NULL:
case C_EXTDEF : /* external definition */
case C_ULABEL : /* undefined label */
case C_USTATIC : /* undefined static */
case C_LINE : /* line # reformatted as symbol table entry */
case C_ALIAS : /* duplicate tag */
case C_HIDDEN : /* ext symbol in dmert public lib */
default:
printf("SICK%d\n",src->n_sclass);
dst->c.flags = BSF_DEBUGGING;
dst->c.value = src->n_value ;
break;
}
if (dst->c.flags == 0) fatal("OOOO dear");
dst->native = src;
dst->c.udata = 0;
dst->c.lineno = (alent *)NULL;
this_index += src->n_numaux + 1;
dst++;
number_of_symbols++;
}
}
obj_symbols(abfd) = cached_area;
obj_raw_syments(abfd) = native_symbols;
bfd_get_symcount(abfd) = number_of_symbols;
/* Slurp the line tables for each section too */
{
asection *p;
p = abfd->sections;
while (p) {
ecoff_slurp_line_table(abfd, p);
p =p->next;
}
}
return true;
abort();
}
unsigned int
@ -871,7 +467,7 @@ ecoff_get_symtab_upper_bound (abfd)
{
if (!ecoff_slurp_symbol_table (abfd)) return 0;
return (bfd_get_symcount (abfd)+1) * (sizeof (esymbol *));
return (bfd_get_symcount (abfd)+1) * (sizeof (coff_symbol_type *));
}
@ -881,8 +477,8 @@ bfd *abfd;
asymbol **alocation;
{
unsigned int counter = 0;
esymbol *symbase;
esymbol **location = (esymbol **)(alocation);
coff_symbol_type *symbase;
coff_symbol_type **location = (coff_symbol_type **)(alocation);
if (!ecoff_slurp_symbol_table (abfd)) return 0;
@ -913,68 +509,7 @@ ecoff_slurp_reloc_table (abfd, asect)
bfd *abfd;
sec_ptr asect;
{
struct reloc *native_relocs;
arelent *reloc_cache;
if (asect->relocation) return true;
if (asect->reloc_count ==0) return true;
if (!ecoff_slurp_symbol_table (abfd)) return false;
native_relocs = (struct reloc *)buy_and_read(abfd,
asect->rel_filepos,
false,
sizeof(struct reloc) * asect->reloc_count);
reloc_cache = (arelent *)xmalloc(asect->reloc_count * sizeof(arelent ));
{
unsigned int counter = 0;
arelent *cache_ptr = reloc_cache;
struct reloc *src = native_relocs;
while (counter < asect->reloc_count)
{
cache_ptr->address = src->r_vaddr - asect->original_vma;
cache_ptr->sym = (asymbol *)(src->r_symndx +
obj_raw_syments (abfd))->n_zeroes;
/* The symbols that we have read in have been relocated as if their
* sections started at 0. But the offsets refering to the symbols
* in the raw data have not been modified, so we have to have
* a negative addend to compensate
*/
if (cache_ptr->sym->section) {
cache_ptr->addend = - cache_ptr->sym->section->original_vma;
}
else {
/* If the symbol doesn't have a section then it hasn't been relocated,
* so we don't have to fix it
*/
cache_ptr->addend = 0;
}
cache_ptr->section = 0;
#if I960
cache_ptr->howto = howto_table + src->r_type;
#endif
#if M88
if (src->r_type >= R_PCR16L && src->r_type <= R_VRT32)
{
cache_ptr->howto = howto_table + src->r_type - R_PCR16L;
}
else
{
fatal("unrecognised reloc type %d\n", src->r_type);
}
#endif
cache_ptr++;
src++;
counter++;
}
}
free (native_relocs);
asect->relocation = reloc_cache;
return true;
abort();
}
@ -988,8 +523,49 @@ ecoff_canonicalize_reloc (abfd, section, relptr)
return 0;
}
boolean
ecoff_get_section_contents (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
PTR location;
file_ptr offset;
int count;
{
if (count) {
if (offset >= section->size) return false;
bfd_seek (abfd, section->filepos + offset, SEEK_SET);
return (bfd_read (location, 1, count, abfd) == count) ? true:false;
}
else return true;
}
alent *
ecoff_get_lineno(ignore_abfd, ignore_symbol)
bfd *ignore_abfd;
PTR ignore_symbol;
{
return (alent *)NULL;
}
#define ecoff_core_file_failing_command _bfd_dummy_core_file_failing_command
#define ecoff_core_file_failing_signal _bfd_dummy_core_file_failing_signal
#define ecoff_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
#define ecoff_slurp_armap bfd_false
#define ecoff_slurp_extended_name_table bfd_false
#define ecoff_truncate_arname bfd_void
#define ecoff_write_armap bfd_false
#define ecoff_print_symbol bfd_void
#define ecoff_set_arch_mach bfd_false
#define ecoff_openr_next_archived_file bfd_generic_openr_next_archived_file
#define ecoff_find_nearest_line bfd_false
#define ecoff_generic_stat_arch_elt bfd_generic_stat_arch_elt
#define ecoff_sizeof_headers bfd_0
bfd_target ecoff_little_vec =
{"ecoff-littlemips", /* name */
bfd_target_coff_flavour_enum,
false, /* data byte order is little */
false, /* header byte order is little */
@ -997,36 +573,9 @@ bfd_target ecoff_little_vec =
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT),
(SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
0, /* valid reloc types */
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
'/', /* ar_pad_char */
15, /* ar_max_namelen */
ecoff_close_and_cleanup, /* _close_and_cleanup */
ecoff_set_section_contents, /* bfd_set_section_contents */
ecoff_new_section_hook, /* new_section_hook */
_bfd_dummy_core_file_failing_command, /* _core_file_failing_command */
_bfd_dummy_core_file_failing_signal, /* _core_file_failing_signal */
_bfd_dummy_core_file_matches_executable_p, /* _core_file_matches_ex...p */
bfd_slurp_coff_armap, /* bfd_slurp_armap */
_bfd_slurp_extended_name_table, /* bfd_slurp_extended_name_table*/
bfd_dont_truncate_arname, /* bfd_truncate_arname */
ecoff_get_symtab_upper_bound, /* get_symtab_upper_bound */
ecoff_get_symtab, /* canonicalize_symtab */
(void (*)())bfd_false, /* bfd_reclaim_symbol_table */
ecoff_get_reloc_upper_bound, /* get_reloc_upper_bound */
ecoff_canonicalize_reloc, /* bfd_canonicalize_reloc */
(void (*)())bfd_false, /* bfd_reclaim_reloc */
ecoff_get_symcount_upper_bound, /* bfd_get_symcount_upper_bound */
ecoff_get_first_symbol, /* bfd_get_first_symbol */
ecoff_get_next_symbol, /* bfd_get_next_symbol */
ecoff_classify_symbol, /* bfd_classify_symbol */
ecoff_symbol_hasclass, /* bfd_symbol_hasclass */
ecoff_symbol_name, /* bfd_symbol_name */
ecoff_symbol_value, /* bfd_symbol_value */
_do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* data */
_do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* hdrs */
@ -1034,13 +583,12 @@ bfd_target ecoff_little_vec =
bfd_generic_archive_p, _bfd_dummy_target},
{bfd_false, ecoff_mkobject, bfd_false, /* bfd_set_format */
bfd_false},
ecoff_make_empty_symbol,
};
JUMP_TABLE (ecoff)
};
bfd_target ecoff_big_vec =
{"ecoff-bigmips", /* name */
bfd_target_coff_flavour_enum,
true, /* data byte order is big */
true, /* header byte order is big */
@ -1048,36 +596,9 @@ bfd_target ecoff_big_vec =
HAS_LINENO | HAS_DEBUG |
HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT),
(SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
0, /* valid reloc types */
'/', /* ar_pad_char */
15, /* ar_max_namelen */
ecoff_close_and_cleanup, /* _close_and_cleanup */
ecoff_set_section_contents, /* bfd_set_section_contents */
ecoff_new_section_hook, /* new_section_hook */
_bfd_dummy_core_file_failing_command, /* _core_file_failing_command */
_bfd_dummy_core_file_failing_signal, /* _core_file_failing_signal */
_bfd_dummy_core_file_matches_executable_p, /* _core_file_matches_ex...p */
bfd_slurp_coff_armap, /* bfd_slurp_armap */
_bfd_slurp_extended_name_table, /* bfd_slurp_extended_name_table*/
bfd_dont_truncate_arname, /* bfd_truncate_arname */
ecoff_get_symtab_upper_bound, /* get_symtab_upper_bound */
ecoff_get_symtab, /* canonicalize_symtab */
(void (*)())bfd_false, /* bfd_reclaim_symbol_table */
ecoff_get_reloc_upper_bound, /* get_reloc_upper_bound */
ecoff_canonicalize_reloc, /* bfd_canonicalize_reloc */
(void (*)())bfd_false, /* bfd_reclaim_reloc */
ecoff_get_symcount_upper_bound, /* bfd_get_symcount_upper_bound */
ecoff_get_first_symbol, /* bfd_get_first_symbol */
ecoff_get_next_symbol, /* bfd_get_next_symbol */
ecoff_classify_symbol, /* bfd_classify_symbol */
ecoff_symbol_hasclass, /* bfd_symbol_hasclass */
ecoff_symbol_name, /* bfd_symbol_name */
ecoff_symbol_value, /* bfd_symbol_value */
(SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
' ', /* ar_pad_char */
16, /* ar_max_namelen */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
_do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
@ -1085,9 +606,5 @@ bfd_target ecoff_big_vec =
bfd_generic_archive_p, _bfd_dummy_target},
{bfd_false, ecoff_mkobject, bfd_false, /* bfd_set_format */
bfd_false},
ecoff_make_empty_symbol,
};
#endif /* ECOFF_BFD */
JUMP_TABLE(ecoff)
};

12
bfd/libbfd.c
View File

@ -136,21 +136,21 @@ zalloc (size)
contents (0 for non-archive elements). For archive entries this is the
first octet in the file, NOT the beginning of the archive header. */
size_t
bfd_size_type
bfd_read (ptr, size, nitems, abfd)
PTR ptr;
size_t size;
size_t nitems;
bfd_size_type size;
bfd_size_type nitems;
bfd *abfd;
{
return fread (ptr, 1, size*nitems, bfd_cache_lookup(abfd));
}
size_t
bfd_size_type
bfd_write (ptr, size, nitems, abfd)
PTR ptr;
size_t size;
size_t nitems;
bfd_size_type size;
bfd_size_type nitems;
bfd *abfd;
{
return fwrite (ptr, 1, size*nitems, bfd_cache_lookup(abfd));

2
bfd/opncls.c
View File

@ -51,6 +51,8 @@ FILE *bfd_open_file();
Perhaps, since unix has so many different kinds of locking anyway,
we should use the emacs lock scheme?... */
extern PTR malloc();
extern void free();
#define obstack_chunk_alloc malloc
#define obstack_chunk_free free

1
bfd/sunos.c
View File

@ -1926,4 +1926,3 @@ bfd_target aout_little_vec =
JUMP_TABLE(sunos4)
};

13
bfd/targets.c
View File

@ -26,7 +26,8 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "bfd.h"
#include "libbfd.h"
extern bfd_target ecoff_little_vec;
extern bfd_target ecoff_big_vec;
extern bfd_target aout_little_vec;
extern bfd_target aout_big_vec;
extern bfd_target srec_vec;
@ -46,6 +47,8 @@ extern bfd_target m88k_bcs_vec;
#endif /* GNU960 */
#ifndef RESTRICTED
#define ECOFF_LITTLE_VEC ecoff_little_vec
#define ECOFF_BIG_VEC ecoff_big_vec
#define ICOFF_LITTLE_VEC icoff_little_vec
#define ICOFF_BIG_VEC icoff_big_vec
#define B_OUT_VEC_LITTLE_HOST b_out_vec_little_host
@ -63,6 +66,14 @@ bfd_target *target_vector[] = {
&DEFAULT_VECTOR,
#endif /* DEFAULT_VECTOR */
#ifdef ECOFF_LITTLE_VEC
&ECOFF_LITTLE_VEC,
#endif
#ifdef ECOFF_BIG_VEC
&ECOFF_BIG_VEC,
#endif
#ifdef IEEE_VEC
&IEEE_VEC,
#endif /* IEEE_VEC */