OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [vms.c] - Diff between revs 157 and 225

Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* vms.c -- BFD back-end for VAX (openVMS/VAX) and
/* vms.c -- BFD back-end for VAX (openVMS/VAX) and
   EVAX (openVMS/Alpha) files.
   EVAX (openVMS/Alpha) files.
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   2006, 2007, 2008 Free Software Foundation, Inc.
   2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
 
 
   Main file.
 
 
   Written by Klaus K"ampf (kkaempf@rmi.de)
   Written by Klaus K"ampf (kkaempf@rmi.de)
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
Line 18... Line 20...
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
   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 "sysdep.h"
#include "bfd.h"
#include "bfd.h"
#include "bfdlink.h"
#include "bfdlink.h"
#include "libbfd.h"
#include "libbfd.h"
 
 
#include "vms.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_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define vms_make_empty_symbol             _bfd_generic_make_empty_symbol
#define vms_make_empty_symbol             _bfd_generic_make_empty_symbol
#define vms_bfd_link_just_syms            _bfd_generic_link_just_syms
#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_is_group_section          bfd_generic_is_group_section
#define vms_bfd_discard_group             bfd_generic_discard_group
#define vms_bfd_discard_group             bfd_generic_discard_group
#define vms_section_already_linked        _bfd_generic_section_already_linked
#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_bfd_copy_private_header_data  _bfd_generic_bfd_copy_private_header_data
#define vms_get_synthetic_symtab          _bfd_nodynamic_get_synthetic_symtab
#define vms_get_synthetic_symtab          _bfd_nodynamic_get_synthetic_symtab
 
 
static unsigned int priv_section_count;

 
#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_vax_vec;
extern const bfd_target vms_alpha_vec;
extern const bfd_target vms_alpha_vec;

 
/* Initialize private data.  */
 
 
 
 
/* Initialize private data  */
static bfd_boolean
static bfd_boolean
vms_initialize (bfd * abfd)
vms_initialize (bfd * abfd)
{
{
  int i;
 
  bfd_size_type amt;
  bfd_size_type amt;
 
 
  bfd_set_start_address (abfd, (bfd_vma) -1);
  bfd_set_start_address (abfd, (bfd_vma) -1);
 
 
  amt = sizeof (struct vms_private_data_struct);
  amt = sizeof (struct vms_private_data_struct);
  abfd->tdata.any = bfd_alloc (abfd, amt);
  abfd->tdata.any = bfd_zalloc (abfd, amt);
  if (abfd->tdata.any == NULL)
  if (abfd->tdata.any == NULL)
    return FALSE;
    return FALSE;
 
 
#ifdef __ALPHA
  if (bfd_get_flavour (abfd) == bfd_target_ovax_flavour)
  PRIV (is_vax) = FALSE;
 
#else
 
  PRIV (is_vax) = TRUE;
  PRIV (is_vax) = TRUE;
#endif
 
  PRIV (vms_buf) = NULL;
 
  PRIV (buf_size) = 0;
 
  PRIV (rec_length) = 0;
 
  PRIV (file_format) = FF_UNKNOWN;
  PRIV (file_format) = FF_UNKNOWN;
  PRIV (fixup_done) = FALSE;
 
  PRIV (sections) = NULL;
 
 
 
  amt = sizeof (struct stack_struct) * STACKSIZE;
  amt = sizeof (struct stack_struct) * STACKSIZE;
  PRIV (stack) = bfd_alloc (abfd, amt);
  PRIV (stack) = bfd_alloc (abfd, amt);
  if (PRIV (stack) == NULL)
  if (PRIV (stack) == NULL)
    goto error_ret1;
    goto error_ret1;
  PRIV (stackptr) = 0;
 
 
 
  amt = sizeof (struct bfd_hash_table);
  amt = sizeof (struct bfd_hash_table);
  PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);
  PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);
  if (PRIV (vms_symbol_table) == NULL)
  if (PRIV (vms_symbol_table) == NULL)
    goto error_ret1;
    goto error_ret1;
 
 
  if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc,
  if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc,
                            sizeof (vms_symbol_entry)))
                            sizeof (vms_symbol_entry)))
    goto error_ret1;
    goto error_ret1;
 
 
  amt = sizeof (struct location_struct) * LOCATION_SAVE_SIZE;
 
  PRIV (location_stack) = bfd_alloc (abfd, amt);
 
  if (PRIV (location_stack) == NULL)
 
    goto error_ret2;
 
 
 
  for (i = 0; i < VMS_SECTION_COUNT; i++)
 
    PRIV (vms_section_table)[i] = NULL;
 
 
 
  amt = MAX_OUTREC_SIZE;
  amt = MAX_OUTREC_SIZE;
  PRIV (output_buf) = bfd_alloc (abfd, amt);
  PRIV (output_buf) = bfd_alloc (abfd, amt);
  if (PRIV (output_buf) == NULL)
  if (PRIV (output_buf) == NULL)
    goto error_ret2;
    goto error_ret2;
 
 
  PRIV (push_level) = 0;
 
  PRIV (pushed_size) = 0;
 
  PRIV (length_pos) = 2;
  PRIV (length_pos) = 2;
  PRIV (output_size) = 0;
 
  PRIV (output_alignment) = 1;
 
 
 
  return TRUE;
  return TRUE;
 
 
 error_ret2:
 error_ret2:
  bfd_hash_table_free (PRIV (vms_symbol_table));
  bfd_hash_table_free (PRIV (vms_symbol_table));
Line 109... Line 204...
  bfd_release (abfd, abfd->tdata.any);
  bfd_release (abfd, abfd->tdata.any);
  abfd->tdata.any = NULL;
  abfd->tdata.any = NULL;
  return FALSE;
  return FALSE;
}
}
 
 
/* Fill symbol->section with section ptr
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
   symbol->section is filled with the section index for defined symbols
   during reading the GSD/EGSD section. But we need the pointer to the
   during reading the GSD/EGSD section. But we need the pointer to the
   bfd section later.
   bfd section later.
 
 
   It has the correct value for referenced (undefined section) symbols
   It has the correct value for referenced (undefined section) symbols.
 
 
   called from bfd_hash_traverse in vms_fixup_sections.  */
   Called from bfd_hash_traverse in vms_fixup_sections.  */
 
 
static bfd_boolean
static bfd_boolean
fill_section_ptr (struct bfd_hash_entry * entry, void * sections)
fill_section_ptr (struct bfd_hash_entry * entry, void * sections)
{
{
  asection *sec;
  asymbol *sym = ((vms_symbol_entry *)entry)->symbol;
  asymbol *sym;
  struct pair *data = (struct pair *)sections;
 
  unsigned long sec = (unsigned long)sym->section;
  sym = ((vms_symbol_entry *) entry)->symbol;
 
  sec = sym->section;
 
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec);
  vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec);
#endif
#endif
 
 
  /* Fill forward references (these contain section number, not section ptr).  */
  if (sec < data->section_count)
  if ((unsigned int) (size_t) sec < priv_section_count)
    {
    sec = ((vms_symbol_entry *) entry)->symbol->section =
      sym->section = data->sections[sec];
      ((asection **) sections)[(unsigned int) (size_t) sec];
 
 
 
  if (strcmp (sym->name, sec->name) == 0)
      if (strcmp (sym->name, sym->section->name) == 0)
    sym->flags |= BSF_SECTION_SYM;
    sym->flags |= BSF_SECTION_SYM;
 
    }
 
  else if (sec == (unsigned long)-1)
 
    sym->section = &bfd_und_section;
 
 
  return TRUE;
  return TRUE;
}
}
 
 
/* Fixup sections
/* Fixup section pointers in symbols.  */
   set up all pointers and arrays, counters and sizes are fixed now
 
 
 
   we build a private sections vector for easy access since sections
 
   are always referenced by an index number.
 
 
 
   alloc PRIV(sections) according to abfd->section_count
 
        copy abfd->sections to PRIV(sections).  */
 
 
 
static bfd_boolean
static bfd_boolean
vms_fixup_sections (bfd * abfd)
vms_fixup_sections (bfd * abfd)
{
{
 
  struct pair data;
 
 
  if (PRIV (fixup_done))
  if (PRIV (fixup_done))
    return TRUE;
    return TRUE;
 
 
  /* Traverse symbol table and fill in all section pointers.  */
  data.section_count = PRIV (section_count);
 
  data.sections = PRIV (sections);
  /* Can't provide section count as argument to fill_section_ptr().  */
  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, &data);
  priv_section_count = PRIV (section_count);
 
  bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, (PRIV (sections)));
 
 
 
  PRIV (fixup_done) = TRUE;
  PRIV (fixup_done) = TRUE;
 
 
  return TRUE;
  return TRUE;
}
}

 
/* 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 *
/* Slurp an ordered set of VMS object records.  */
vms_object_p (bfd * abfd)
int
 
_bfd_vms_slurp_object_records (bfd * abfd)
{
{
  int err = 0;
  int err, new_type, type = -1;
  int prev_type;
 
  const struct bfd_target *target_vector = NULL;
 
  const bfd_arch_info_type *arch = NULL;
 
  void * tdata_save = abfd->tdata.any;
 
  bfd_vma saddr_save = bfd_get_start_address (abfd);
 
 
 
#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;
 
 
 
  prev_type = -1;
 
 
 
  do
  do
    {
    {
#if VMS_DEBUG
#if VMS_DEBUG
      vms_debug (7, "reading at %08lx\n", bfd_tell (abfd));
      vms_debug (7, "reading at %08lx\n", bfd_tell (abfd));
#endif
#endif
      if (_bfd_vms_next_record (abfd) < 0)
      new_type = _bfd_vms_get_object_record (abfd);
 
      if (new_type < 0)
        {
        {
#if VMS_DEBUG
#if VMS_DEBUG
          vms_debug (2, "next_record failed\n");
          vms_debug (2, "next_record failed\n");
#endif
#endif
          goto err_wrong_format;
          return -1;
        }
        }
 
 
      if ((prev_type == EOBJ_S_C_EGSD)
      if (type == EOBJ_S_C_EGSD && new_type != EOBJ_S_C_EGSD)
           && (PRIV (rec_type) != EOBJ_S_C_EGSD))
 
        {
        {
          if (! vms_fixup_sections (abfd))
          if (! vms_fixup_sections (abfd))
            {
            {
#if VMS_DEBUG
#if VMS_DEBUG
              vms_debug (2, "vms_fixup_sections failed\n");
              vms_debug (2, "vms_fixup_sections failed\n");
#endif
#endif
              goto err_wrong_format;
              return -1;
            }
            }
        }
        }
 
 
      prev_type = PRIV (rec_type);
      type = new_type;
 
 
      if (target_vector == NULL)
      switch (type)
        {
 
          if (prev_type <= OBJ_S_C_MAXRECTYP)
 
            target_vector = & vms_vax_vec;
 
          else
 
            target_vector = & vms_alpha_vec;
 
        }
 
 
 
      switch (prev_type)
 
        {
        {
          case OBJ_S_C_HDR:
          case OBJ_S_C_HDR:
          case EOBJ_S_C_EMH:
          case EOBJ_S_C_EMH:
            err = _bfd_vms_slurp_hdr (abfd, prev_type);
            err = _bfd_vms_slurp_hdr (abfd, type);
            break;
            break;
          case OBJ_S_C_EOM:
          case OBJ_S_C_EOM:
          case OBJ_S_C_EOMW:
          case OBJ_S_C_EOMW:
          case EOBJ_S_C_EEOM:
          case EOBJ_S_C_EEOM:
            err = _bfd_vms_slurp_eom (abfd, prev_type);
            err = _bfd_vms_slurp_eom (abfd, type);
            break;
            break;
          case OBJ_S_C_GSD:
          case OBJ_S_C_GSD:
          case EOBJ_S_C_EGSD:
          case EOBJ_S_C_EGSD:
            err = _bfd_vms_slurp_gsd (abfd, prev_type);
            err = _bfd_vms_slurp_gsd (abfd, type);
            break;
            break;
          case OBJ_S_C_TIR:
          case OBJ_S_C_TIR:
          case EOBJ_S_C_ETIR:
          case EOBJ_S_C_ETIR:
            err = _bfd_vms_slurp_tir (abfd, prev_type);
            err = _bfd_vms_slurp_tir (abfd, type);
            break;
            break;
          case OBJ_S_C_DBG:
          case OBJ_S_C_DBG:
          case EOBJ_S_C_EDBG:
          case EOBJ_S_C_EDBG:
            err = _bfd_vms_slurp_dbg (abfd, prev_type);
            err = _bfd_vms_slurp_dbg (abfd, type);
 
            PRIV (dst_ptr_end) = PRIV (image_ptr);
            break;
            break;
          case OBJ_S_C_TBT:
          case OBJ_S_C_TBT:
          case EOBJ_S_C_ETBT:
          case EOBJ_S_C_ETBT:
            err = _bfd_vms_slurp_tbt (abfd, prev_type);
            err = _bfd_vms_slurp_tbt (abfd, type);
 
            PRIV (dst_ptr_end) = PRIV (image_ptr);
            break;
            break;
          case OBJ_S_C_LNK:
          case OBJ_S_C_LNK:
            err = _bfd_vms_slurp_lnk (abfd, prev_type);
            err = _bfd_vms_slurp_lnk (abfd, type);
            break;
            break;
          default:
          default:
            err = -1;
            err = -1;
        }
        }
      if (err != 0)
      if (err != 0)
        {
        {
#if VMS_DEBUG
#if VMS_DEBUG
          vms_debug (2, "slurp type %d failed with %d\n", prev_type, err);
          vms_debug (2, "slurp type %d failed with %d\n", type, err);
#endif
#endif
          goto err_wrong_format;
          return err;
 
        }
        }
        }
 
  while (type != EOBJ_S_C_EEOM && type != OBJ_S_C_EOM && type != OBJ_S_C_EOMW);
 
 
 
  return 0;
    }
    }
  while ((prev_type != EOBJ_S_C_EEOM) && (prev_type != OBJ_S_C_EOM) && (prev_type != OBJ_S_C_EOMW));
 
 
 
  if (target_vector == & vms_vax_vec)
/* 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_fixup_sections (abfd))
        {
        {
#if VMS_DEBUG
#if VMS_DEBUG
          vms_debug (2, "vms_fixup_sections failed\n");
          vms_debug (2, "vms_fixup_sections failed\n");
#endif
#endif
          goto err_wrong_format;
          goto err_wrong_format;
        }
        }
 
 
      /* Set arch_info to vax.  */
      target_vector = &vms_vax_vec;
 
 
      arch = bfd_scan_arch ("vax");
      arch = bfd_scan_arch ("vax");
      PRIV (is_vax) = TRUE;
 
#if VMS_DEBUG
#if VMS_DEBUG
      vms_debug (2, "arch is vax\n");
      vms_debug (2, "arch is vax\n");
#endif
#endif
    }
    }
  else if (target_vector == & vms_alpha_vec)
  else
    {
    {
      /* Set arch_info to alpha.   */
      /* Set arch_info to alpha.   */
 
      target_vector = &vms_alpha_vec;
      arch = bfd_scan_arch ("alpha");
      arch = bfd_scan_arch ("alpha");
      PRIV (is_vax) = FALSE;
 
#if VMS_DEBUG
#if VMS_DEBUG
      vms_debug (2, "arch is alpha\n");
      vms_debug (2, "arch is alpha\n");
#endif
#endif
    }
    }
 
 
  if (arch == NULL)
 
    {
 
#if VMS_DEBUG
 
      vms_debug (2, "arch not found\n");
 
#endif
 
      goto err_wrong_format;
 
    }
 
  abfd->arch_info = arch;
  abfd->arch_info = arch;
 
 
  return target_vector;
  return target_vector;
 
 
 err_wrong_format:
 err_wrong_format:
  bfd_set_error (bfd_error_wrong_format);
  bfd_set_error (bfd_error_wrong_format);
 
 
 error_ret:
 error_ret:
  if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
  if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
    bfd_release (abfd, abfd->tdata.any);
    bfd_release (abfd, abfd->tdata.any);
  abfd->tdata.any = tdata_save;
  abfd->tdata.any = tdata_save;
  bfd_set_start_address (abfd, saddr_save);
  bfd_set_start_address (abfd, saddr_save);
Line 339... Line 489...
/* Set the format of a file being written.  */
/* Set the format of a file being written.  */
 
 
static bfd_boolean
static bfd_boolean
vms_mkobject (bfd * abfd)
vms_mkobject (bfd * abfd)
{
{
 
  const bfd_arch_info_type *arch;
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_mkobject (%p)\n", abfd);
  vms_debug (1, "vms_mkobject (%p)\n", abfd);
#endif
#endif
 
 
  if (!vms_initialize (abfd))
  if (!vms_initialize (abfd))
    return FALSE;
    return FALSE;
 
 
  {
  if (PRIV (is_vax))
#ifdef __VAX
    arch = bfd_scan_arch ("vax");
    const bfd_arch_info_type *arch = bfd_scan_arch ("vax");
  else
#else
    arch = bfd_scan_arch ("alpha");
    const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
 
#endif
  if (arch == 0)
    if (arch == NULL)
 
      {
      {
        bfd_set_error (bfd_error_wrong_format);
        bfd_set_error (bfd_error_wrong_format);
        return FALSE;
        return FALSE;
      }
      }
    abfd->arch_info = arch;
 
  }
 
 
 
 
  abfd->arch_info = arch;
  return TRUE;
  return TRUE;
}
}
 
 
/* Write cached information into a file being written, at bfd_close.  */
/* Write cached information into a file being written, at bfd_close.  */
 
 
Line 418... Line 568...
  return TRUE;
  return TRUE;
}
}
 
 
/* 4.1, generic.  */
/* 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.  */
/* Called when the BFD is being closed to do any necessary cleanup.  */
 
 
static bfd_boolean
static bfd_boolean
vms_close_and_cleanup (bfd * abfd)
vms_close_and_cleanup (bfd * abfd)
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_close_and_cleanup (%p)\n", abfd);
  vms_debug (1, "vms_close_and_cleanup (%p)\n", abfd);
#endif
#endif
  if (abfd == NULL
  if (abfd == NULL || abfd->tdata.any == NULL)
      || abfd->tdata.any == NULL)
 
    return TRUE;
    return TRUE;
 
 
  if (PRIV (vms_buf) != NULL)
  if (PRIV (vms_buf) != NULL)
    free (PRIV (vms_buf));
    free (PRIV (vms_buf));
 
 
Line 439... Line 644...
    free (PRIV (sections));
    free (PRIV (sections));
 
 
  if (PRIV (vms_symbol_table))
  if (PRIV (vms_symbol_table))
    bfd_hash_table_free (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);
  bfd_release (abfd, abfd->tdata.any);
  abfd->tdata.any = NULL;
  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;
  return TRUE;
}
}
 
 
/* Ask the BFD to free all cached information.  */
/* Ask the BFD to free all cached information.  */
 
 
Line 461... Line 680...
/* Called when a new section is created.  */
/* Called when a new section is created.  */
 
 
static bfd_boolean
static bfd_boolean
vms_new_section_hook (bfd * abfd, asection *section)
vms_new_section_hook (bfd * abfd, asection *section)
{
{
 
  bfd_size_type amt;
 
 
  /* Count hasn't been incremented yet.  */
  /* Count hasn't been incremented yet.  */
  unsigned int section_count = abfd->section_count + 1;
  unsigned int section_count = abfd->section_count + 1;
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
  vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
             abfd, section->index, section->name, section_count);
             abfd, section->index, section->name, section_count);
#endif
#endif
  bfd_set_section_alignment (abfd, section, 4);
 
 
  bfd_set_section_alignment (abfd, section, 0);
 
 
  if (section_count > PRIV (section_count))
  if (section_count > PRIV (section_count))
    {
    {
      bfd_size_type amt = section_count;
      bfd_size_type amt = section_count;
      amt *= sizeof (asection *);
      amt *= sizeof (asection *);
      PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
      PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
      if (PRIV (sections) == NULL)
      if (PRIV (sections) == NULL)
        return FALSE;
        return FALSE;
      PRIV (section_count) = section_count;
      PRIV (section_count) = section_count;
    }
    }
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (6, "section_count: %d\n", PRIV (section_count));
  vms_debug (6, "section_count: %d\n", PRIV (section_count));
#endif
#endif
 
 
  PRIV (sections)[section->index] = section;
  PRIV (sections)[section->index] = section;
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (7, "%d: %s\n", section->index, section->name);
  vms_debug (7, "%d: %s\n", section->index, section->name);
#endif
#endif
 
 
 
  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);
  return _bfd_generic_new_section_hook (abfd, section);
}
}
 
 
/* Read the contents of a section.
/* Read the contents of a section.
   buf points to a buffer of buf_size bytes to be filled with
   buf points to a buffer of buf_size bytes to be filled with
Line 501... Line 731...
                          asection *section ATTRIBUTE_UNUSED,
                          asection *section ATTRIBUTE_UNUSED,
                          void * buf ATTRIBUTE_UNUSED,
                          void * buf ATTRIBUTE_UNUSED,
                          file_ptr offset ATTRIBUTE_UNUSED,
                          file_ptr offset ATTRIBUTE_UNUSED,
                          bfd_size_type buf_size ATTRIBUTE_UNUSED)
                          bfd_size_type buf_size ATTRIBUTE_UNUSED)
{
{
 
  bfd_size_type size = section->size;
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",
  vms_debug (1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",
                 abfd, section->name, buf, offset, (int)buf_size);
                 abfd, section->name, buf, offset, (int)buf_size);
#endif
#endif
 
 
  /* Shouldn't be called, since all sections are IN_MEMORY.  */
  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;
  return FALSE;
}
}
 
 
 
  section->flags |= SEC_IN_MEMORY;
 
 
 
  if (buf)
 
    memcpy (buf, section->contents + offset, (size_t) buf_size);
 
 
 
  return TRUE;
 
}
 
 
/* Read the contents of a section.
/* Read the contents of a section.
   buf points to a buffer of buf_size bytes to be filled with
   buf points to a buffer of buf_size bytes to be filled with
   section data (starting at offset into section).  */
   section data (starting at offset into section).  */
 
 
static bfd_boolean
static bfd_boolean
Line 701... Line 960...
                     char *arhdr ATTRIBUTE_UNUSED)
                     char *arhdr ATTRIBUTE_UNUSED)
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_truncate_arname (%p, %s, %s)\n", abfd, pathname, arhdr);
  vms_debug (1, "vms_truncate_arname (%p, %s, %s)\n", abfd, pathname, arhdr);
#endif
#endif
  return;
 
}
}
 
 
/* ???  write archive map.  */
/* ???  write archive map.  */
 
 
static bfd_boolean
static bfd_boolean
Line 904... Line 1162...
  sec = symbol->section;
  sec = symbol->section;
 
 
  if (ret == NULL)
  if (ret == NULL)
    return;
    return;
 
 
  if (bfd_is_com_section (sec))
  if (sec == 0)
 
    ret->type = 'U';
 
  else if (bfd_is_com_section (sec))
    ret->type = 'C';
    ret->type = 'C';
  else if (bfd_is_abs_section (sec))
  else if (bfd_is_abs_section (sec))
    ret->type = 'A';
    ret->type = 'A';
  else if (bfd_is_und_section (sec))
  else if (bfd_is_und_section (sec))
    ret->type = 'U';
    ret->type = 'U';
Line 970... Line 1230...
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_find_nearest_line (%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
  vms_debug (1, "vms_find_nearest_line (%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
              abfd, section->name, symbols, (long int)offset);
              abfd, section->name, symbols, (long int)offset);
#endif
#endif
  return FALSE;
  return _bfd_vms_find_nearest_dst_line (abfd, section, symbols, offset, file, func, line);
}
}
 
 
static bfd_boolean
static bfd_boolean
vms_find_inliner_info (bfd * abfd ATTRIBUTE_UNUSED,
vms_find_inliner_info (bfd * abfd ATTRIBUTE_UNUSED,
                       const char **file ATTRIBUTE_UNUSED,
                       const char **file ATTRIBUTE_UNUSED,
Line 1035... Line 1295...
  return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
  return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
}
}
 
 
/* Part 4.6, relocations.  */
/* Part 4.6, relocations.  */
 
 
/* Return the number of bytes required to store the relocation information
/* Allocate the reloc buffer for the specified section.  */
   associated with section sect attached to bfd abfd.
 
   If an error occurs, return -1.  */
 
 
 
static long
static void
vms_get_reloc_upper_bound (bfd * abfd ATTRIBUTE_UNUSED,
alloc_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
                           asection *section ATTRIBUTE_UNUSED)
                    void *alloc_error)
 
{
 
  unsigned char *ptr;
 
 
 
  /* If there were no relocations, there is nothing to do.  */
 
  if (section->reloc_count == 0)
 
    return;
 
 
 
  ptr = bfd_malloc (vms_section_data (section)->reloc_size);
 
  if (ptr == NULL)
 
    {
 
      *(bfd_boolean *)alloc_error = TRUE;
 
      return;
 
    }
 
 
 
  vms_section_data (section)->reloc_stream = ptr;
 
}
 
 
 
/* Read in the relocs for the specified section and internalize them.
 
 
 
   The implementation is loosely based on the SOM code and made up
 
   of 3 distinct phases:
 
 
 
   1. When the VMS object is opened and parsed, the number and the size
 
      of the relocations are computed for all sections.  This makes it
 
      possible to know upfront both which sections have no relocs and
 
      the size of the reloc buffers for the other sections, at virtually
 
      no cost for consumers that don't care about relocs at all.
 
 
 
   2. When vms_slurp_reloc_table is invoked for the first time on a section
 
      with relocs, the object is traversed and all the reloc information
 
      is saved in per-section reloc buffers.  It would be very inefficient
 
      to scan the whole file on each invocation, so we slurp for all the
 
      sections at once.
 
 
 
   3. On subsequent invocations of vms_slurp_reloc_table, the relocs for the
 
      specified section are fetched from the buffer, decoded and internalized.
 
      The buffer is then freed since the internalized relocs are attached to
 
      the section, turning additional invocations of vms_slurp_reloc_table
 
      on the same section into no-ops.
 
 
 
   Since VMS objects have very few sections, it could be profitable to merge
 
   phase #2 and phase #3, i.e. to decode and internalize the relocs for all
 
   the sections at once.  The current implementation is more elegant.  */
 
 
 
static bfd_boolean
 
vms_slurp_reloc_table (bfd *abfd, asection *section, asymbol **symbols)
 
{
 
  arelent *internal_relocs;
 
  bfd_size_type amt;
 
  int err;
 
 
 
  /* If there were no relocations, there is nothing to do.  */
 
  if (section->reloc_count == 0)
 
    return TRUE;
 
 
 
  /* Return saved information about the relocations if it is available.  */
 
  if (section->relocation != NULL)
 
    return TRUE;
 
 
 
  /* If the relocation stream has not been slurped, do it now.  */
 
  if (vms_section_data (section)->reloc_stream == NULL)
 
    {
 
      bfd_boolean alloc_error = FALSE;
 
      int type;
 
 
 
      /* Size the reloc buffer for each section.  */
 
      bfd_map_over_sections (abfd, alloc_reloc_stream, &alloc_error);
 
      if (alloc_error)
 
        return FALSE;
 
 
 
      if (bfd_seek (abfd, 0, SEEK_SET) != 0)
 
        return FALSE;
 
 
 
      /* Reset section pointer.  */
 
      PRIV (image_section) = NULL;
 
 
 
      do
 
        {
 
          type = _bfd_vms_get_object_record (abfd);
 
          if (type != EOBJ_S_C_ETIR
 
              && type != EOBJ_S_C_EDBG
 
              && type != EOBJ_S_C_ETBT)
 
            continue;
 
          err = _bfd_vms_slurp_relocs (abfd);
 
          if (err != 0)
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_get_reloc_upper_bound (%p, %s)\n", abfd, section->name);
              vms_debug (2, "slurp relocs failed with %d\n", err);
#endif
#endif
  return -1L;
              return FALSE;
 
            }
 
        }
 
      while (type != EOBJ_S_C_EEOM);
}
}
 
 
/* Call the back end associated with the open BFD abfd and translate the
  amt = section->reloc_count * sizeof (arelent);
   external form of the relocation information attached to sec into the
  internal_relocs = (arelent *) bfd_zalloc (abfd, amt);
   internal canonical form.  Place the table into memory at loc, which has
  if (internal_relocs == NULL)
   been preallocated, usually by a call to bfd_get_reloc_upper_bound.
    return FALSE;
   Returns the number of relocs, or -1 on error.  */
 
 
 
static long
  /* Decode and internalize the relocations.  */
vms_canonicalize_reloc (bfd * abfd ATTRIBUTE_UNUSED,
  err = _bfd_vms_decode_relocs (abfd, internal_relocs, section, symbols);
                        asection *section ATTRIBUTE_UNUSED,
  if (err != 0)
                        arelent **location ATTRIBUTE_UNUSED,
 
                        asymbol **symbols ATTRIBUTE_UNUSED)
 
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_canonicalize_reloc (%p, %s, <ret>, <ret>)\n", abfd, section->name);
      vms_debug (2, "decode relocs failed with %d\n", err);
#endif
#endif
  return FALSE;
  return FALSE;
}
}
 
 
 
  /* We're done with the external relocations.  Free them.  */
 
  free (vms_section_data (section)->reloc_stream);
 
  vms_section_data (section)->reloc_stream = NULL;
 
 
 
  /* Save our results and return success.  */
 
  section->relocation = internal_relocs;
 
  return TRUE;
 
}
 
 
 
/* Return the number of bytes required to store the relocation
 
   information associated with the given section.  */
 
 
 
static long
 
vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
 
{
 
  return (section->reloc_count + 1) * sizeof (arelent *);
 
}
 
 
 
/* Convert relocations from VMS (external) form into BFD internal
 
   form.  Return the number of relocations.  */
 
 
 
static long
 
vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
 
                        asymbol **symbols)
 
{
 
  arelent *tblptr;
 
  int count;
 
 
 
  if (! vms_slurp_reloc_table (abfd, section, symbols))
 
    return -1;
 
 
 
  count = section->reloc_count;
 
  tblptr = section->relocation;
 
 
 
  while (count--)
 
    *relptr++ = tblptr++;
 
 
 
  *relptr = (arelent *) NULL;
 
  return section->reloc_count;
 
}


/* This is just copied from ecoff-alpha, needs to be fixed probably.  */
/* This is just copied from ecoff-alpha, needs to be fixed probably.  */
 
 
/* How to process the various reloc types.  */
/* How to process the various reloc types.  */
 
 
Line 1315... Line 1699...
         FALSE,                 /* Partial_inplace.  */
         FALSE,                 /* Partial_inplace.  */
         0xffffffff,            /* Source mask.  */
         0xffffffff,            /* Source mask.  */
         0xffffffff,            /* Dest mask.  */
         0xffffffff,            /* Dest mask.  */
         FALSE),                /* PC rel offset.  */
         FALSE),                /* PC rel offset.  */
 
 
 
  HOWTO (ALPHA_R_NOP,           /* Type.  */
 
         0,                      /* Rightshift.  */
 
         3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 
         0,                      /* Bitsize.  */
 
         /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
 
            because the calculations for the 3 relocations are the same.
 
            See B.4.5.2 of the OpenVMS Linker Utility Manual.  */
 
         TRUE,                  /* PC relative.  */
 
         0,                      /* Bitpos.   */
 
         complain_overflow_dont,/* Complain_on_overflow.  */
 
         reloc_nil,             /* Special_function.  */
 
         "NOP",                 /* Name.  */
 
         FALSE,                 /* Partial_inplace.  */
 
         0xffffffff,            /* Source mask.  */
 
         0xffffffff,            /* Dest mask.  */
 
         FALSE),                /* PC rel offset.  */
 
 
 
  HOWTO (ALPHA_R_BSR,           /* Type.  */
 
         0,                      /* Rightshift.  */
 
         3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 
         0,                      /* Bitsize.  */
 
         TRUE,                  /* PC relative.  */
 
         0,                      /* Bitpos.  */
 
         complain_overflow_dont,/* Complain_on_overflow.  */
 
         reloc_nil,             /* Special_function.  */
 
         "BSR",                 /* Name.  */
 
         FALSE,                 /* Partial_inplace.  */
 
         0xffffffff,            /* Source mask.  */
 
         0xffffffff,            /* Dest mask.  */
 
         FALSE),                /* PC rel offset.  */
 
 
 
  HOWTO (ALPHA_R_LDA,           /* Type.  */
 
         0,                      /* Rightshift.  */
 
         3,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 
         0,                      /* Bitsize.  */
 
         FALSE,                 /* PC relative.  */
 
         0,                      /* Bitpos.  */
 
         complain_overflow_dont,/* Complain_on_overflow.  */
 
         reloc_nil,             /* Special_function.  */
 
         "LDA",                 /* Name.  */
 
         FALSE,                 /* Partial_inplace.  */
 
         0xffffffff,            /* Source mask.  */
 
         0xffffffff,            /* Dest mask.  */
 
         FALSE),                /* PC rel offset.  */
 
 
 
  HOWTO (ALPHA_R_BOH,           /* Type.  */
 
         0,                      /* Rightshift.  */
 
         3,                     /* Size (0 = byte, 1 = short, 2 = long, 3 = nil).  */
 
         0,                      /* Bitsize.  */
 
         TRUE,                  /* PC relative.  */
 
         0,                      /* Bitpos.  */
 
         complain_overflow_dont,/* Complain_on_overflow.  */
 
         reloc_nil,             /* Special_function.  */
 
         "BOH",                 /* Name.  */
 
         FALSE,                 /* Partial_inplace.  */
 
         0xffffffff,            /* Source mask.  */
 
         0xffffffff,            /* Dest mask.  */
 
         FALSE),                /* PC rel offset.  */
};
};
 
 
/* Return a pointer to a howto structure which, when invoked, will perform
/* Return a pointer to a howto structure which, when invoked, will perform
   the relocation code on data from the architecture noted.  */
   the relocation code on data from the architecture noted.  */
 
 
Line 1343... Line 1785...
      case BFD_RELOC_16_PCREL:          alpha_type = ALPHA_R_SREL16;    break;
      case BFD_RELOC_16_PCREL:          alpha_type = ALPHA_R_SREL16;    break;
      case BFD_RELOC_32_PCREL:          alpha_type = ALPHA_R_SREL32;    break;
      case BFD_RELOC_32_PCREL:          alpha_type = ALPHA_R_SREL32;    break;
      case BFD_RELOC_64_PCREL:          alpha_type = ALPHA_R_SREL64;    break;
      case BFD_RELOC_64_PCREL:          alpha_type = ALPHA_R_SREL64;    break;
      case BFD_RELOC_ALPHA_LINKAGE:     alpha_type = ALPHA_R_LINKAGE;   break;
      case BFD_RELOC_ALPHA_LINKAGE:     alpha_type = ALPHA_R_LINKAGE;   break;
      case BFD_RELOC_ALPHA_CODEADDR:    alpha_type = ALPHA_R_CODEADDR;  break;
      case BFD_RELOC_ALPHA_CODEADDR:    alpha_type = ALPHA_R_CODEADDR;  break;
 
      case BFD_RELOC_ALPHA_NOP:         alpha_type = ALPHA_R_NOP;       break;
 
      case BFD_RELOC_ALPHA_BSR:         alpha_type = ALPHA_R_BSR;       break;
 
      case BFD_RELOC_ALPHA_LDA:         alpha_type = ALPHA_R_LDA;       break;
 
      case BFD_RELOC_ALPHA_BOH:         alpha_type = ALPHA_R_BOH;       break;
      default:
      default:
        (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
        (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
        return NULL;
        return NULL;
    }
    }
#if VMS_DEBUG
#if VMS_DEBUG
Line 1383... Line 1829...
                   unsigned long mach ATTRIBUTE_UNUSED)
                   unsigned long mach ATTRIBUTE_UNUSED)
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach);
  vms_debug (1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach);
#endif
#endif
  abfd->arch_info = bfd_scan_arch ("alpha");
 
 
 
  return TRUE;
  if (arch != bfd_arch_alpha
 
      && arch != bfd_arch_vax
 
      && arch != bfd_arch_unknown)
 
    return FALSE;
 
 
 
  return bfd_default_set_arch_mach (abfd, arch, mach);
}
}
 
 
/* Sets the contents of the section section in BFD abfd to the data starting
/* Sets the contents of the section section in BFD abfd to the data starting
   in memory at data. The data is written to the output section starting at
   in memory at LOCATION. The data is written to the output section starting
   offset offset for count bytes.
   at offset offset for count bytes.
 
 
   Normally TRUE is returned, else FALSE. Possible error returns are:
   Normally TRUE is returned, else FALSE. Possible error returns are:
   o bfd_error_no_contents - The output section does not have the
   o bfd_error_no_contents - The output section does not have the
        SEC_HAS_CONTENTS attribute, so nothing can be written to it.
        SEC_HAS_CONTENTS attribute, so nothing can be written to it.
   o and some more too  */
   o and some more too  */
Line 1409... Line 1859...
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_set_section_contents (%p, sec %s, loc %p, off %ld, count %d)\n",
  vms_debug (1, "vms_set_section_contents (%p, sec %s, loc %p, off %ld, count %d)\n",
             abfd, section->name, location, (long int)offset, (int)count);
             abfd, section->name, location, (long int)offset, (int)count);
  vms_debug (2, "size %d\n", (int) section->size);
  vms_debug (2, "size %d\n", (int) section->size);
#endif
#endif
  return _bfd_save_vms_section (abfd, section, location, offset, count);
  if (count == (bfd_size_type)0)
 
    return TRUE;
 
 
 
  if (section->contents == NULL)
 
    section->contents = bfd_alloc (abfd, section->size);
 
  if (section->contents == NULL)
 
    return FALSE;
 
 
 
  memcpy (section->contents + offset, location, (size_t) count);
 
  return TRUE;
}
}
 
 
/* Part 4.8, linker.  */
/* Part 4.8, linker.  */
 
 
/* Get the size of the section headers.  */
/* Get the size of the section headers.  */
Line 1452... Line 1911...
vms_bfd_relax_section (bfd * abfd ATTRIBUTE_UNUSED,
vms_bfd_relax_section (bfd * abfd ATTRIBUTE_UNUSED,
                       asection *section ATTRIBUTE_UNUSED,
                       asection *section ATTRIBUTE_UNUSED,
                       struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
                       struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
                       bfd_boolean *again ATTRIBUTE_UNUSED)
                       bfd_boolean *again ATTRIBUTE_UNUSED)
{
{
 
  if (link_info->relocatable)
 
    (*link_info->callbacks->einfo)
 
      (_("%P%F: --relax and -r may not be used together\n"));
 
 
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_bfd_relax_section (%p, %s, %p, <ret>)\n",
  vms_debug (1, "vms_bfd_relax_section (%p, %s, %p, <ret>)\n",
             abfd, section->name, link_info);
             abfd, section->name, link_info);
#endif
#endif
  return TRUE;
  return TRUE;
Line 1548... Line 2011...
vms_get_dynamic_symtab_upper_bound (bfd * abfd ATTRIBUTE_UNUSED)
vms_get_dynamic_symtab_upper_bound (bfd * abfd ATTRIBUTE_UNUSED)
{
{
#if VMS_DEBUG
#if VMS_DEBUG
  vms_debug (1, "vms_get_dynamic_symtab_upper_bound (%p)\n", abfd);
  vms_debug (1, "vms_get_dynamic_symtab_upper_bound (%p)\n", abfd);
#endif
#endif
  return 0;
  return 0L;
}
}
 
 
static bfd_boolean
static bfd_boolean
vms_bfd_print_private_bfd_data (bfd * abfd ATTRIBUTE_UNUSED,
vms_bfd_print_private_bfd_data (bfd * abfd ATTRIBUTE_UNUSED,
                                void *file ATTRIBUTE_UNUSED)
                                void *file ATTRIBUTE_UNUSED)
Line 1604... Line 2067...
  "vms-alpha",                  /* Name.  */
  "vms-alpha",                  /* Name.  */
  bfd_target_evax_flavour,
  bfd_target_evax_flavour,
  BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
  BFD_ENDIAN_LITTLE,            /* Data byte order is little.  */
  BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
  BFD_ENDIAN_LITTLE,            /* Header byte order is little.  */
 
 
  (HAS_RELOC | HAS_SYMS
  (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
   | WP_TEXT | D_PAGED),        /* Object flags.  */
   | WP_TEXT | D_PAGED),        /* Object flags.  */
  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
   | SEC_READONLY | SEC_CODE | SEC_DATA
   | SEC_READONLY | SEC_CODE | SEC_DATA
   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
  0,                             /* Symbol_leading_char.  */
  0,                             /* symbol_leading_char.  */
  ' ',                          /* AR_pad_char.  */
  ' ',                          /* ar_pad_char.  */
  15,                           /* AR_max_namelen.  */
  15,                           /* ar_max_namelen.  */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
Line 1638... Line 2101...
  BFD_JUMP_TABLE_LINK (vms),
  BFD_JUMP_TABLE_LINK (vms),
  BFD_JUMP_TABLE_DYNAMIC (vms),
  BFD_JUMP_TABLE_DYNAMIC (vms),
 
 
  NULL,
  NULL,
 
 
  NULL
  (PTR) 0
};
};
 
 
const bfd_target vms_vax_vec =
const bfd_target vms_vax_vec =
{
{
  "vms-vax",                    /* Name.  */
  "vms-vax",                    /* Name.  */
Line 1655... Line 2118...
   | HAS_LINENO | HAS_DEBUG | HAS_LOCALS),
   | HAS_LINENO | HAS_DEBUG | HAS_LOCALS),
 
 
  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
   | SEC_READONLY | SEC_CODE | SEC_DATA
   | SEC_READONLY | SEC_CODE | SEC_DATA
   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),         /* Sect flags.  */
  0,                             /* Symbol_leading_char.  */
  0,                             /* symbol_leading_char */
  ' ',                          /* AR_pad_char.  */
  ' ',                          /* ar_pad_char */
  15,                           /* AR_max_namelen.  */
  15,                           /* ar_max_namelen */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs.  */
 
 
  {_bfd_dummy_target, vms_object_p,             /* bfd_check_format.  */
  {_bfd_dummy_target, vms_object_p,             /* bfd_check_format.  */
   vms_archive_p, _bfd_dummy_target},
   vms_archive_p, _bfd_dummy_target},
  {bfd_false, vms_mkobject,                     /* bfd_set_format.  */
  {bfd_false, vms_mkobject,                     /* bfd_set_format.  */
   _bfd_generic_mkarchive, bfd_false},
   _bfd_generic_mkarchive, bfd_false},
Line 1684... Line 2147...
  BFD_JUMP_TABLE_LINK (vms),
  BFD_JUMP_TABLE_LINK (vms),
  BFD_JUMP_TABLE_DYNAMIC (vms),
  BFD_JUMP_TABLE_DYNAMIC (vms),
 
 
  NULL,
  NULL,
 
 
  NULL
  (PTR) 0
};
};
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.