Subversion Repositories openrisc

/* vms.c -- BFD back-end for VAX (openVMS/VAX) and

   EVAX (openVMS/Alpha) files.

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

   2006, 2007, 2008, 2009 Free Software Foundation, Inc.

   Main file.

   Written by Klaus K"ampf (kkaempf@rmi.de)

   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.  */

#ifdef VMS

#include <rms.h>

#include <unixlib.h>

#include <starlet.h>

#define RME$C_SETRFM 0x00000001

#include <unistd.h>

#endif

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "vms.h"

static bfd_boolean vms_initialize (bfd *);

static bfd_boolean fill_section_ptr (struct bfd_hash_entry *, PTR);

static bfd_boolean vms_fixup_sections (bfd *);

static bfd_boolean copy_symbols (struct bfd_hash_entry *, PTR);

static bfd_reloc_status_type reloc_nil (bfd *, arelent *, asymbol *, PTR,

                                        asection *, bfd *, char **);

static int vms_slurp_module (bfd *abfd);

static int vms_slurp_image (bfd *abfd);

static const struct bfd_target *vms_object_p (bfd *abfd);

static bfd_boolean vms_mkobject (bfd *abfd);

static bfd_boolean vms_write_object_contents (bfd *abfd);

static void free_reloc_stream (bfd *abfd, asection *section, void *data);

static bfd_boolean vms_close_and_cleanup (bfd *abfd);

static bfd_boolean vms_new_section_hook (bfd *abfd, asection *section);

static bfd_boolean vms_get_section_contents

  (bfd *abfd, asection *section, PTR x1, file_ptr x2, bfd_size_type x3);

static long vms_get_symtab_upper_bound (bfd *abfd);

static long vms_canonicalize_symtab (bfd *abfd, asymbol **symbols);

static void vms_print_symbol (bfd *abfd, PTR file, asymbol *symbol,

                              bfd_print_symbol_type how);

static void vms_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret);

static bfd_boolean vms_bfd_is_local_label_name (bfd *abfd, const char *);

static bfd_boolean vms_find_nearest_line

  (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,

   const char **file, const char **func, unsigned int *line);

static void alloc_reloc_stream (bfd *abfd, asection *section,

                                void *alloc_error);

static bfd_boolean vms_slurp_reloc_table (bfd *abfd, asection *section,

                                          asymbol **symbols);

static long vms_get_reloc_upper_bound (bfd *abfd, asection *sect);

static long vms_canonicalize_reloc (bfd *abfd, asection *srcsec,

                                    arelent **location, asymbol **symbols);

static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup

  (bfd *abfd, bfd_reloc_code_real_type code);

static bfd_boolean vms_set_arch_mach

  (bfd *abfd, enum bfd_architecture arch, unsigned long mach);

static bfd_boolean vms_set_section_contents

  (bfd *abfd, asection *section, const PTR location, file_ptr offset,

   bfd_size_type count);

#define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)

#define vms_make_empty_symbol             _bfd_generic_make_empty_symbol

#define vms_bfd_link_just_syms            _bfd_generic_link_just_syms

#define vms_bfd_copy_link_hash_symbol_type \

  _bfd_generic_copy_link_hash_symbol_type

#define vms_bfd_is_group_section          bfd_generic_is_group_section

#define vms_bfd_discard_group             bfd_generic_discard_group

#define vms_section_already_linked        _bfd_generic_section_already_linked

#define vms_bfd_define_common_symbol      bfd_generic_define_common_symbol

#define vms_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data

#define vms_get_synthetic_symtab          _bfd_nodynamic_get_synthetic_symtab

#define vms_bfd_copy_private_bfd_data     _bfd_generic_bfd_copy_private_bfd_data

#define vms_bfd_free_cached_info          _bfd_generic_bfd_free_cached_info

#define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data

#define vms_bfd_copy_private_symbol_data  _bfd_generic_bfd_copy_private_symbol_data

#define vms_bfd_set_private_flags         _bfd_generic_bfd_set_private_flags

#define vms_bfd_merge_private_bfd_data    _bfd_generic_bfd_merge_private_bfd_data

#define vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window

#define vms_read_minisymbols               _bfd_generic_read_minisymbols

#define vms_minisymbol_to_symbol           _bfd_generic_minisymbol_to_symbol

#define vms_get_lineno                     _bfd_nosymbols_get_lineno

#define vms_find_inliner_info              _bfd_nosymbols_find_inliner_info

#define vms_bfd_make_debug_symbol          _bfd_nosymbols_bfd_make_debug_symbol

#ifdef VMS_DEBUG

/* Cause debug info to be emitted for the structure.  */

struct vms_private_data_struct _vms_private_data_struct_dummy;

struct vms_section_data_struct _vms_section_data_struct_dummy;

#endif

extern const bfd_target vms_vax_vec;

extern const bfd_target vms_alpha_vec;

/* Initialize private data  */

static bfd_boolean

vms_initialize (bfd * abfd)

{

  bfd_size_type amt;

  bfd_set_start_address (abfd, (bfd_vma) -1);

  amt = sizeof (struct vms_private_data_struct);

  abfd->tdata.any = bfd_zalloc (abfd, amt);

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

    return FALSE;

  if (bfd_get_flavour (abfd) == bfd_target_ovax_flavour)

    PRIV (is_vax) = TRUE;

  PRIV (file_format) = FF_UNKNOWN;

  amt = sizeof (struct stack_struct) * STACKSIZE;

  PRIV (stack) = bfd_alloc (abfd, amt);

  if (PRIV (stack) == NULL)

    goto error_ret1;

  amt = sizeof (struct bfd_hash_table);

  PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);

  if (PRIV (vms_symbol_table) == NULL)

    goto error_ret1;

  if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc,

                            sizeof (vms_symbol_entry)))

    goto error_ret1;

  amt = MAX_OUTREC_SIZE;

  PRIV (output_buf) = bfd_alloc (abfd, amt);

  if (PRIV (output_buf) == NULL)

    goto error_ret2;

  PRIV (length_pos) = 2;

  return TRUE;

 error_ret2:

  bfd_hash_table_free (PRIV (vms_symbol_table));

 error_ret1:

  bfd_release (abfd, abfd->tdata.any);

  abfd->tdata.any = NULL;

  return FALSE;

}

struct pair

{

  unsigned int section_count;

  asection **sections;

};

/* Fill symbol->section with section pointer.

   symbol->section is filled with the section index for defined symbols

   during reading the GSD/EGSD section.  But we need the pointer to the

   bfd section later.

   It has the correct value for referenced (undefined section) symbols.

   Called from bfd_hash_traverse in vms_fixup_sections.  */

static bfd_boolean

fill_section_ptr (struct bfd_hash_entry *entry, void *sections)

{

  asymbol *sym = ((vms_symbol_entry *)entry)->symbol;

  struct pair *data = (struct pair *)sections;

  unsigned long sec = (unsigned long)sym->section;

  vms_debug2 ((6, "fill_section_ptr: sym %p, sec %lu\n", sym, sec));

  if (sec < data->section_count)

    {

      sym->section = data->sections[sec];

      if (strcmp (sym->name, sym->section->name) == 0)

        sym->flags |= BSF_SECTION_SYM;

    }

  else if (sec == (unsigned long)-1)

    sym->section = &bfd_und_section;

  return TRUE;

}

/* Fixup section pointers in symbols.  */

static bfd_boolean

vms_fixup_sections (bfd * abfd)

{

  struct pair data;

  if (PRIV (fixup_done))

    return TRUE;

  data.section_count = PRIV (section_count);

  data.sections = PRIV (sections);

  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, &data);

  PRIV (fixup_done) = TRUE;

  return TRUE;

}

/* Slurp an ordered set of VMS object records.  */

int

_bfd_vms_slurp_object_records (bfd * abfd)

{

  int err, new_type, type = -1;

  do

    {

      vms_debug2 ((7, "reading at %08lx\n", bfd_tell (abfd)));

      new_type = _bfd_vms_get_object_record (abfd);

      if (new_type < 0)

        {

          vms_debug2 ((2, "next_record failed\n"));

          return -1;

        }

      if (type == EOBJ_S_C_EGSD && new_type != EOBJ_S_C_EGSD)

        {

          if (! vms_fixup_sections (abfd))

            {

              vms_debug2 ((2, "vms_fixup_sections failed\n"));

              return -1;

            }

        }

      type = new_type;

      switch (type)

        {

          case OBJ_S_C_HDR:

          case EOBJ_S_C_EMH:

            err = _bfd_vms_slurp_hdr (abfd, type);

            break;

          case OBJ_S_C_EOM:

          case OBJ_S_C_EOMW:

          case EOBJ_S_C_EEOM:

            err = _bfd_vms_slurp_eom (abfd, type);

            break;

          case OBJ_S_C_GSD:

          case EOBJ_S_C_EGSD:

            err = _bfd_vms_slurp_gsd (abfd, type);

            break;

          case OBJ_S_C_TIR:

          case EOBJ_S_C_ETIR:

            err = _bfd_vms_slurp_tir (abfd, type);

            break;

          case OBJ_S_C_DBG:

          case EOBJ_S_C_EDBG:

            err = _bfd_vms_slurp_dbg (abfd, type);

            PRIV (dst_ptr_end) = PRIV (image_ptr);

            break;

          case OBJ_S_C_TBT:

          case EOBJ_S_C_ETBT:

            err = _bfd_vms_slurp_tbt (abfd, type);

            PRIV (dst_ptr_end) = PRIV (image_ptr);

            break;

          case OBJ_S_C_LNK:

            err = _bfd_vms_slurp_lnk (abfd, type);

            break;

          default:

            err = -1;

        }

      if (err != 0)

        {

          vms_debug2 ((2, "slurp type %d failed with %d\n", type, err));

          return err;

        }

    }

  while (type != EOBJ_S_C_EEOM && type != OBJ_S_C_EOM && type != OBJ_S_C_EOMW);

  return 0;

}

/* Slurp a VMS module and return an error status.  */

static int

vms_slurp_module (bfd *abfd)

{

  int type, err;

  if (PRIV (is_vax))

    type = PRIV (vms_rec)[0];

  else

    type = bfd_getl16 (PRIV (vms_rec));

  err = _bfd_vms_slurp_hdr (abfd, type);

  if (err != 0)

    {

      bfd_set_error (bfd_error_wrong_format);

      return err;

    }

  return _bfd_vms_slurp_object_records (abfd);

}

/* Slurp a VMS image and return an error status.  */

static int

vms_slurp_image (bfd *abfd)

{

  unsigned int isd_offset, ihs_offset;

  int err;

  err = _bfd_vms_slurp_ihd (abfd, &isd_offset, &ihs_offset);

  if (err != 0)

    {

      bfd_set_error (bfd_error_wrong_format);

      return err;

    }

  err = _bfd_vms_slurp_isd (abfd, isd_offset);

  if (err != 0)

    {

      bfd_set_error (bfd_error_wrong_format);

      return err;

    }

  return _bfd_vms_slurp_ihs (abfd, ihs_offset);

}

/* Check the format for a file being read.

   Return a (bfd_target *) if it's an object file or zero if not.  */

static const struct bfd_target *

vms_object_p (bfd *abfd)

{

  const struct bfd_target *target_vector;

  const bfd_arch_info_type *arch;

  PTR tdata_save = abfd->tdata.any;

  bfd_vma saddr_save = bfd_get_start_address (abfd);

  int err = 0;

  vms_debug2 ((1, "vms_object_p(%p)\n", abfd));

  if (!vms_initialize (abfd))

    goto error_ret;

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

    goto err_wrong_format;

  switch (_bfd_vms_get_first_record (abfd))

    {

    case FT_UNKNOWN:

    default:

      err = -1;

      break;

    case FT_MODULE:

      err = vms_slurp_module (abfd);

      break;

    case FT_IMAGE:

      err = vms_slurp_image (abfd);

      break;

    }

  if (err != 0)

    goto err_wrong_format;

  if (PRIV (is_vax))

    {

      if (! vms_fixup_sections (abfd))

        {

          vms_debug2 ((2, "vms_fixup_sections failed\n"));

          goto err_wrong_format;

        }

      target_vector = &vms_vax_vec;

      arch = bfd_scan_arch ("vax");

      vms_debug2 ((2, "arch is vax\n"));

    }

  else

    {

      /* Set arch_info to alpha.   */

      target_vector = &vms_alpha_vec;

      arch = bfd_scan_arch ("alpha");

      vms_debug2 ((2, "arch is alpha\n"));

    }

  abfd->arch_info = arch;

  return target_vector;

 err_wrong_format:

  bfd_set_error (bfd_error_wrong_format);

 error_ret:

  if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)

    bfd_release (abfd, abfd->tdata.any);

  abfd->tdata.any = tdata_save;

  bfd_set_start_address (abfd, saddr_save);

  return NULL;

}

/* Set the format of a file being written.  */

static bfd_boolean

vms_mkobject (bfd * abfd)

{

  const bfd_arch_info_type *arch;

  vms_debug2 ((1, "vms_mkobject (%p)\n", abfd));

  if (!vms_initialize (abfd))

    return FALSE;

  if (PRIV (is_vax))

    arch = bfd_scan_arch ("vax");

  else

    arch = bfd_scan_arch ("alpha");

  if (arch == 0)

    {

      bfd_set_error(bfd_error_wrong_format);

      return FALSE;

    }

  abfd->arch_info = arch;

  return TRUE;

}

/* Write cached information into a file being written, at bfd_close.  */

static bfd_boolean

vms_write_object_contents (bfd * abfd)

{

  vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));

  if (abfd->section_count > 0)                   /* we have sections */

    {

      if (PRIV (is_vax))

        {

          if (_bfd_vms_write_hdr (abfd, OBJ_S_C_HDR) != 0)

            return FALSE;

          if (_bfd_vms_write_gsd (abfd, OBJ_S_C_GSD) != 0)

            return FALSE;

          if (_bfd_vms_write_tir (abfd, OBJ_S_C_TIR) != 0)

            return FALSE;

          if (_bfd_vms_write_tbt (abfd, OBJ_S_C_TBT) != 0)

            return FALSE;

          if (_bfd_vms_write_dbg (abfd, OBJ_S_C_DBG) != 0)

            return FALSE;

          if (abfd->section_count > 255)

            {

              if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOMW) != 0)

                return FALSE;

            }

          else

            {

              if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOM) != 0)

                return FALSE;

            }

        }

      else

        {

          if (_bfd_vms_write_hdr (abfd, EOBJ_S_C_EMH) != 0)

            return FALSE;

          if (_bfd_vms_write_gsd (abfd, EOBJ_S_C_EGSD) != 0)

            return FALSE;

          if (_bfd_vms_write_tir (abfd, EOBJ_S_C_ETIR) != 0)

            return FALSE;

          if (_bfd_vms_write_tbt (abfd, EOBJ_S_C_ETBT) != 0)

            return FALSE;

          if (_bfd_vms_write_dbg (abfd, EOBJ_S_C_EDBG) != 0)

            return FALSE;

          if (_bfd_vms_write_eom (abfd, EOBJ_S_C_EEOM) != 0)

            return FALSE;

        }

    }

  return TRUE;

}

/* 4.1, generic.  */

/* Free the reloc buffer for the specified section.  */

static void

free_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,

                   void *data ATTRIBUTE_UNUSED)

{

  if (vms_section_data (section)->reloc_stream)

    free (vms_section_data (section)->reloc_stream);

}

#ifdef VMS

/* Convert the file to variable record length format. This is done

   using undocumented system call sys$modify().

   Pure VMS version.  */

static void

vms_convert_to_var (char *vms_filename)

{

  struct FAB fab = cc$rms_fab;

  fab.fab$l_fna = vms_filename;

  fab.fab$b_fns = strlen (vms_filename);

  fab.fab$b_fac = FAB$M_PUT;

  fab.fab$l_fop = FAB$M_ESC;

  fab.fab$l_ctx = RME$C_SETRFM;

  sys$open (&fab);

  fab.fab$b_rfm = FAB$C_VAR;

  sys$modify (&fab);

  sys$close (&fab);

}

static int

vms_convert_to_var_1 (char *filename, int type)

{

  if (type != DECC$K_FILE)

    return FALSE;

  vms_convert_to_var (filename);

  return TRUE;

}

/* Convert the file to variable record length format. This is done

   using undocumented system call sys$modify().

   Unix filename version.  */

static int

vms_convert_to_var_unix_filename (const char *unix_filename)

{

  if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)

    return FALSE;

  return TRUE;

}

#endif /* VMS */

/* Called when the BFD is being closed to do any necessary cleanup.  */

static bfd_boolean

vms_close_and_cleanup (bfd * abfd)

{

  vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));

  if (abfd == NULL || abfd->tdata.any == NULL)

    return TRUE;

  if (PRIV (vms_buf) != NULL)

    free (PRIV (vms_buf));

  if (PRIV (sections) != NULL)

    free (PRIV (sections));

  if (PRIV (vms_symbol_table))

    bfd_hash_table_free (PRIV (vms_symbol_table));

  bfd_map_over_sections (abfd, free_reloc_stream, NULL);

  bfd_release (abfd, abfd->tdata.any);

  abfd->tdata.any = NULL;

#ifdef VMS

  if (abfd->direction == write_direction)

    {

      /* Last step on VMS is to convert the file to variable record length

         format.  */

      if (bfd_cache_close (abfd) != TRUE)

        return FALSE;

      if (vms_convert_to_var_unix_filename (abfd->filename) != TRUE)

        return FALSE;

    }

#endif

  return TRUE;

}

/* Called when a new section is created.  */

static bfd_boolean

vms_new_section_hook (bfd * abfd, asection *section)

{

  bfd_size_type amt;

  /* Count hasn't been incremented yet.  */

  unsigned int section_count = abfd->section_count + 1;

  vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s), count %d\n",

               abfd, section->index, section->name, section_count));

  bfd_set_section_alignment (abfd, section, 0);

  if (section_count > PRIV (section_count))

    {

      amt = section_count;

      amt *= sizeof (asection *);

      PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);

      if (PRIV (sections) == NULL)

        return FALSE;

      PRIV (section_count) = section_count;

    }

  vms_debug2 ((6, "section_count: %d\n", PRIV (section_count)));

  PRIV (sections)[section->index] = section;

  vms_debug2 ((7, "%d: %s\n", section->index, section->name));

  amt = sizeof (struct vms_section_data_struct);

  section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);

  if (section->used_by_bfd == NULL)

    return FALSE;

  return _bfd_generic_new_section_hook (abfd, section);

}

/* Read the contents of a section.

   buf points to a buffer of buf_size bytes to be filled with

   section data (starting at offset into section)  */

static bfd_boolean

vms_get_section_contents (bfd * abfd ATTRIBUTE_UNUSED,

                          asection *section ATTRIBUTE_UNUSED,

                          void * buf ATTRIBUTE_UNUSED,

                          file_ptr offset ATTRIBUTE_UNUSED,

                          bfd_size_type buf_size ATTRIBUTE_UNUSED)

{

  bfd_size_type size = section->size;

  vms_debug2 ((1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",

               abfd, section->name, buf, offset, (int)buf_size));

  if (section->contents)

    abort ();

  section->contents = (unsigned char *) bfd_malloc (size);

  if (section->contents == NULL)

    {

      bfd_set_error (bfd_error_no_memory);

      return FALSE;

    }

  if (bfd_seek (abfd, section->filepos, SEEK_SET))

    {

      bfd_set_error (bfd_error_file_truncated);

      return FALSE;

    }

  if (bfd_bread (section->contents, size, abfd) != size)

    {

      bfd_set_error (bfd_error_file_truncated);

      return FALSE;

    }

  section->flags |= SEC_IN_MEMORY;

  if (buf)

    memcpy (buf, section->contents + offset, (size_t) buf_size);

  return TRUE;

}

/* Part 4.5, symbols.  */