-/* MIPS Extended-Coff handler for Binary File Diddling.
- Written by Per Bothner.
+/* BFD back-end for MIPS Extended-Coff files.
+ Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+ Original version by Per Bothner.
- FIXME, Needs Copyleft here. */
+This file is part of BFD, the Binary File Descriptor library.
-/* 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 "libbfd.h"
-#include "sysdep.h"
-#include "libcoff.h" /* to allow easier abstraction-breaking */
-
-#include "intel-coff.h"
+This program 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 2 of the License, or
+(at your option) any later version.
+This program 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 this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+#include "bfd.h"
+#include "sysdep.h"
+#include "libbfd.h"
+#include "seclet.h"
+#include "coff/internal.h"
+#include "coff/sym.h"
+#include "coff/symconst.h"
+#include "coff/ecoff.h"
+#include "coff/mips.h"
+#include "libcoff.h"
+#include "libecoff.h"
+\f
+/* Prototypes for static functions. */
+
+static boolean mips_ecoff_bad_format_hook PARAMS ((bfd *abfd, PTR filehdr));
+static PTR mips_ecoff_mkobject_hook PARAMS ((bfd *abfd, PTR filehdr,
+ PTR aouthdr));
+static void mips_ecoff_swap_reloc_in PARAMS ((bfd *, PTR,
+ struct internal_reloc *));
+static void mips_ecoff_swap_reloc_out PARAMS ((bfd *,
+ const struct internal_reloc *,
+ PTR));
+\f
-static reloc_howto_type howto_table[] =
-{
- {0},
- {1},
- {2},
- {3},
- {4},
- {5},
- {6},
- {7},
- {8},
- {9},
- {10},
- {11},
- {12},
- {13},
- {14},
- {15},
- {16},
- { R_RELLONG, 0, 2, 32, 0, 0, true, true},
- {18},
- {19},
- {20},
- {21},
- {22},
- {23},
- {24},
- { R_IPRMED, 2, 2,22,1,0, true, true},
- {26},
-/* What do we do with this - ? */
-#if 1
- { R_OPTCALL, 0,2,32,0,0, true, true},
-#else
- { R_OPTCALL, 0,3,32,0,0, true, true},
-#endif
+/* ECOFF has COFF sections, but the debugging information is stored in
+ a completely different format. ECOFF targets use some of the
+ swapping routines from coffswap.h, and some of the generic COFF
+ routines in coffgen.c, but, unlike the real COFF targets, do not
+ use coffcode.h itself.
+
+ Get the generic COFF swapping routines, except for the reloc,
+ symbol, and lineno ones. Give them ecoff names. */
+#define MIPSECOFF
+#define NO_COFF_RELOCS
+#define NO_COFF_SYMBOLS
+#define NO_COFF_LINENOS
+#define coff_swap_filehdr_in mips_ecoff_swap_filehdr_in
+#define coff_swap_filehdr_out mips_ecoff_swap_filehdr_out
+#define coff_swap_aouthdr_in mips_ecoff_swap_aouthdr_in
+#define coff_swap_aouthdr_out mips_ecoff_swap_aouthdr_out
+#define coff_swap_scnhdr_in mips_ecoff_swap_scnhdr_in
+#define coff_swap_scnhdr_out mips_ecoff_swap_scnhdr_out
+#include "coffswap.h"
+
+/* Get the ECOFF swapping routines. */
+#define ECOFF_32
+#include "ecoffswap.h"
+\f
+/* This is the ECOFF backend structure. The backend_data field of the
+ ecoff_tdata structure is set to this when an ECOFF BFD is
+ initialized. This is used by the generic ECOFF routines. */
+
+static const struct ecoff_backend_data mips_ecoff_backend_data =
+{
+ /* Supported architecture. */
+ bfd_arch_mips,
+ /* Big endian magic number. */
+ MIPS_MAGIC_BIG,
+ /* Little endian magic number. */
+ MIPS_MAGIC_LITTLE,
+ /* Alignment of debugging information. E.g., 4. */
+ 4,
+ /* The page boundary used to align sections in a demand-paged
+ executable file. E.g., 0x1000. */
+ 0x1000,
+ /* Bitsize of constructor entries. */
+ 32,
+ /* Sizes of external symbolic information. */
+ sizeof (struct hdr_ext),
+ sizeof (struct dnr_ext),
+ sizeof (struct pdr_ext),
+ sizeof (struct sym_ext),
+ sizeof (struct opt_ext),
+ sizeof (struct fdr_ext),
+ sizeof (struct rfd_ext),
+ sizeof (struct ext_ext),
+ /* Functions to swap in external symbolic data. */
+ ecoff_swap_hdr_in,
+ ecoff_swap_dnr_in,
+ ecoff_swap_pdr_in,
+ ecoff_swap_sym_in,
+ ecoff_swap_opt_in,
+ ecoff_swap_fdr_in,
+ ecoff_swap_rfd_in,
+ ecoff_swap_ext_in,
+ /* Functions to swap out external symbolic data. */
+ ecoff_swap_hdr_out,
+ ecoff_swap_dnr_out,
+ ecoff_swap_pdr_out,
+ ecoff_swap_sym_out,
+ ecoff_swap_opt_out,
+ ecoff_swap_fdr_out,
+ ecoff_swap_rfd_out,
+ ecoff_swap_ext_out,
+ /* External reloc size. */
+ RELSZ,
+ /* Reloc swapping functions. */
+ mips_ecoff_swap_reloc_in,
+ mips_ecoff_swap_reloc_out
};
-
-
-#define ALIGN(this, boundary) \
- ((( (this) + ((boundary) -1)) & (~((boundary)-1))))
-
-
-/* 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) */
-#define i960_align(addr, align) \
- ( ((addr) + ((1<<(align))-1)) & (-1 << (align)))
-
-#define TAG_SECTION_NAME ".tagbits"
-
-/* Libraries shouldn't be doing this stuff anyway! */
-void fatal();
-/* void warning(); */
\f
+/* See whether the magic number matches. */
-/* initialize a section structure with information
- * peculiar to this particular implementation of coff
- */
-
-static void
-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;
- }
-
-
-
-}
-/* actually it makes itself and its children from the file headers */
static boolean
-make_a_section_from_file (abfd, hdr)
-bfd *abfd;
- struct scnhdr *hdr;
-
+mips_ecoff_bad_format_hook (abfd, filehdr)
+ bfd *abfd;
+ PTR filehdr;
{
- asection *return_section ;
-
- { char *name = (char *)xmalloc(9);
-
- strncpy(name, (char *)&hdr->s_name[0], 8);
-
- return_section = bfd_make_section(abfd, name);
- (return_section->name)[8] = 0;
- }
-
- /* s_paddr is presumed to be = to s_vaddr */
- /* 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 (size, s_size);
- assign (filepos, s_scnptr);
- assign (rel_filepos, s_relptr);
- assign (reloc_count, s_nreloc);
-#ifdef I960
- assign (alignment, s_align);
-#endif
- assign (line_filepos, s_lnnoptr);
-/* return_section->linesize = hdr->s_nlnno * sizeof (struct lineno);*/
-
-#undef assign
- return_section->lineno_count = hdr->s_nlnno;
- return_section->userdata = (void *)NULL;
- return_section->next = (asection *)NULL;
- if ((hdr->s_flags & STYP_TEXT) || (hdr->s_flags & STYP_DATA))
- return_section->flags = (SEC_LOAD | SEC_ALLOC);
- else if (hdr->s_flags & STYP_BSS)
- return_section->flags = SEC_ALLOC;
+ struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
- if (hdr->s_nreloc != 0) return_section->flags |= SEC_RELOC;
+ if (MIPS_ECOFF_BADMAG (*internal_f))
+ return false;
return true;
}
-bfd_target *
-ecoff_real_object_p (abfd, nscns, opthdr)
- bfd *abfd;
- unsigned short nscns, opthdr;
-{
- struct icofdata *tdata;
- char *file_info; /* buffer for all the headers */
- long readsize; /* length of file_info */
- struct filehdr* filehdr; /* points into file_info */
- struct scnhdr *sections; /* points into file_info */
-
- /* 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);
- if (file_info == NULL) {
- bfd_error = no_memory;
- return 0;
- }
- if (bfd_seek (abfd, 0, false) < 0) return 0;
- if (bfd_read (file_info, 1, readsize, abfd) != readsize) return 0;
- filehdr = (struct filehdr *) file_info;
- 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));
- if (tdata == NULL) {
- bfd_error = no_memory;
- return 0;
- }
-
- if (nscns != 0)
- {
- unsigned int i;
- for (i = 0; i < nscns; i++)
- {
- make_a_section_from_file (abfd, sections + i);
- }
- }
-
-#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;
-
-
- /* 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;
- 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;
- return abfd->xvec;
-}
-
-bfd_target *
-ecoff_object_p (abfd)
- bfd *abfd;
-{
- unsigned short magic, nscns, opthdr;
-
- bfd_error = no_error;
-
- /* figure out how much to read */
- if (bfd_read (&magic, 1, sizeof (magic), abfd) != sizeof (magic))
- return 0;
-
- magic = bfd_h_getshort (abfd, (unsigned char *)&magic);
- if (magic != (abfd->xvec->byteorder_big_p ? 0x160 : 0x162)) {
- bfd_error = wrong_format;
- return 0;
- }
- if (bfd_read (&nscns, 1, sizeof (nscns), abfd) != sizeof (nscns))
- return 0;
- nscns = bfd_h_getshort (abfd, (unsigned char *)&nscns);
-
- if (bfd_seek (abfd, ((sizeof (long)) * 3), true) < 0) return false;
- if (bfd_read (&opthdr, 1, sizeof (opthdr), abfd) != sizeof (opthdr))
- return 0;
- opthdr = bfd_h_getshort (abfd, (unsigned char *)&opthdr);
-
- return ecoff_real_object_p (abfd, nscns, opthdr);
-}
+/* Create an ECOFF object. */
static boolean
-ecoff_mkobject (abfd)
+mips_ecoff_mkobject (abfd)
bfd *abfd;
{
- char *rawptr;
-
-
- bfd_error = no_error;
+ abfd->tdata.ecoff_obj_data = ((struct ecoff_tdata *)
+ bfd_zalloc (abfd, sizeof (ecoff_data_type)));
+ if (abfd->tdata.ecoff_obj_data == NULL)
+ {
+ bfd_error = no_memory;
+ return false;
+ }
- /* Use an intermediate variable for clarity */
- rawptr = xmalloc (sizeof (struct icofdata) + sizeof (AOUTHDR));
- if (rawptr == NULL) {
- bfd_error = no_memory;
- return false;
- }
+ ecoff_data (abfd)->backend_data = &mips_ecoff_backend_data;
- abfd->tdata = (struct icofdata *) rawptr;
- exec_hdr (abfd) = (AOUTHDR *) (rawptr + sizeof (struct icofdata));
+ /* Always create a .scommon section for every BFD. This is a hack so
+ that the linker has something to attach scSCommon symbols to. */
+ bfd_make_section (abfd, SCOMMON);
return true;
}
-\f
-static void
-ecoff_count_linenumbers(abfd)
-bfd *abfd;
-{
- unsigned int limit = bfd_get_symcount(abfd);
- unsigned int i = 0;
- esymbol **p = (esymbol **)(abfd->outsymbols);
- {
- asection *s = abfd->sections;
- while (s) {
- if (s->lineno_count != 0) {
- fatal("Bad initial state");
- }
- s = s->next;
- }
- }
- while (i < limit)
- {
- 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++;
- l++;
- }
- }
- p++;
- i++;
- }
-}
-
-/*
- run through the internal symbol table and make all the
- pointers and things within the table point to the right places
- */
+/* Create the MIPS ECOFF backend specific information. */
-static void
-ecoff_mangle_symbols(abfd)
-bfd *abfd;
+static PTR
+mips_ecoff_mkobject_hook (abfd, filehdr, aouthdr)
+ bfd *abfd;
+ PTR filehdr;
+ PTR aouthdr;
{
- 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;
- }
- }
+ struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
+ struct internal_aouthdr *internal_a = (struct internal_aouthdr *) aouthdr;
+ ecoff_data_type *ecoff;
+ if (mips_ecoff_mkobject (abfd) == false)
+ return NULL;
- 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;
+ ecoff = ecoff_data (abfd);
+ ecoff->gp_size = 8;
+ ecoff->sym_filepos = internal_f->f_symptr;
- 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++;
+ if (internal_a != (struct internal_aouthdr *) NULL)
+ {
+ int i;
+
+ ecoff->text_start = internal_a->text_start;
+ ecoff->text_end = internal_a->text_start + internal_a->tsize;
+ ecoff->gp = internal_a->gp_value;
+ ecoff->gprmask = internal_a->gprmask;
+ for (i = 0; i < 4; i++)
+ ecoff->cprmask[i] = internal_a->cprmask[i];
+ if (internal_a->magic == ECOFF_AOUT_ZMAGIC)
+ abfd->flags |= D_PAGED;
}
- p++;
- }
-}
-static void
-ecoff_write_symbols(abfd)
-bfd *abfd;
-{
-}
-
-void
-ecoff_write_linenumbers(abfd)
-bfd *abfd;
-{
-}
-
-
-asymbol *
-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;
-}
-
-/*SUPPRESS 558*/
-/*SUPPRESS 529*/
-boolean
-ecoff_write_object_contents (abfd)
- bfd *abfd;
-{
- return false;
+ return (PTR) ecoff;
}
\f
-/* Calculate the file position for each section. */
+/* Reloc handling. MIPS ECOFF relocs are packed into 8 bytes in
+ external form. They use a bit which indicates whether the symbol
+ is external. */
+
+/* Swap a reloc in. */
static void
-ecoff_compute_section_file_positions (abfd)
+mips_ecoff_swap_reloc_in (abfd, ext_ptr, intern)
bfd *abfd;
+ PTR ext_ptr;
+ struct internal_reloc *intern;
{
- 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;
+ const RELOC *ext = (RELOC *) ext_ptr;
+
+ intern->r_vaddr = bfd_h_get_32 (abfd, (bfd_byte *) ext->r_vaddr);
+ if (abfd->xvec->header_byteorder_big_p != false)
+ {
+ intern->r_symndx = (((int) ext->r_bits[0]
+ << RELOC_BITS0_SYMNDX_SH_LEFT_BIG)
+ | ((int) ext->r_bits[1]
+ << RELOC_BITS1_SYMNDX_SH_LEFT_BIG)
+ | ((int) ext->r_bits[2]
+ << RELOC_BITS2_SYMNDX_SH_LEFT_BIG));
+ intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_BIG)
+ >> RELOC_BITS3_TYPE_SH_BIG);
+ intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_BIG) != 0;
+ }
+ else
+ {
+ intern->r_symndx = (((int) ext->r_bits[0]
+ << RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE)
+ | ((int) ext->r_bits[1]
+ << RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE)
+ | ((int) ext->r_bits[2]
+ << RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE));
+ intern->r_type = ((ext->r_bits[3] & RELOC_BITS3_TYPE_LITTLE)
+ >> RELOC_BITS3_TYPE_SH_LITTLE);
+ intern->r_extern = (ext->r_bits[3] & RELOC_BITS3_EXTERN_LITTLE) != 0;
}
-#endif
- }
- obj_relocbase (abfd) = sofar;
}
-boolean
-ecoff_set_section_contents (abfd, section, location, offset, count)
- bfd *abfd;
- sec_ptr section;
- unsigned char *location;
- file_ptr offset;
- int count;
-{
- return false;
-}
+/* Swap a reloc out. */
-boolean
-ecoff_set_section_linenos (abfd, section, location, offset, count)
+static void
+mips_ecoff_swap_reloc_out (abfd, intern, dst)
bfd *abfd;
- sec_ptr section;
- unsigned char *location;
- file_ptr offset;
- int count;
+ const struct internal_reloc *intern;
+ PTR dst;
{
- return 0;
-}
-\f
+ RELOC *ext = (RELOC *) dst;
-boolean
-ecoff_close_and_cleanup (abfd)
- bfd *abfd;
-{
- return false;
+ bfd_h_put_32 (abfd, intern->r_vaddr, (bfd_byte *) ext->r_vaddr);
+ if (abfd->xvec->header_byteorder_big_p != false)
+ {
+ ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_BIG;
+ ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_BIG;
+ ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_BIG;
+ ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_BIG)
+ & RELOC_BITS3_TYPE_BIG)
+ | (intern->r_extern ? RELOC_BITS3_EXTERN_BIG : 0));
+ }
+ else
+ {
+ ext->r_bits[0] = intern->r_symndx >> RELOC_BITS0_SYMNDX_SH_LEFT_LITTLE;
+ ext->r_bits[1] = intern->r_symndx >> RELOC_BITS1_SYMNDX_SH_LEFT_LITTLE;
+ ext->r_bits[2] = intern->r_symndx >> RELOC_BITS2_SYMNDX_SH_LEFT_LITTLE;
+ ext->r_bits[3] = (((intern->r_type << RELOC_BITS3_TYPE_SH_LITTLE)
+ & RELOC_BITS3_TYPE_LITTLE)
+ | (intern->r_extern ? RELOC_BITS3_EXTERN_LITTLE : 0));
+ }
}
\f
+#ifdef HOST_IRIX4
+#include <core.out.h>
-
-
-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;
-int index;
-{
-if (index > 0) {
- struct sec *answer = abfd->sections;
-
- while (--index) {
- answer = answer->next;
- }
- return answer;
-}
-return 0;
-}
-
-static int
-ecoff_get_symcount_upper_bound (abfd)
- bfd *abfd;
-{
-fatal("call to ecoff_get_symcount_upper_bound");
-return 0;
-}
-
-static symindex
-ecoff_get_first_symbol (abfd)
- bfd * abfd;
-{
- return 0;
-}
-
-static symindex
-ecoff_get_next_symbol (abfd, oidx)
- bfd *abfd;
- symindex oidx;
-{
- if (oidx == BFD_NO_MORE_SYMBOLS) return BFD_NO_MORE_SYMBOLS;
- return ++oidx >= bfd_get_symcount (abfd) ? BFD_NO_MORE_SYMBOLS : oidx;
-}
-
-static char *
-ecoff_symbol_name (abfd, idx)
- bfd *abfd;
- symindex idx;
+struct sgi_core_struct
{
- return (obj_symbols (abfd) + idx)->c.name;
-}
-
-static long
-ecoff_symbol_value (abfd, idx)
- bfd *abfd;
- symindex idx;
-{
- return (obj_symbols (abfd) + idx)->c.value;
-}
-
-static symclass
-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;
+ int sig;
+ char cmd[CORE_NAMESIZE];
+};
- return bfd_symclass_unknown;
-}
+#define core_hdr(bfd) ((bfd)->tdata.sgi_core_data)
+#define core_signal(bfd) (core_hdr(bfd)->sig)
+#define core_command(bfd) (core_hdr(bfd)->cmd)
-static boolean
-ecoff_symbol_hasclass (abfd, idx, class)
+static asection *
+make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
bfd *abfd;
- symindex idx;
- symclass class;
+ CONST char *name;
+ flagword flags;
+ bfd_size_type _raw_size;
+ bfd_vma vma;
+ file_ptr filepos;
{
+ asection *asect;
- 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;
- }
-}
-
-
+ asect = bfd_make_section (abfd, name);
+ if (!asect)
+ return NULL;
+ asect->flags = flags;
+ asect->_raw_size = _raw_size;
+ asect->vma = vma;
+ asect->filepos = filepos;
+ asect->alignment_power = 4;
-static
-boolean
-ecoff_slurp_line_table (abfd, asect)
- bfd *abfd;
- asection *asect;
-{
- return true;
+ return asect;
}
-static boolean
-ecoff_slurp_symbol_table(abfd)
+static bfd_target *
+ecoff_core_file_p (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;
- }
+ int val;
+ int i;
+ char *secname;
+ struct coreout coreout;
+ struct idesc *idg, *idf, *ids;
+ val = bfd_read ((PTR)&coreout, 1, sizeof coreout, abfd);
+ if (val != sizeof coreout)
+ return 0;
- /* Allocate enough room for all the symbols in cached form */
- cached_area = (esymbol *)xmalloc(bfd_get_symcount(abfd) * sizeof(esymbol));
-
+ if (coreout.c_magic != CORE_MAGIC
+ || coreout.c_version != CORE_VERSION1)
+ return 0;
- {
+ core_hdr (abfd) = (struct sgi_core_struct *) bfd_zalloc (abfd, sizeof (struct sgi_core_struct));
+ if (!core_hdr (abfd))
+ return NULL;
- 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 */
+ strncpy (core_command (abfd), coreout.c_name, CORE_NAMESIZE);
+ core_signal (abfd) = coreout.c_sigcause;
- /* 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)) ;
+ bfd_seek (abfd, coreout.c_vmapoffset, SEEK_SET);
- }
- }
+ for (i = 0; i < coreout.c_nvmap; i++)
+ {
+ struct vmap vmap;
+ val = bfd_read ((PTR)&vmap, 1, sizeof vmap, abfd);
+ if (val != sizeof vmap)
+ break;
- dst->c.name = string_table + src->n_offset - 4;
+ switch (vmap.v_type)
+ {
+ case VDATA:
+ secname = ".data";
+ break;
+ case VSTACK:
+ secname = ".stack";
+ break;
+ default:
+ continue;
}
- 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;
+ if (!make_bfd_asection (abfd, secname,
+ SEC_ALLOC+SEC_LOAD+SEC_HAS_CONTENTS,
+ vmap.v_len,
+ vmap.v_vaddr,
+ vmap.v_offset,
+ 2))
+ return NULL;
}
- }
- return true;
-}
-unsigned int
-ecoff_get_symtab_upper_bound (abfd)
- bfd *abfd;
-{
- if (!ecoff_slurp_symbol_table (abfd)) return 0;
+ /* Make sure that the regs are contiguous within the core file. */
- return (bfd_get_symcount (abfd)+1) * (sizeof (esymbol *));
-}
+ idg = &coreout.c_idesc[I_GPREGS];
+ idf = &coreout.c_idesc[I_FPREGS];
+ ids = &coreout.c_idesc[I_SPECREGS];
+ if (idg->i_offset + idg->i_len != idf->i_offset
+ || idf->i_offset + idf->i_len != ids->i_offset)
+ return 0; /* Can't deal with non-contig regs */
-unsigned int
-ecoff_get_symtab(abfd, alocation)
-bfd *abfd;
-asymbol **alocation;
-{
- unsigned int counter = 0;
- esymbol *symbase;
- esymbol **location = (esymbol **)(alocation);
+ bfd_seek (abfd, idg->i_offset, SEEK_SET);
+
+ make_bfd_asection (abfd, ".reg",
+ SEC_ALLOC+SEC_HAS_CONTENTS,
+ idg->i_len + idf->i_len + ids->i_len,
+ 0,
+ idg->i_offset);
- if (!ecoff_slurp_symbol_table (abfd)) return 0;
+ /* OK, we believe you. You're a core file (sure, sure). */
- for (symbase = obj_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
- *(location++) = symbase++;
- *location++ =0;
- return counter;
+ return abfd->xvec;
}
-unsigned int
-ecoff_get_reloc_upper_bound (abfd, asect)
+static char *
+ecoff_core_file_failing_command (abfd)
bfd *abfd;
- sec_ptr asect;
{
- if (bfd_get_format (abfd) != bfd_object) {
- bfd_error = invalid_operation;
- return 0;
- }
-
- return (asect->reloc_count + 1) * sizeof(arelent *);
+ return core_command (abfd);
}
-
-
-
-boolean
-ecoff_slurp_reloc_table (abfd, asect)
+static int
+ecoff_core_file_failing_signal (abfd)
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;
+ return core_signal (abfd);
}
-
-/* This is stupid. This function should be a boolean predicate */
-unsigned int
-ecoff_canonicalize_reloc (abfd, section, relptr)
- bfd *abfd;
- sec_ptr section;
- arelent **relptr;
+static boolean
+ecoff_core_file_matches_executable_p (core_bfd, exec_bfd)
+ bfd *core_bfd, *exec_bfd;
{
- return 0;
+ return true; /* XXX - FIXME */
}
+#else /* not def HOST_IRIX4 */
+#define ecoff_core_file_p _bfd_dummy_target
+#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
+#endif
+\f
+/* This is the COFF backend structure. The backend_data field of the
+ bfd_target structure is set to this. The section reading code in
+ coffgen.c uses this structure. */
+
+static CONST bfd_coff_backend_data mips_ecoff_std_swap_table = {
+ (void (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_in */
+ (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_in */
+ (void (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_in */
+ (unsigned (*) PARAMS ((bfd *,PTR,int,int,PTR))) bfd_void, /* aux_out */
+ (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* sym_out */
+ (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* lineno_out */
+ (unsigned (*) PARAMS ((bfd *,PTR,PTR))) bfd_void, /* reloc_out */
+ mips_ecoff_swap_filehdr_out, mips_ecoff_swap_aouthdr_out,
+ mips_ecoff_swap_scnhdr_out,
+ FILHSZ, AOUTSZ, SCNHSZ, 0, 0, 0, true,
+ mips_ecoff_swap_filehdr_in, mips_ecoff_swap_aouthdr_in,
+ mips_ecoff_swap_scnhdr_in, mips_ecoff_bad_format_hook,
+ ecoff_set_arch_mach_hook, mips_ecoff_mkobject_hook,
+ ecoff_styp_to_sec_flags, ecoff_make_section_hook, ecoff_set_alignment_hook,
+ ecoff_slurp_symbol_table
+};
bfd_target ecoff_little_vec =
- {"ecoff-littlemips", /* name */
- false, /* data byte order is little */
- false, /* header byte order is little */
-
- (HAS_RELOC | EXEC_P | /* object flags */
- 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 */
-
- _do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* data */
- _do_getllong, _do_putllong, _do_getlshort, _do_putlshort, /* hdrs */
-
- {_bfd_dummy_target, ecoff_object_p, /* bfd_check_format */
- bfd_generic_archive_p, _bfd_dummy_target},
- {bfd_false, ecoff_mkobject, bfd_false, /* bfd_set_format */
- bfd_false},
- ecoff_make_empty_symbol,
-
-
- };
+{
+ "ecoff-littlemips", /* name */
+ bfd_target_ecoff_flavour,
+ false, /* data byte order is little */
+ false, /* header byte order is little */
+
+ (HAS_RELOC | EXEC_P | /* object flags */
+ HAS_LINENO | HAS_DEBUG |
+ HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
+
+ (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect
+ flags */
+ 0, /* leading underscore */
+ ' ', /* ar_pad_char */
+ 15, /* ar_max_namelen */
+ 4, /* minimum alignment power */
+ _do_getl64, _do_getl_signed_64, _do_putl64,
+ _do_getl32, _do_getl_signed_32, _do_putl32,
+ _do_getl16, _do_getl_signed_16, _do_putl16, /* data */
+ _do_getl64, _do_getl_signed_64, _do_putl64,
+ _do_getl32, _do_getl_signed_32, _do_putl32,
+ _do_getl16, _do_getl_signed_16, _do_putl16, /* hdrs */
+
+ {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
+ ecoff_archive_p, _bfd_dummy_target},
+ {bfd_false, mips_ecoff_mkobject, /* bfd_set_format */
+ _bfd_generic_mkarchive, bfd_false},
+ {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
+ _bfd_write_archive_contents, bfd_false},
+ JUMP_TABLE (ecoff),
+ (PTR) &mips_ecoff_std_swap_table
+};
bfd_target ecoff_big_vec =
- {"ecoff-bigmips", /* name */
- true, /* data byte order is big */
- true, /* header byte order is big */
-
- (HAS_RELOC | EXEC_P | /* object flags */
- 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 */
-
- _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* data */
- _do_getblong, _do_putblong, _do_getbshort, _do_putbshort, /* hdrs */
-
- {_bfd_dummy_target, ecoff_object_p, /* bfd_check_format */
- 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 */
+{
+ "ecoff-bigmips", /* name */
+ bfd_target_ecoff_flavour,
+ true, /* data byte order is big */
+ true, /* header byte order is big */
+
+ (HAS_RELOC | EXEC_P | /* object flags */
+ HAS_LINENO | HAS_DEBUG |
+ HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
+
+ (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect flags */
+ 0, /* leading underscore */
+ ' ', /* ar_pad_char */
+ 15, /* ar_max_namelen */
+ 4, /* minimum alignment power */
+ _do_getb64, _do_getb_signed_64, _do_putb64,
+ _do_getb32, _do_getb_signed_32, _do_putb32,
+ _do_getb16, _do_getb_signed_16, _do_putb16,
+ _do_getb64, _do_getb_signed_64, _do_putb64,
+ _do_getb32, _do_getb_signed_32, _do_putb32,
+ _do_getb16, _do_getb_signed_16, _do_putb16,
+ {_bfd_dummy_target, coff_object_p, /* bfd_check_format */
+ ecoff_archive_p, ecoff_core_file_p},
+ {bfd_false, mips_ecoff_mkobject, /* bfd_set_format */
+ _bfd_generic_mkarchive, bfd_false},
+ {bfd_false, ecoff_write_object_contents, /* bfd_write_contents */
+ _bfd_write_archive_contents, bfd_false},
+ JUMP_TABLE(ecoff),
+ (PTR) &mips_ecoff_std_swap_table
+ /* Note that there is another bfd_target just above this one. If
+ you are adding initializers here, you should be adding them there
+ as well. */
+};
projects / binutils.git / blobdiff