Subversion Repositories openrisc

/* BFD back-end for VERSAdos-E objects.

   Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,

   2006, 2007, 2009 Free Software Foundation, Inc.

   Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.

   Versados is a Motorola trademark.

   This file is part of BFD, the Binary File Descriptor library.

   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 3 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., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

/*

   SUBSECTION

   VERSAdos-E relocatable object file format

   DESCRIPTION

   This module supports reading of VERSAdos relocatable

   object files.

   A VERSAdos file looks like contains

   o Identification Record

   o External Symbol Definition Record

   o Object Text Record

   o End Record.  */

#include "sysdep.h"

#include "bfd.h"

#include "libbfd.h"

#include "libiberty.h"

#define VHEADER '1'

#define VESTDEF '2'

#define VOTR '3'

#define VEND '4'

#define ES_BASE 17              /* First symbol has esdid 17.  */

/* Per file target dependent information.  */

/* One for each section.  */

struct esdid

{

  asection *section;            /* Ptr to bfd version.  */

  unsigned char *contents;      /* Used to build image.  */

  int pc;

  int relocs;                   /* Reloc count, valid end of pass 1.  */

  int donerel;                  /* Have relocs been translated.  */

};

typedef struct versados_data_struct

{

  int es_done;                  /* Count of symbol index, starts at ES_BASE.  */

  asymbol *symbols;             /* Pointer to local symbols.  */

  char *strings;                /* Strings of all the above.  */

  int stringlen;                /* Len of string table (valid end of pass1).  */

  int nsecsyms;                 /* Number of sections.  */

  int ndefs;                    /* Number of exported symbols (they dont get esdids).  */

  int nrefs;                    /* Number of imported symbols  (valid end of pass1).  */

  int ref_idx;                  /* Current processed value of the above.  */

  int def_idx;

  int pass_2_done;

  struct esdid e[16];           /* Per section info.  */

  int alert;                    /* To see if we're trampling.  */

  asymbol *rest[256 - 16];      /* Per symbol info.  */

}

tdata_type;

#define VDATA(abfd)       (abfd->tdata.versados_data)

#define EDATA(abfd, n)    (abfd->tdata.versados_data->e[n])

#define RDATA(abfd, n)    (abfd->tdata.versados_data->rest[n])

struct ext_otr

{

  unsigned char size;

  char type;

  unsigned char map[4];

  unsigned char esdid;

  unsigned char data[200];

};

struct ext_vheader

{

  unsigned char size;

  char type;                    /* Record type.  */

  char name[10];                /* Module name.  */

  char rev;                     /* Module rev number.  */

  char lang;

  char vol[4];

  char user[2];

  char cat[8];

  char fname[8];

  char ext[2];

  char time[3];

  char date[3];

  char rest[211];

};

struct ext_esd

{

  unsigned char size;

  char type;

  unsigned char esd_entries[1];

};

#define ESD_ABS           0

#define ESD_COMMON        1

#define ESD_STD_REL_SEC   2

#define ESD_SHRT_REL_SEC  3

#define ESD_XDEF_IN_SEC   4

#define ESD_XDEF_IN_ABS   5

#define ESD_XREF_SEC      6

#define ESD_XREF_SYM      7

union ext_any

{

  unsigned char size;

  struct ext_vheader header;

  struct ext_esd esd;

  struct ext_otr otr;

};

/* Initialize by filling in the hex conversion array.  */

/* Set up the tdata information.  */

static bfd_boolean

versados_mkobject (bfd *abfd)

{

  if (abfd->tdata.versados_data == NULL)

    {

      bfd_size_type amt = sizeof (tdata_type);

      tdata_type *tdata = bfd_alloc (abfd, amt);

      if (tdata == NULL)

        return FALSE;

      abfd->tdata.versados_data = tdata;

      tdata->symbols = NULL;

      VDATA (abfd)->alert = 0x12345678;

    }

  bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);

  return TRUE;

}

/* Report a problem in an S record file.  FIXME: This probably should

   not call fprintf, but we really do need some mechanism for printing

   error messages.  */

static asymbol *

versados_new_symbol (bfd *abfd,

                     int snum,

                     const char *name,

                     bfd_vma val,

                     asection *sec)

{

  asymbol *n = VDATA (abfd)->symbols + snum;

  n->name = name;

  n->value = val;

  n->section = sec;

  n->the_bfd = abfd;

  n->flags = 0;

  return n;

}

static int

get_record (bfd *abfd, union ext_any *ptr)

{

  if (bfd_bread (&ptr->size, (bfd_size_type) 1, abfd) != 1

      || (bfd_bread ((char *) ptr + 1, (bfd_size_type) ptr->size, abfd)

          != ptr->size))

    return 0;

  return 1;

}

static int

get_4 (unsigned char **pp)

{

  unsigned char *p = *pp;

  *pp += 4;

  return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3] << 0);

}

static void

get_10 (unsigned char **pp, char *name)

{

  char *p = (char *) *pp;

  int len = 10;

  *pp += len;

  while (*p != ' ' && len)

    {

      *name++ = *p++;

      len--;

    }

  *name = 0;

}

static char *

new_symbol_string (bfd *abfd, const char *name)

{

  char *n = VDATA (abfd)->strings;

  strcpy (VDATA (abfd)->strings, name);

  VDATA (abfd)->strings += strlen (VDATA (abfd)->strings) + 1;

  return n;

}

static void

process_esd (bfd *abfd, struct ext_esd *esd, int pass)

{

  /* Read through the ext def for the est entries.  */

  int togo = esd->size - 2;

  bfd_vma size;

  bfd_vma start;

  asection *sec;

  char name[11];

  unsigned char *ptr = esd->esd_entries;

  unsigned char *end = ptr + togo;

  while (ptr < end)

    {

      int scn = *ptr & 0xf;

      int typ = (*ptr >> 4) & 0xf;

      /* Declare this section.  */

      sprintf (name, "%d", scn);

      sec = bfd_make_section_old_way (abfd, strdup (name));

      sec->target_index = scn;

      EDATA (abfd, scn).section = sec;

      ptr++;

      switch (typ)

        {

        default:

          abort ();

        case ESD_XREF_SEC:

        case ESD_XREF_SYM:

          {

            int snum = VDATA (abfd)->ref_idx++;

            get_10 (&ptr, name);

            if (pass == 1)

              VDATA (abfd)->stringlen += strlen (name) + 1;

            else

              {

                int esidx;

                asymbol *s;

                char *n = new_symbol_string (abfd, name);

                s = versados_new_symbol (abfd, snum, n, (bfd_vma) 0,

                                         bfd_und_section_ptr);

                esidx = VDATA (abfd)->es_done++;

                RDATA (abfd, esidx - ES_BASE) = s;

              }

          }

          break;

        case ESD_ABS:

          size = get_4 (&ptr);

          start = get_4 (&ptr);

          break;

        case ESD_STD_REL_SEC:

        case ESD_SHRT_REL_SEC:

          sec->size = get_4 (&ptr);

          sec->flags |= SEC_ALLOC;

          break;

        case ESD_XDEF_IN_ABS:

          sec = (asection *) & bfd_abs_section;

        case ESD_XDEF_IN_SEC:

          {

            int snum = VDATA (abfd)->def_idx++;

            bfd_vma val;

            get_10 (&ptr, name);

            val = get_4 (&ptr);

            if (pass == 1)

              /* Just remember the symbol.  */

              VDATA (abfd)->stringlen += strlen (name) + 1;

            else

              {

                asymbol *s;

                char *n = new_symbol_string (abfd, name);

                s = versados_new_symbol (abfd, snum + VDATA (abfd)->nrefs, n,

                                         val, sec);

                s->flags |= BSF_GLOBAL;

              }

          }

          break;

        }

    }

}

#define R_RELWORD     1

#define R_RELLONG     2

#define R_RELWORD_NEG 3

#define R_RELLONG_NEG 4

reloc_howto_type versados_howto_table[] =

{

  HOWTO (R_RELWORD, 0, 1, 16, FALSE,

         0, complain_overflow_dont, 0,

         "+v16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),

  HOWTO (R_RELLONG, 0, 2, 32, FALSE,

         0, complain_overflow_dont, 0,

         "+v32", TRUE, 0xffffffff, 0xffffffff, FALSE),

  HOWTO (R_RELWORD_NEG, 0, -1, 16, FALSE,

         0, complain_overflow_dont, 0,

         "-v16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),

  HOWTO (R_RELLONG_NEG, 0, -2, 32, FALSE,

         0, complain_overflow_dont, 0,

         "-v32", TRUE, 0xffffffff, 0xffffffff, FALSE),

};

static int

get_offset (int len, unsigned char *ptr)

{

  int val = 0;

  if (len)

    {

      int i;

      val = *ptr++;

      if (val & 0x80)

        val |= ~0xff;

      for (i = 1; i < len; i++)

        val = (val << 8) | *ptr++;

    }

  return val;

}

static void

process_otr (bfd *abfd, struct ext_otr *otr, int pass)

{

  unsigned long shift;

  unsigned char *srcp = otr->data;

  unsigned char *endp = (unsigned char *) otr + otr->size;

  unsigned int bits = (otr->map[0] << 24)

  | (otr->map[1] << 16)

  | (otr->map[2] << 8)

  | (otr->map[3] << 0);

  struct esdid *esdid = &EDATA (abfd, otr->esdid - 1);

  unsigned char *contents = esdid->contents;

  int need_contents = 0;

  unsigned int dst_idx = esdid->pc;

  for (shift = ((unsigned long) 1 << 31); shift && srcp < endp; shift >>= 1)

    {

      if (bits & shift)

        {

          int flag = *srcp++;

          int esdids = (flag >> 5) & 0x7;

          int sizeinwords = ((flag >> 3) & 1) ? 2 : 1;

          int offsetlen = flag & 0x7;

          int j;

          if (esdids == 0)

            {

              /* A zero esdid means the new pc is the offset given.  */

              dst_idx += get_offset (offsetlen, srcp);

              srcp += offsetlen;

            }

          else

            {

              int val = get_offset (offsetlen, srcp + esdids);

              if (pass == 1)

                need_contents = 1;

              else

                for (j = 0; j < sizeinwords * 2; j++)

                  {

                    contents[dst_idx + (sizeinwords * 2) - j - 1] = val;

                    val >>= 8;

                  }

              for (j = 0; j < esdids; j++)

                {

                  int esdid = *srcp++;

                  if (esdid)

                    {

                      int rn = EDATA (abfd, otr->esdid - 1).relocs++;

                      if (pass == 1)

                        {

                          /* This is the first pass over the data,

                             just remember that we need a reloc.  */

                        }

                      else

                        {

                          arelent *n =

                          EDATA (abfd, otr->esdid - 1).section->relocation + rn;

                          n->address = dst_idx;

                          n->sym_ptr_ptr = (asymbol **) (size_t) esdid;

                          n->addend = 0;

                          n->howto = versados_howto_table + ((j & 1) * 2) + (sizeinwords - 1);

                        }

                    }

                }

              srcp += offsetlen;

              dst_idx += sizeinwords * 2;

            }

        }

      else

        {

          need_contents = 1;

          if (dst_idx < esdid->section->size)

            if (pass == 2)

              {

                /* Absolute code, comes in 16 bit lumps.  */

                contents[dst_idx] = srcp[0];

                contents[dst_idx + 1] = srcp[1];

              }

          dst_idx += 2;

          srcp += 2;

        }

    }

  EDATA (abfd, otr->esdid - 1).pc = dst_idx;

  if (!contents && need_contents)

    {

      bfd_size_type size = esdid->section->size;

      esdid->contents = bfd_alloc (abfd, size);

    }

}

static bfd_boolean

versados_scan (bfd *abfd)

{

  int loop = 1;

  int i;

  int j;

  int nsecs = 0;

  bfd_size_type amt;

  VDATA (abfd)->stringlen = 0;

  VDATA (abfd)->nrefs = 0;

  VDATA (abfd)->ndefs = 0;

  VDATA (abfd)->ref_idx = 0;

  VDATA (abfd)->def_idx = 0;

  VDATA (abfd)->pass_2_done = 0;

  while (loop)

    {

      union ext_any any;

      if (!get_record (abfd, &any))

        return TRUE;

      switch (any.header.type)

        {

        case VHEADER:

          break;

        case VEND:

          loop = 0;

          break;

        case VESTDEF:

          process_esd (abfd, &any.esd, 1);

          break;

        case VOTR:

          process_otr (abfd, &any.otr, 1);

          break;

        }

    }

  /* Now allocate space for the relocs and sections.  */

  VDATA (abfd)->nrefs = VDATA (abfd)->ref_idx;

  VDATA (abfd)->ndefs = VDATA (abfd)->def_idx;

  VDATA (abfd)->ref_idx = 0;

  VDATA (abfd)->def_idx = 0;

  abfd->symcount = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs;

  for (i = 0; i < 16; i++)

    {

      struct esdid *esdid = &EDATA (abfd, i);

      if (esdid->section)

        {

          amt = (bfd_size_type) esdid->relocs * sizeof (arelent);

          esdid->section->relocation = bfd_alloc (abfd, amt);

          esdid->pc = 0;

          if (esdid->contents)

            esdid->section->flags |= SEC_HAS_CONTENTS | SEC_LOAD;

          esdid->section->reloc_count = esdid->relocs;

          if (esdid->relocs)

            esdid->section->flags |= SEC_RELOC;

          esdid->relocs = 0;

          /* Add an entry into the symbol table for it.  */

          nsecs++;

          VDATA (abfd)->stringlen += strlen (esdid->section->name) + 1;

        }

    }

  abfd->symcount += nsecs;

  amt = abfd->symcount;

  amt *= sizeof (asymbol);

  VDATA (abfd)->symbols = bfd_alloc (abfd, amt);

  amt = VDATA (abfd)->stringlen;

  VDATA (abfd)->strings = bfd_alloc (abfd, amt);

  if ((VDATA (abfd)->symbols == NULL && abfd->symcount > 0)

      || (VDATA (abfd)->strings == NULL && VDATA (abfd)->stringlen > 0))

    return FALSE;

  /* Actually fill in the section symbols,

     we stick them at the end of the table.  */

  for (j = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs, i = 0; i < 16; i++)

    {

      struct esdid *esdid = &EDATA (abfd, i);

      asection *sec = esdid->section;

      if (sec)

        {

          asymbol *s = VDATA (abfd)->symbols + j;

          s->name = new_symbol_string (abfd, sec->name);

          s->section = sec;

          s->flags = BSF_LOCAL;

          s->value = 0;

          s->the_bfd = abfd;

          j++;

        }

    }

  if (abfd->symcount)

    abfd->flags |= HAS_SYMS;

  /* Set this to nsecs - since we've already planted the section

     symbols.  */

  VDATA (abfd)->nsecsyms = nsecs;

  VDATA (abfd)->ref_idx = 0;

  return 1;

}

/* Check whether an existing file is a versados  file.  */

static const bfd_target *

versados_object_p (bfd *abfd)

{

  struct ext_vheader ext;

  unsigned char len;

  tdata_type *tdata_save;

  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

    return NULL;

  if (bfd_bread (&len, (bfd_size_type) 1, abfd) != 1)

    {

      if (bfd_get_error () != bfd_error_system_call)

        bfd_set_error (bfd_error_wrong_format);

      return NULL;

    }

  if (bfd_bread (&ext.type, (bfd_size_type) len, abfd) != len)

    {

      if (bfd_get_error () != bfd_error_system_call)

        bfd_set_error (bfd_error_wrong_format);

      return NULL;

    }

  /* We guess that the language field will never be larger than 10.

     In sample files, it is always either 0 or 1.  Checking for this

     prevents confusion with Intel Hex files.  */

  if (ext.type != VHEADER

      || ext.lang > 10)

    {

      bfd_set_error (bfd_error_wrong_format);

      return NULL;

    }

  /* OK, looks like a record, build the tdata and read in.  */

  tdata_save = abfd->tdata.versados_data;

  if (!versados_mkobject (abfd) || !versados_scan (abfd))

    {

      abfd->tdata.versados_data = tdata_save;

      return NULL;

    }

  return abfd->xvec;

}

static bfd_boolean

versados_pass_2 (bfd *abfd)

{

  union ext_any any;

  if (VDATA (abfd)->pass_2_done)

    return 1;

  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)

    return 0;

  VDATA (abfd)->es_done = ES_BASE;

  /* Read records till we get to where we want to be.  */

  while (1)

    {

      get_record (abfd, &any);

      switch (any.header.type)

        {

        case VEND:

          VDATA (abfd)->pass_2_done = 1;

          return 1;

        case VESTDEF:

          process_esd (abfd, &any.esd, 2);

          break;

        case VOTR:

          process_otr (abfd, &any.otr, 2);

          break;

        }

    }

}

static bfd_boolean

versados_get_section_contents (bfd *abfd,

                               asection *section,

                               void * location,

                               file_ptr offset,

                               bfd_size_type count)

{

  if (!versados_pass_2 (abfd))

    return FALSE;

  memcpy (location,

          EDATA (abfd, section->target_index).contents + offset,

          (size_t) count);