Subversion Repositories openrisc_2011-10-31

/* 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 const struct bfd_target *vms_archive_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_bfd_free_cached_info (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 bfd_boolean vms_get_section_contents_in_window

  (bfd *abfd, asection *section, bfd_window *w, file_ptr offset,

   bfd_size_type count);

static bfd_boolean vms_bfd_copy_private_bfd_data (bfd *src, bfd *dest);

static bfd_boolean vms_bfd_copy_private_section_data

  (bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec);

static bfd_boolean vms_bfd_copy_private_symbol_data

  (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);

static bfd_boolean vms_bfd_print_private_bfd_data (bfd *abfd, void *file);

static char *vms_core_file_failing_command (bfd *abfd);

static int vms_core_file_failing_signal (bfd *abfd);

static bfd_boolean vms_core_file_matches_executable_p (bfd *abfd, bfd *bbfd);

static bfd_boolean vms_slurp_armap (bfd *abfd);

static bfd_boolean vms_slurp_extended_name_table (bfd *abfd);

static bfd_boolean vms_construct_extended_name_table

  (bfd *abfd, char **tabloc, bfd_size_type *tablen, const char **name);

static void vms_truncate_arname (bfd *abfd, const char *pathname, char *arhdr);

static bfd_boolean vms_write_armap

  (bfd *arch, unsigned int elen, struct orl *map, unsigned int cnt, int idx);

static PTR vms_read_ar_hdr (bfd *abfd);

static bfd *vms_get_elt_at_index (bfd *abfd, symindex index);

static bfd *vms_openr_next_archived_file (bfd *arch, bfd *prev);

static bfd_boolean vms_update_armap_timestamp (bfd *abfd);

static int vms_generic_stat_arch_elt (bfd *, struct stat *);

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 alent *vms_get_lineno (bfd *abfd, asymbol *symbol);

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 asymbol *vms_bfd_make_debug_symbol (bfd *abfd, void *ptr,

                                           unsigned long size);

static long vms_read_minisymbols (bfd *abfd, bfd_boolean dynamic,

                                  PTR *minisymsp, unsigned int *sizep);

static asymbol *vms_minisymbol_to_symbol

  (bfd *abfd, bfd_boolean dynamic, const PTR minisym, asymbol *sym);

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);

static int vms_sizeof_headers (bfd *abfd,

                               struct bfd_link_info *info ATTRIBUTE_UNUSED);

static bfd_byte *vms_bfd_get_relocated_section_contents

  (bfd *abfd, struct bfd_link_info *link_info,

   struct bfd_link_order *link_order, bfd_byte *data,

   bfd_boolean relocatable, asymbol **symbols);

static bfd_boolean vms_bfd_relax_section

  (bfd *abfd, asection *section, struct bfd_link_info *link_info,

   bfd_boolean *again);

static bfd_boolean vms_bfd_gc_sections

  (bfd *abfd, struct bfd_link_info *link_info);

static bfd_boolean vms_bfd_merge_sections

  (bfd *abfd, struct bfd_link_info *link_info);

static struct bfd_link_hash_table *vms_bfd_link_hash_table_create (bfd *abfd);

static void vms_bfd_link_hash_table_free (struct bfd_link_hash_table *hash);

static bfd_boolean vms_bfd_link_add_symbols

  (bfd *abfd, struct bfd_link_info *link_info);

static bfd_boolean vms_bfd_final_link (bfd *abfd,

                                       struct bfd_link_info *link_info);

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

static long vms_get_dynamic_symtab_upper_bound (bfd *abfd);

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

static long vms_get_dynamic_reloc_upper_bound (bfd *abfd);

static long vms_canonicalize_dynamic_reloc

  (bfd *abfd, arelent **arel, asymbol **symbols);

static bfd_boolean vms_bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);

static bfd_boolean vms_bfd_set_private_flags (bfd *abfd, flagword flags);

#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_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

#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;

#if VMS_DEBUG

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

#endif

  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

    {

#if VMS_DEBUG

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

#endif

      new_type = _bfd_vms_get_object_record (abfd);

      if (new_type < 0)

        {

#if VMS_DEBUG

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

#endif

          return -1;

        }

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

        {

          if (! vms_fixup_sections (abfd))

            {

#if VMS_DEBUG

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

#endif

              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)

        {

#if VMS_DEBUG

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

#endif

          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;

#if VMS_DEBUG

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

#endif

  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))

        {

#if VMS_DEBUG

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

#endif

          goto err_wrong_format;

        }

      target_vector = &vms_vax_vec;

      arch = bfd_scan_arch ("vax");

#if VMS_DEBUG

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

#endif

    }

  else

    {

      /* Set arch_info to alpha.   */

      target_vector = &vms_alpha_vec;

      arch = bfd_scan_arch ("alpha");

#if VMS_DEBUG

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

#endif

    }

  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;

}

/* Check the format for a file being read.

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

static const struct bfd_target *

vms_archive_p (bfd * abfd ATTRIBUTE_UNUSED)

{

#if VMS_DEBUG

  vms_debug (1, "vms_archive_p (%p)\n", abfd);

#endif

  return NULL;

}

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

static bfd_boolean

vms_mkobject (bfd * abfd)

{

  const bfd_arch_info_type *arch;

#if VMS_DEBUG

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

#endif

  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)

{

#if VMS_DEBUG

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

#endif

  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)

{

#if VMS_DEBUG

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

#endif

  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);