Subversion Repositories or1k

/* BFD back-end for oasys objects.

   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2001, 2002

   Free Software Foundation, Inc.

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

   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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#define UNDERSCORE_HACK 1

#include "bfd.h"

#include "sysdep.h"

#include "safe-ctype.h"

#include "libbfd.h"

#include "oasys.h"

#include "liboasys.h"

static boolean oasys_slurp_section_data PARAMS ((bfd * const));

static boolean oasys_read_record PARAMS ((bfd *, oasys_record_union_type *));

static boolean oasys_write_sections PARAMS ((bfd *));

static boolean oasys_write_record

  PARAMS ((bfd *, oasys_record_enum_type, oasys_record_union_type *, size_t));

static boolean oasys_write_syms PARAMS ((bfd *));

static boolean oasys_write_header PARAMS ((bfd *));

static boolean oasys_write_end PARAMS ((bfd *));

static boolean oasys_write_data PARAMS ((bfd *));

static size_t oasys_string_length PARAMS ((oasys_record_union_type *));

static boolean oasys_slurp_symbol_table PARAMS ((bfd *const));

static long int oasys_get_symtab_upper_bound PARAMS ((bfd *const));

static const bfd_target *oasys_archive_p PARAMS ((bfd *));

static boolean oasys_mkobject PARAMS ((bfd *));

static const bfd_target *oasys_object_p PARAMS ((bfd *));

static void oasys_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));

static void oasys_print_symbol

  PARAMS ((bfd *, void *, asymbol *, bfd_print_symbol_type));

static boolean oasys_new_section_hook PARAMS ((bfd *, asection *));

static long int oasys_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));

static boolean oasys_get_section_contents

  PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));

static int comp PARAMS ((const void *, const void *));

static boolean oasys_write_object_contents PARAMS ((bfd *));

static boolean oasys_set_section_contents

  PARAMS ((bfd *, sec_ptr, void *, file_ptr, bfd_size_type));

static asymbol *oasys_make_empty_symbol PARAMS ((bfd *));

static bfd *oasys_openr_next_archived_file PARAMS ((bfd *, bfd *));

static boolean oasys_find_nearest_line

  PARAMS ((bfd *, asection *, asymbol **, bfd_vma,

           const char **, const char **, unsigned int *));

static int oasys_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));

static int oasys_sizeof_headers PARAMS ((bfd *, boolean));

long oasys_get_symtab PARAMS ((bfd *, asymbol **));

long oasys_canonicalize_reloc

  PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));

/* Read in all the section data and relocation stuff too.  */

static boolean

oasys_read_record (abfd, record)

     bfd *abfd;

     oasys_record_union_type *record;

{

  bfd_size_type amt = sizeof (record->header);

  if (bfd_bread ((PTR) record, amt, abfd) != amt)

    return false;

  amt = record->header.length - sizeof (record->header);

  if ((long) amt <= 0)

    return true;

  if (bfd_bread ((PTR) ((char *) record + sizeof (record->header)), amt, abfd)

      != amt)

    return false;

  return true;

}

static size_t

oasys_string_length (record)

     oasys_record_union_type *record;

{

  return record->header.length

    - ((char *) record->symbol.name - (char *) record);

}

/*****************************************************************************/

/*

Slurp the symbol table by reading in all the records at the start file

till we get to the first section record.

We'll sort the symbolss into  two lists, defined and undefined. The

undefined symbols will be placed into the table according to their

refno.

We do this by placing all undefined symbols at the front of the table

moving in, and the defined symbols at the end of the table moving back.

*/

static boolean

oasys_slurp_symbol_table (abfd)

     bfd *const abfd;

{

  oasys_record_union_type record;

  oasys_data_type *data = OASYS_DATA (abfd);

  boolean loop = true;

  asymbol *dest_defined;

  asymbol *dest;

  char *string_ptr;

  bfd_size_type amt;

  if (data->symbols != (asymbol *) NULL)

    {

      return true;

    }

  /* Buy enough memory for all the symbols and all the names */

  amt = abfd->symcount;

  amt *= sizeof (asymbol);

  data->symbols = (asymbol *) bfd_alloc (abfd, amt);

  amt = data->symbol_string_length;

#ifdef UNDERSCORE_HACK

  /* buy 1 more char for each symbol to keep the underscore in*/

  amt += abfd->symcount;

#endif

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

  if (!data->symbols || !data->strings)

    return false;

  dest_defined = data->symbols + abfd->symcount - 1;

  string_ptr = data->strings;

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

    return false;

  while (loop)

    {

      if (! oasys_read_record (abfd, &record))

        return false;

      switch (record.header.type)

        {

        case oasys_record_is_header_enum:

          break;

        case oasys_record_is_local_enum:

        case oasys_record_is_symbol_enum:

          {

            int flag = record.header.type == (int) oasys_record_is_local_enum ?

            (BSF_LOCAL) : (BSF_GLOBAL | BSF_EXPORT);

            size_t length = oasys_string_length (&record);

            switch (record.symbol.relb & RELOCATION_TYPE_BITS)

              {

              case RELOCATION_TYPE_ABS:

                dest = dest_defined--;

                dest->section = bfd_abs_section_ptr;

                dest->flags = 0;

                break;

              case RELOCATION_TYPE_REL:

                dest = dest_defined--;

                dest->section =

                  OASYS_DATA (abfd)->sections[record.symbol.relb &

                                              RELOCATION_SECT_BITS];

                if (record.header.type == (int) oasys_record_is_local_enum)

                  {

                    dest->flags = BSF_LOCAL;

                    if (dest->section == (asection *) (~0))

                      {

                        /* It seems that sometimes internal symbols are tied up, but

                       still get output, even though there is no

                       section */

                        dest->section = 0;

                      }

                  }

                else

                  {

                    dest->flags = flag;

                  }

                break;

              case RELOCATION_TYPE_UND:

                dest = data->symbols + H_GET_16 (abfd, record.symbol.refno);

                dest->section = bfd_und_section_ptr;

                break;

              case RELOCATION_TYPE_COM:

                dest = dest_defined--;

                dest->name = string_ptr;

                dest->the_bfd = abfd;

                dest->section = bfd_com_section_ptr;

                break;

              default:

                dest = dest_defined--;

                BFD_ASSERT (0);

                break;

              }

            dest->name = string_ptr;

            dest->the_bfd = abfd;

            dest->udata.p = (PTR) NULL;

            dest->value = H_GET_32 (abfd, record.symbol.value);

#ifdef UNDERSCORE_HACK

            if (record.symbol.name[0] != '_')

              {

                string_ptr[0] = '_';

                string_ptr++;

              }

#endif

            memcpy (string_ptr, record.symbol.name, length);

            string_ptr[length] = 0;

            string_ptr += length + 1;

          }

          break;

        default:

          loop = false;

        }

    }

  return true;

}

static long

oasys_get_symtab_upper_bound (abfd)

     bfd *const abfd;

{

  if (! oasys_slurp_symbol_table (abfd))

    return -1;

  return (abfd->symcount + 1) * (sizeof (oasys_symbol_type *));

}

extern const bfd_target oasys_vec;

long

oasys_get_symtab (abfd, location)

     bfd *abfd;

     asymbol **location;

{

  asymbol *symbase;

  unsigned int counter;

  if (! oasys_slurp_symbol_table (abfd))

    {

      return -1;

    }

  symbase = OASYS_DATA (abfd)->symbols;

  for (counter = 0; counter < abfd->symcount; counter++)

    {

      *(location++) = symbase++;

    }

  *location = 0;

  return abfd->symcount;

}

/***********************************************************************

*  archive stuff

*/

static const bfd_target *

oasys_archive_p (abfd)

     bfd *abfd;

{

  oasys_archive_header_type header;

  oasys_extarchive_header_type header_ext;

  unsigned int i;

  file_ptr filepos;

  bfd_size_type amt;

  amt = sizeof (header_ext);

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

      || bfd_bread ((PTR) &header_ext, amt, abfd) != amt)

    {

      if (bfd_get_error () != bfd_error_system_call)

        bfd_set_error (bfd_error_wrong_format);

      return NULL;

    }

  header.version = H_GET_32 (abfd, header_ext.version);

  header.mod_count = H_GET_32 (abfd, header_ext.mod_count);

  header.mod_tbl_offset = H_GET_32 (abfd, header_ext.mod_tbl_offset);

  header.sym_tbl_size = H_GET_32 (abfd, header_ext.sym_tbl_size);

  header.sym_count = H_GET_32 (abfd, header_ext.sym_count);

  header.sym_tbl_offset = H_GET_32 (abfd, header_ext.sym_tbl_offset);

  header.xref_count = H_GET_32 (abfd, header_ext.xref_count);

  header.xref_lst_offset = H_GET_32 (abfd, header_ext.xref_lst_offset);

  /*

    There isn't a magic number in an Oasys archive, so the best we

    can do to verify reasnableness is to make sure that the values in

    the header are too weird

    */

  if (header.version > 10000 ||

      header.mod_count > 10000 ||

      header.sym_count > 100000 ||

      header.xref_count > 100000)

    return (const bfd_target *) NULL;

  /*

    That all worked, let's buy the space for the header and read in

    the headers.

    */

  {

    oasys_ar_data_type *ar;

    oasys_module_info_type *module;

    oasys_module_table_type record;

    amt = sizeof (oasys_ar_data_type);

    ar = (oasys_ar_data_type *) bfd_alloc (abfd, amt);

    amt = header.mod_count;

    amt *= sizeof (oasys_module_info_type);

    module = (oasys_module_info_type *) bfd_alloc (abfd, amt);

    if (!ar || !module)

      return NULL;

    abfd->tdata.oasys_ar_data = ar;

    ar->module = module;

    ar->module_count = header.mod_count;

    filepos = header.mod_tbl_offset;

    for (i = 0; i < header.mod_count; i++)

      {

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

          return NULL;

        /* There are two ways of specifying the archive header */

        if (0)

          {

            oasys_extmodule_table_type_a_type record_ext;

            amt = sizeof (record_ext);

            if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)

              return NULL;

            record.mod_size = H_GET_32 (abfd, record_ext.mod_size);

            record.file_offset = H_GET_32 (abfd, record_ext.file_offset);

            record.dep_count = H_GET_32 (abfd, record_ext.dep_count);

            record.depee_count = H_GET_32 (abfd, record_ext.depee_count);

            record.sect_count = H_GET_32 (abfd, record_ext.sect_count);

            module[i].name = bfd_alloc (abfd, (bfd_size_type) 33);

            if (!module[i].name)

              return NULL;

            memcpy (module[i].name, record_ext.mod_name, 33);

            filepos +=

              sizeof (record_ext) +

              record.dep_count * 4 +

              record.depee_count * 4 +

              record.sect_count * 8 + 187;

          }

        else

          {

            oasys_extmodule_table_type_b_type record_ext;

            amt = sizeof (record_ext);

            if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)

              return NULL;

            record.mod_size = H_GET_32 (abfd, record_ext.mod_size);

            record.file_offset = H_GET_32 (abfd, record_ext.file_offset);

            record.dep_count = H_GET_32 (abfd, record_ext.dep_count);

            record.depee_count = H_GET_32 (abfd, record_ext.depee_count);

            record.sect_count = H_GET_32 (abfd, record_ext.sect_count);

            record.module_name_size = H_GET_32 (abfd,

                                                record_ext.mod_name_length);

            amt = record.module_name_size;

            module[i].name = bfd_alloc (abfd, amt + 1);

            if (!module[i].name)

              return NULL;

            if (bfd_bread ((PTR) module[i].name, amt, abfd) != amt)

              return NULL;

            module[i].name[record.module_name_size] = 0;

            filepos += (sizeof (record_ext)

                        + record.dep_count * 4

                        + record.module_name_size + 1);

          }

        module[i].size = record.mod_size;

        module[i].pos = record.file_offset;

        module[i].abfd = 0;

      }

  }

  return abfd->xvec;

}

static boolean

oasys_mkobject (abfd)

     bfd *abfd;

{

  bfd_size_type amt = sizeof (oasys_data_type);

  abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, amt);

  return abfd->tdata.oasys_obj_data != NULL;

}

#define MAX_SECS 16

static const bfd_target *

oasys_object_p (abfd)

     bfd *abfd;

{

  oasys_data_type *oasys;

  oasys_data_type *save = OASYS_DATA (abfd);

  boolean loop = true;

  boolean had_usefull = false;

  abfd->tdata.oasys_obj_data = 0;

  oasys_mkobject (abfd);

  oasys = OASYS_DATA (abfd);

  memset ((PTR) oasys->sections, 0xff, sizeof (oasys->sections));

  /* Point to the start of the file */

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

    goto fail;

  oasys->symbol_string_length = 0;

  /* Inspect the records, but only keep the section info -

     remember the size of the symbols

     */

  oasys->first_data_record = 0;

  while (loop)

    {

      oasys_record_union_type record;

      if (! oasys_read_record (abfd, &record))

        goto fail;

      if ((size_t) record.header.length < (size_t) sizeof (record.header))

        goto fail;

      switch ((oasys_record_enum_type) (record.header.type))

        {

        case oasys_record_is_header_enum:

          had_usefull = true;

          break;

        case oasys_record_is_symbol_enum:

        case oasys_record_is_local_enum:

          /* Count symbols and remember their size for a future malloc   */

          abfd->symcount++;

          oasys->symbol_string_length += 1 + oasys_string_length (&record);

          had_usefull = true;

          break;

        case oasys_record_is_section_enum:

          {

            asection *s;

            char *buffer;

            unsigned int section_number;

            if (record.section.header.length != sizeof (record.section))

              {

                goto fail;

              }

            buffer = bfd_alloc (abfd, (bfd_size_type) 3);

            if (!buffer)

              goto fail;

            section_number = record.section.relb & RELOCATION_SECT_BITS;

            sprintf (buffer, "%u", section_number);

            s = bfd_make_section (abfd, buffer);

            oasys->sections[section_number] = s;

            switch (record.section.relb & RELOCATION_TYPE_BITS)

              {

              case RELOCATION_TYPE_ABS:

              case RELOCATION_TYPE_REL:

                break;

              case RELOCATION_TYPE_UND:

              case RELOCATION_TYPE_COM:

                BFD_FAIL ();

              }

            s->_raw_size = H_GET_32 (abfd, record.section.value);

            s->vma = H_GET_32 (abfd, record.section.vma);

            s->flags = 0;

            had_usefull = true;

          }

          break;

        case oasys_record_is_data_enum:

          oasys->first_data_record = bfd_tell (abfd) - record.header.length;

        case oasys_record_is_debug_enum:

        case oasys_record_is_module_enum:

        case oasys_record_is_named_section_enum:

        case oasys_record_is_end_enum:

          if (! had_usefull)

            goto fail;

          loop = false;

          break;

        default:

          goto fail;

        }

    }

  oasys->symbols = (asymbol *) NULL;

  /*

    Oasys support several architectures, but I can't see a simple way

    to discover which one is in a particular file - we'll guess

    */

  bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);

  if (abfd->symcount != 0)

    {

      abfd->flags |= HAS_SYMS;

    }

  /*

    We don't know if a section has data until we've read it..

    */

  oasys_slurp_section_data (abfd);

  return abfd->xvec;

fail:

  (void) bfd_release (abfd, oasys);

  abfd->tdata.oasys_obj_data = save;

  return (const bfd_target *) NULL;

}

static void

oasys_get_symbol_info (ignore_abfd, symbol, ret)

     bfd *ignore_abfd ATTRIBUTE_UNUSED;

     asymbol *symbol;

     symbol_info *ret;

{

  bfd_symbol_info (symbol, ret);

  if (!symbol->section)

    ret->type = (symbol->flags & BSF_LOCAL) ? 'a' : 'A';

}

static void

oasys_print_symbol (abfd, afile, symbol, how)

     bfd *abfd;

     PTR afile;

     asymbol *symbol;

     bfd_print_symbol_type how;

{

  FILE *file = (FILE *) afile;

  switch (how)

    {

    case bfd_print_symbol_name:

    case bfd_print_symbol_more:

      fprintf (file, "%s", symbol->name);

      break;

    case bfd_print_symbol_all:

      {

        const char *section_name = symbol->section == (asection *) NULL ?

        (const char *) "*abs" : symbol->section->name;

        bfd_print_symbol_vandf (abfd, (PTR) file, symbol);

        fprintf (file, " %-5s %s",

                 section_name,

                 symbol->name);

      }

      break;

    }

}

/*

 The howto table is build using the top two bits of a reloc byte to

 index into it. The bits are PCREL,WORD/LONG

*/

static reloc_howto_type howto_table[] =

{

  HOWTO (0, 0, 1, 16, false, 0, complain_overflow_bitfield, 0, "abs16", true, 0x0000ffff, 0x0000ffff, false),

  HOWTO (0, 0, 2, 32, false, 0, complain_overflow_bitfield, 0, "abs32", true, 0xffffffff, 0xffffffff, false),

  HOWTO (0, 0, 1, 16, true, 0, complain_overflow_signed, 0, "pcrel16", true, 0x0000ffff, 0x0000ffff, false),

  HOWTO (0, 0, 2, 32, true, 0, complain_overflow_signed, 0, "pcrel32", true, 0xffffffff, 0xffffffff, false)

};

/* Read in all the section data and relocation stuff too */

static boolean

oasys_slurp_section_data (abfd)

     bfd *const abfd;

{

  oasys_record_union_type record;

  oasys_data_type *data = OASYS_DATA (abfd);

  boolean loop = true;

  oasys_per_section_type *per;

  asection *s;

  bfd_size_type amt;

  /* See if the data has been slurped already .. */

  for (s = abfd->sections; s != (asection *) NULL; s = s->next)

    {

      per = oasys_per_section (s);

      if (per->initialized)

        return true;

    }

  if (data->first_data_record == 0)

    return true;

  if (bfd_seek (abfd, data->first_data_record, SEEK_SET) != 0)

    return false;

  while (loop)

    {

      if (! oasys_read_record (abfd, &record))

        return false;

      switch (record.header.type)

        {

        case oasys_record_is_header_enum:

          break;

        case oasys_record_is_data_enum:

          {

            bfd_byte *src = record.data.data;

            bfd_byte *end_src = ((bfd_byte *) & record) + record.header.length;

            bfd_byte *dst_ptr;

            bfd_byte *dst_base_ptr;

            unsigned int relbit;

            unsigned int count;

            asection *section =

            data->sections[record.data.relb & RELOCATION_SECT_BITS];

            bfd_vma dst_offset;

            per = oasys_per_section (section);

            if (! per->initialized)

              {

                per->data = (bfd_byte *) bfd_zalloc (abfd, section->_raw_size);

                if (!per->data)

                  return false;

                per->reloc_tail_ptr

                  = (oasys_reloc_type **) &section->relocation;

                per->had_vma = false;

                per->initialized = true;