From 23b0b55855895b0654f2c7916f953b802398bb25 Mon Sep 17 00:00:00 2001 From: John Gilmore Date: Thu, 2 May 1991 23:10:23 +0000 Subject: [PATCH] Merge Per Bothner's MIPS changes from 31 March 1991 (bfd-0.5.2-patch1a) 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. --- bfd/Makefile.in | 4 +- bfd/aout.c | 1 - bfd/coff-code.h | 3 +- bfd/coff-mips.c | 735 ++++++++++---------------------------------------------- bfd/libbfd.c | 12 +- bfd/opncls.c | 2 + bfd/sunos.c | 1 - bfd/targets.c | 13 +- 8 files changed, 149 insertions(+), 622 deletions(-) diff --git a/bfd/Makefile.in b/bfd/Makefile.in index 9d51b02..03f896f 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -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) diff --git a/bfd/aout.c b/bfd/aout.c index 55e7547..fdc51a5 100755 --- a/bfd/aout.c +++ b/bfd/aout.c @@ -1926,4 +1926,3 @@ bfd_target aout_little_vec = JUMP_TABLE(sunos4) }; - diff --git a/bfd/coff-code.h b/bfd/coff-code.h index c649285..8472670 100755 --- a/bfd/coff-code.h +++ b/bfd/coff-code.h @@ -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; diff --git a/bfd/coff-mips.c b/bfd/coff-mips.c index 81c2a53..0ae7af8 100644 --- a/bfd/coff-mips.c +++ b/bfd/coff-mips.c @@ -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 +#include + +#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 -#include - /* 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++; - } - } - 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; + while (l->line_number) { + q->symbol.section->output_section->lineno_count++; + l++; } - - 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) +}; diff --git a/bfd/libbfd.c b/bfd/libbfd.c index f612343..190e500 100644 --- a/bfd/libbfd.c +++ b/bfd/libbfd.c @@ -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)); diff --git a/bfd/opncls.c b/bfd/opncls.c index 9b91c2f..9dbcfcf 100644 --- a/bfd/opncls.c +++ b/bfd/opncls.c @@ -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 diff --git a/bfd/sunos.c b/bfd/sunos.c index 55e7547..fdc51a5 100644 --- a/bfd/sunos.c +++ b/bfd/sunos.c @@ -1926,4 +1926,3 @@ bfd_target aout_little_vec = JUMP_TABLE(sunos4) }; - diff --git a/bfd/targets.c b/bfd/targets.c index e4166be..cec1b6f 100644 --- a/bfd/targets.c +++ b/bfd/targets.c @@ -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 */ -- 2.7.4