Merge Per Bothner's MIPS changes from 31 March 1991 (bfd-0.5.2-patch1a)
authorJohn Gilmore <gnu@cygnus>
Thu, 2 May 1991 23:10:23 +0000 (23:10 +0000)
committerJohn Gilmore <gnu@cygnus>
Thu, 2 May 1991 23:10:23 +0000 (23:10 +0000)
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
bfd/aout.c
bfd/coff-code.h
bfd/coff-mips.c
bfd/libbfd.c
bfd/opncls.c
bfd/sunos.c
bfd/targets.c

index 9d51b02..03f896f 100644 (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)
 
index 55e7547..fdc51a5 100755 (executable)
@@ -1926,4 +1926,3 @@ bfd_target aout_little_vec =
 
   JUMP_TABLE(sunos4)
   };
-
index c649285..8472670 100755 (executable)
@@ -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;
index 81c2a53..0ae7af8 100644 (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;
 }
 \f
@@ -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;
 }
 \f
-
-
-
-
-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)
+};
index f612343..190e500 100644 (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));
index 9b91c2f..9dbcfcf 100644 (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
 
index 55e7547..fdc51a5 100644 (file)
@@ -1926,4 +1926,3 @@ bfd_target aout_little_vec =
 
   JUMP_TABLE(sunos4)
   };
-
index e4166be..cec1b6f 100644 (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 */