19990502 sourceware importbinu_ss_19990502

1 files changed, 1947 insertions, 0 deletions

diff --git a/bfd/vms.c b/bfd/vms.c
new file mode 100644
index 0000000..a5fc13a
--- /dev/null
+++ b/bfd/vms.c
@@ -0,0 +1,1947 @@
+/* vms.c -- BFD back-end for VAX (openVMS/VAX) and
+   EVAX (openVMS/Alpha) files.
+   Copyright 1996, 1997, 1998 Free Software Foundation, Inc.
+
+   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 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "vms.h"
+
+static boolean vms_initialize PARAMS ((bfd *));
+static int priv_section_count;
+static boolean fill_section_ptr PARAMS ((struct bfd_hash_entry *, PTR));
+static boolean vms_fixup_sections PARAMS ((bfd *));
+static boolean copy_symbols PARAMS ((struct bfd_hash_entry *, PTR));
+static bfd_reloc_status_type reloc_nil
+  PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static const struct bfd_target *vms_object_p PARAMS ((bfd *abfd));
+static const struct bfd_target *vms_archive_p PARAMS ((bfd *abfd));
+static boolean vms_mkobject PARAMS ((bfd *abfd));
+static boolean vms_write_object_contents PARAMS ((bfd *abfd));
+static boolean vms_close_and_cleanup PARAMS ((bfd *abfd));
+static boolean vms_bfd_free_cached_info PARAMS ((bfd *abfd));
+static boolean vms_new_section_hook PARAMS ((bfd *abfd, asection *section));
+static boolean vms_get_section_contents
+  PARAMS ((bfd *abfd, asection *section, PTR x1, file_ptr x2,
+	   bfd_size_type x3));
+static boolean vms_get_section_contents_in_window
+  PARAMS ((bfd *abfd, asection *section, bfd_window *w, file_ptr offset,
+	   bfd_size_type count));
+static boolean vms_bfd_copy_private_bfd_data PARAMS ((bfd *src, bfd *dest));
+static boolean vms_bfd_copy_private_section_data
+  PARAMS ((bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec));
+static boolean vms_bfd_copy_private_symbol_data
+  PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
+static boolean vms_bfd_print_private_bfd_data
+  PARAMS ((bfd *abfd, void *file));
+static char *vms_core_file_failing_command PARAMS ((bfd *abfd));
+static int vms_core_file_failing_signal PARAMS ((bfd *abfd));
+static boolean vms_core_file_matches_executable_p
+  PARAMS ((bfd *abfd, bfd *bbfd));
+static boolean vms_slurp_armap PARAMS ((bfd *abfd));
+static boolean vms_slurp_extended_name_table PARAMS ((bfd *abfd));
+static boolean vms_construct_extended_name_table
+  PARAMS ((bfd *abfd, char **tabloc, bfd_size_type *tablen,
+	   const char **name));
+static void vms_truncate_arname
+  PARAMS ((bfd *abfd, CONST char *pathname, char *arhdr));
+static boolean vms_write_armap
+  PARAMS ((bfd *arch, unsigned int elength, struct orl *map,
+	   unsigned int orl_count, int stridx));
+static PTR vms_read_ar_hdr PARAMS ((bfd *abfd));
+static bfd *vms_get_elt_at_index PARAMS ((bfd *abfd, symindex index));
+static bfd *vms_openr_next_archived_file PARAMS ((bfd *arch, bfd *prev));
+static boolean vms_update_armap_timestamp PARAMS ((bfd *abfd));
+static int vms_generic_stat_arch_elt PARAMS ((bfd *abfd, struct stat *stat));
+static long vms_get_symtab_upper_bound PARAMS ((bfd *abfd));
+static long vms_get_symtab PARAMS ((bfd *abfd, asymbol **symbols));
+static void vms_print_symbol
+  PARAMS ((bfd *abfd, PTR file, asymbol *symbol, bfd_print_symbol_type how));
+static void vms_get_symbol_info
+  PARAMS ((bfd *abfd, asymbol *symbol, symbol_info *ret));
+static boolean vms_bfd_is_local_label_name PARAMS ((bfd *abfd, const char *));
+static alent *vms_get_lineno PARAMS ((bfd *abfd, asymbol *symbol));
+static boolean vms_find_nearest_line
+  PARAMS ((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
+  PARAMS ((bfd *abfd, void *ptr, unsigned long size));
+static long vms_read_minisymbols
+  PARAMS ((bfd *abfd, boolean dynamic, PTR *minisymsp, unsigned int *sizep));
+static asymbol *vms_minisymbol_to_symbol
+  PARAMS ((bfd *abfd, boolean dynamic, const PTR minisym, asymbol *sym));
+static long vms_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
+static long vms_canonicalize_reloc
+  PARAMS ((bfd *abfd, asection *srcsec, arelent **location,
+	   asymbol **symbols));
+static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup
+  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
+static boolean vms_set_arch_mach
+  PARAMS ((bfd *abfd, enum bfd_architecture arch, unsigned long mach));
+static boolean vms_set_section_contents
+  PARAMS ((bfd *abfd, asection *section, PTR location, file_ptr offset,
+	   bfd_size_type count));
+static int vms_sizeof_headers PARAMS ((bfd *abfd, boolean reloc));
+static bfd_byte *vms_bfd_get_relocated_section_contents
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info,
+	   struct bfd_link_order *link_order, bfd_byte *data,
+	   boolean relocateable, asymbol **symbols));
+static boolean vms_bfd_relax_section
+  PARAMS ((bfd *abfd, asection *section, struct bfd_link_info *link_info,
+	   boolean *again));
+static boolean vms_bfd_gc_sections
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
+static struct bfd_link_hash_table *vms_bfd_link_hash_table_create
+  PARAMS ((bfd *abfd));
+static boolean vms_bfd_link_add_symbols
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
+static boolean vms_bfd_final_link
+  PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
+static boolean vms_bfd_link_split_section
+  PARAMS ((bfd *abfd, asection *section));
+static long vms_get_dynamic_symtab_upper_bound PARAMS ((bfd *abfd));
+static long vms_canonicalize_dynamic_symtab
+  PARAMS ((bfd *abfd, asymbol **symbols));
+static long vms_get_dynamic_reloc_upper_bound PARAMS ((bfd *abfd));
+static long vms_canonicalize_dynamic_reloc
+  PARAMS ((bfd *abfd, arelent **arel, asymbol **symbols));
+static boolean vms_bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
+static boolean vms_bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
+
+#define vms_make_empty_symbol _bfd_vms_make_empty_symbol
+
+/*===========================================================================*/
+
+const bfd_target vms_alpha_vec =
+{
+
+  "vms-alpha",			/* name */
+  bfd_target_evax_flavour,
+  false,			/* data byte order is little */
+  false,			/* header byte order is little */
+
+  (HAS_RELOC | HAS_SYMS
+   | WP_TEXT | D_PAGED),	/* object flags */
+  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
+   | SEC_READONLY | SEC_CODE | SEC_DATA
+   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* sect flags */
+  0,				/* symbol_leading_char */
+  ' ',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16,
+
+  {_bfd_dummy_target, vms_object_p,		/* bfd_check_format */
+   vms_archive_p, _bfd_dummy_target},
+  {bfd_false, vms_mkobject,			/* bfd_set_format */
+   _bfd_generic_mkarchive, bfd_false},
+  {bfd_false, vms_write_object_contents,	/* bfd_write_contents */
+   _bfd_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (vms),
+  BFD_JUMP_TABLE_COPY (vms),
+  BFD_JUMP_TABLE_CORE (vms),
+  BFD_JUMP_TABLE_ARCHIVE (vms),
+  BFD_JUMP_TABLE_SYMBOLS (vms),
+  BFD_JUMP_TABLE_RELOCS (vms),
+  BFD_JUMP_TABLE_WRITE (vms),
+  BFD_JUMP_TABLE_LINK (vms),
+  BFD_JUMP_TABLE_DYNAMIC (vms),
+
+  (PTR) 0
+};
+
+const bfd_target vms_vax_vec =
+{
+
+  "vms-vax",			/* name */
+  bfd_target_ovax_flavour,
+  false,			/* data byte order is little */
+  false,			/* header byte order is little */
+
+  (HAS_RELOC | HAS_SYMS 	/* object flags */
+   | WP_TEXT | D_PAGED
+   | HAS_LINENO | HAS_DEBUG | HAS_LOCALS),
+
+  (SEC_ALLOC | SEC_LOAD | SEC_RELOC
+   | SEC_READONLY | SEC_CODE | SEC_DATA
+   | SEC_HAS_CONTENTS | SEC_IN_MEMORY),		/* sect flags */
+  0,				/* symbol_leading_char */
+  ' ',				/* ar_pad_char */
+  15,				/* ar_max_namelen */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
+  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
+  bfd_getl32, bfd_getl_signed_32, bfd_putl32,
+  bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */
+
+  {_bfd_dummy_target, vms_object_p,		/* bfd_check_format */
+   vms_archive_p, _bfd_dummy_target},
+  {bfd_false, vms_mkobject,			/* bfd_set_format */
+   _bfd_generic_mkarchive, bfd_false},
+  {bfd_false, vms_write_object_contents,	/* bfd_write_contents */
+   _bfd_write_archive_contents, bfd_false},
+
+  BFD_JUMP_TABLE_GENERIC (vms),
+  BFD_JUMP_TABLE_COPY (vms),
+  BFD_JUMP_TABLE_CORE (vms),
+  BFD_JUMP_TABLE_ARCHIVE (vms),
+  BFD_JUMP_TABLE_SYMBOLS (vms),
+  BFD_JUMP_TABLE_RELOCS (vms),
+  BFD_JUMP_TABLE_WRITE (vms),
+  BFD_JUMP_TABLE_LINK (vms),
+  BFD_JUMP_TABLE_DYNAMIC (vms),
+
+  (PTR) 0
+};
+
+/*===========================================================================*/
+
+/* Initialize private data  */
+
+static boolean
+vms_initialize (abfd)
+     bfd *abfd;
+{
+  int i;
+
+  if (abfd->tdata.any != 0)
+    return true;
+
+  bfd_set_start_address (abfd, (bfd_vma)-1);
+
+  abfd->tdata.any = ((struct vms_private_data_struct*)
+		     bfd_malloc (sizeof (struct vms_private_data_struct)));
+  if (abfd->tdata.any == 0)
+    return false;
+
+#ifdef __ALPHA
+  PRIV(is_vax) = 0;
+#else
+  PRIV(is_vax) = 1;
+#endif
+  PRIV(vms_buf) = 0;
+  PRIV(buf_size) = 0;
+  PRIV(rec_length) = 0;
+  PRIV(file_format) = FF_UNKNOWN;
+  PRIV(fixup_done) = false;
+  PRIV(sections) = NULL;
+
+  PRIV(stack) = ((struct stack_struct *)
+		 bfd_malloc (sizeof (struct stack_struct) * STACKSIZE));
+  if (PRIV(stack) == 0)
+    {
+     vms_init_no_mem1:
+      free (abfd->tdata.any);
+      abfd->tdata.any = 0;
+      return false;
+    }
+  PRIV(stackptr) = 0;
+
+  PRIV(vms_symbol_table) = ((struct bfd_hash_table *)
+			     bfd_malloc (sizeof (struct bfd_hash_table)));
+  if (PRIV(vms_symbol_table) == 0)
+    {
+     vms_init_no_mem2:
+      free (PRIV(stack));
+      PRIV(stack) = 0;
+      goto vms_init_no_mem1;
+    }
+
+  if (!bfd_hash_table_init (PRIV(vms_symbol_table), _bfd_vms_hash_newfunc))
+    return false;
+
+  PRIV(location_stack) = ((struct location_struct *)
+			  bfd_malloc (sizeof (struct location_struct)
+				      * LOCATION_SAVE_SIZE));
+  if (PRIV(location_stack) == 0)
+    {
+     vms_init_no_mem3:
+      free (PRIV(vms_symbol_table));
+      PRIV(vms_symbol_table) = 0;
+      goto vms_init_no_mem2;
+    }
+
+  for (i = 0; i < VMS_SECTION_COUNT; i++)
+    PRIV(vms_section_table)[i] = NULL;
+
+  PRIV(output_buf) = (unsigned char *) malloc (MAX_OUTREC_SIZE);
+  if (PRIV(output_buf) == 0)
+    {
+      free (PRIV(location_stack));
+      PRIV(location_stack) = 0;
+      goto vms_init_no_mem3;
+    }
+  PRIV(push_level) = 0;
+  PRIV(pushed_size) = 0;
+  PRIV(length_pos) = 2;
+  PRIV(output_size) = 0;
+  PRIV(output_alignment) = 1;
+
+  return true;
+}
+
+
+/* Fill symbol->section with section ptr
+   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 boolean
+fill_section_ptr (entry, sections)
+     struct bfd_hash_entry *entry;
+     PTR sections;
+{
+  asection *sec;
+  asymbol *sym;
+
+  sym =  ((vms_symbol_entry *)entry)->symbol;
+  sec = sym->section;
+
+#if VMS_DEBUG
+  vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec);
+#endif
+
+  /* fill forward references (these contain section number, not section ptr).  */
+
+  if ((int)sec < priv_section_count)
+    {
+      sec = ((vms_symbol_entry *)entry)->symbol->section =
+	((asection **)sections)[(int)sec];
+    }
+
+  if (strcmp (sym->name, sec->name) == 0)
+    sym->flags |= BSF_SECTION_SYM;
+
+  return true;
+}
+
+
+/* Fixup sections
+   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 boolean
+vms_fixup_sections (abfd)
+     bfd *abfd;
+{
+  asection *s;
+
+  if (PRIV(fixup_done))
+    return true;
+
+  /*
+   * traverse symbol table and fill in all section pointers
+   */
+
+  /* can't provide section count as argument to fill_section_ptr().  */
+  priv_section_count = PRIV(section_count);
+  bfd_hash_traverse (PRIV(vms_symbol_table), fill_section_ptr,
+		    (PTR)(PRIV(sections)));
+
+  PRIV(fixup_done) = 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 *
+vms_object_p (abfd)
+     bfd *abfd;
+{
+  int err = 0;
+  int prev_type;
+  const struct bfd_target *target_vector = 0;
+  const bfd_arch_info_type *arch = 0;
+
+#if VMS_DEBUG
+  vms_debug (1, "vms_object_p(%p)\n", abfd);
+#endif
+
+  if (!vms_initialize (abfd))
+    {
+      fprintf (stderr, "vms_initialize () failed !!\n");
+      return 0;
+    }
+
+  if (bfd_seek (abfd, 0L, SEEK_SET))
+    {
+      bfd_set_error (bfd_error_file_truncated);
+      return 0;
+    }
+
+  prev_type = -1;
+
+  do
+    {
+#if VMS_DEBUG
+      vms_debug (7, "reading at %08lx\n", bfd_tell(abfd));
+#endif
+      if (_bfd_vms_next_record (abfd) < 0)
+	{
+#if VMS_DEBUG
+	  vms_debug (2, "next_record failed\n");      
+#endif
+	  bfd_set_error (bfd_error_wrong_format);
+	  return 0;
+	}
+
+      if ((prev_type == EOBJ_S_C_EGSD)
+	   && (PRIV(rec_type) != EOBJ_S_C_EGSD))
+	{
+	  if (vms_fixup_sections (abfd) == false)
+	    {
+#if VMS_DEBUG
+	      vms_debug (2, "vms_fixup_sections failed\n");
+#endif
+	      bfd_set_error (bfd_error_wrong_format);
+	      return 0;
+	    }
+	}
+
+      prev_type = PRIV(rec_type);
+
+      if (target_vector == 0)
+	{
+	  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 EOBJ_S_C_EMH:
+	    err = _bfd_vms_slurp_hdr (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_EOM:
+	  case OBJ_S_C_EOMW:
+	  case EOBJ_S_C_EEOM:
+	    err = _bfd_vms_slurp_eom (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_GSD:
+	  case EOBJ_S_C_EGSD:
+	    err = _bfd_vms_slurp_gsd (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_TIR:
+	  case EOBJ_S_C_ETIR:
+	    err = _bfd_vms_slurp_tir (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_DBG:
+	  case EOBJ_S_C_EDBG:
+	    err = _bfd_vms_slurp_dbg (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_TBT:
+	  case EOBJ_S_C_ETBT:
+	    err = _bfd_vms_slurp_tbt (abfd, prev_type);
+	    break;
+	  case OBJ_S_C_LNK:
+	    err = _bfd_vms_slurp_lnk (abfd, prev_type);
+	    break;
+	  default:
+	    err = -1;
+	}
+      if (err != 0)
+	{
+#if VMS_DEBUG
+	  vms_debug (2, "slurp type %d failed with %d\n", prev_type, err);
+#endif
+	  bfd_set_error (bfd_error_wrong_format);
+	  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)
+    {
+      if (vms_fixup_sections (abfd) == false)
+	{
+#if VMS_DEBUG
+	  vms_debug (2, "vms_fixup_sections failed\n");
+#endif
+	  bfd_set_error (bfd_error_wrong_format);
+	  return 0;
+	}
+
+      /* set arch_info to vax  */
+ 
+      arch = bfd_scan_arch ("vax");
+      PRIV (is_vax) = 1;
+#if VMS_DEBUG
+      vms_debug (2, "arch is vax\n");
+#endif
+    }
+  else if (target_vector == &vms_alpha_vec)
+    {
+      /* set arch_info to alpha  */
+ 
+      arch = bfd_scan_arch ("alpha");
+      PRIV (is_vax) = 0;
+#if VMS_DEBUG
+      vms_debug (2, "arch is alpha\n");
+#endif
+    }
+
+  if (arch == 0)
+    {
+#if VMS_DEBUG
+      vms_debug (2, "arch not found\n");
+#endif
+      bfd_set_error (bfd_error_wrong_format);
+      return 0;
+    }
+  abfd->arch_info = arch;
+
+  return target_vector;
+}
+
+
+/* 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 (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_archive_p(%p)\n", abfd);
+#endif
+
+  return 0;
+}
+
+
+/* Set the format of a file being written.  */
+
+static boolean
+vms_mkobject (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_mkobject(%p)\n", abfd);
+#endif
+
+  if (!vms_initialize (abfd))
+    {
+      fprintf (stderr, "vms_initialize () failed !!\n");
+      return 0;
+    }
+
+  {
+#ifdef __VAX
+    const bfd_arch_info_type *arch = bfd_scan_arch ("vax");
+#else
+    const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
+#endif
+    if (arch == 0)
+      {
+	bfd_set_error(bfd_error_wrong_format);
+	return 0;
+      }
+    abfd->arch_info = arch;
+  }
+
+  return true;
+}
+
+
+/* Write cached information into a file being written, at bfd_close.  */
+
+static boolean
+vms_write_object_contents (abfd)
+     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 -----------------------------------------------------------*/
+
+/* Called when the BFD is being closed to do any necessary cleanup.  */
+
+static boolean
+vms_close_and_cleanup (abfd)
+     bfd *abfd;
+{
+  asection *sec;
+  vms_section *es, *es1;
+  vms_reloc *er, *er1;
+  int i;
+
+#if VMS_DEBUG
+  vms_debug (1, "vms_close_and_cleanup(%p)\n", abfd);
+#endif
+  if (abfd == 0)
+    return true;
+
+  if (PRIV(vms_buf) != NULL)
+    {
+      free (PRIV(vms_buf));
+      PRIV(vms_buf) = NULL;
+    }
+  PRIV(buf_size) = 0;
+
+  if (PRIV(output_buf) != 0)
+    {
+      free (PRIV(output_buf));
+      PRIV(output_buf) = 0;
+    }
+
+  sec = abfd->sections;
+  while (sec != NULL)
+    {
+      if (sec->contents)
+	free (sec->contents);
+      sec = sec->next;
+    }
+
+  if (PRIV(sections) != NULL)
+    {
+      free (PRIV(sections));
+      PRIV(sections) = NULL;
+    }
+
+  if (PRIV(vms_symbol_table))
+    {
+      bfd_hash_table_free (PRIV(vms_symbol_table));
+      PRIV(vms_symbol_table) = 0;
+    }
+
+  if (PRIV(stack))
+    {
+      free (PRIV(stack));
+      PRIV(stack) = 0;
+    }
+
+  if (PRIV(location_stack))
+    {
+      free (PRIV(location_stack));
+      PRIV(location_stack) = 0;
+    }
+
+  for (i = 0; i < VMS_SECTION_COUNT; i++)
+    {
+      es = PRIV(vms_section_table)[i];
+      while (es != NULL)
+	{
+	  es1 = es->next;
+	  free (es);
+	  es = es1;
+	}
+      PRIV(vms_section_table)[i] = NULL;
+   }
+
+  free (abfd->tdata.any);
+  abfd->tdata.any = NULL;
+
+  return true;
+}
+
+
+/* Ask the BFD to free all cached information.  */
+static boolean
+vms_bfd_free_cached_info (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_free_cached_info(%p)\n", abfd);
+#endif
+  return true;
+}
+
+
+/* Called when a new section is created.  */
+
+static boolean
+vms_new_section_hook (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n", abfd, section->index, section->name, abfd->section_count);
+#endif
+  bfd_set_section_alignment(abfd, section, 4);
+
+  if (abfd->section_count > PRIV(section_count))
+    {
+      PRIV(sections) = ((asection **)
+			    bfd_realloc (PRIV(sections), abfd->section_count * sizeof (asection *)));
+      if (PRIV(sections) == 0)
+	return false;
+      PRIV(section_count) = abfd->section_count;
+    }
+#if VMS_DEBUG
+  vms_debug (6, "section_count: %d\n", PRIV(section_count));
+#endif
+  PRIV(sections)[section->index] = section;
+#if VMS_DEBUG
+  vms_debug (7, "%d: %s\n", section->index, section->name);
+#endif
+
+  return true;
+}
+
+
+/* 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 boolean
+vms_get_section_contents (abfd, section, buf, offset, buf_size)
+     bfd *abfd;
+     asection *section;
+     PTR buf;
+     file_ptr offset;
+     bfd_size_type buf_size;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_section_contents(%p, %s, %p, off %ld, size %d)\n",
+		 abfd, section->name, buf, offset, (int)buf_size);
+#endif
+
+  /* shouldn't be called, since all sections are IN_MEMORY  */
+
+  return false;
+}
+
+/* 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 boolean
+vms_get_section_contents_in_window (abfd, section, w, offset, count)
+     bfd *abfd;
+     asection *section;
+     bfd_window *w;
+     file_ptr offset;
+     bfd_size_type count;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_section_contents_in_window(%p, %s, %p, off %ld, count %d)\n",
+		 abfd, section->name, w, offset, (int)count);
+#endif
+
+  /* shouldn't be called, since all sections are IN_MEMORY  */
+
+  return false;
+}
+
+/*-- Part 4.2, copy private data --------------------------------------------*/
+
+/* Called to copy BFD general private data from one object file
+   to another.  */
+
+static boolean
+vms_bfd_copy_private_bfd_data (src, dest)
+     bfd *src;
+     bfd *dest;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_copy_private_bfd_data(%p, %p)\n", src, dest);
+#endif
+  return true;
+}
+
+
+/* Merge private BFD information from the BFD @var{ibfd} to the
+   the output file BFD @var{obfd} when linking.  Return <<true>>
+   on success, <<false>> on error.  Possible error returns are:
+
+   o <<bfd_error_no_memory>> -
+     Not enough memory exists to create private data for @var{obfd}.  */
+
+static boolean
+vms_bfd_merge_private_bfd_data (ibfd, obfd)
+     bfd *ibfd;
+     bfd *obfd;
+{
+#if VMS_DEBUG
+  vms_debug (1,"vms_bfd_merge_private_bfd_data(%p, %p)\n", ibfd, obfd);
+#endif
+  return true;
+}
+
+
+/* Set private BFD flag information in the BFD @var{abfd}.
+   Return <<true>> on success, <<false>> on error.  Possible error
+   returns are:
+
+   o <<bfd_error_no_memory>> -
+     Not enough memory exists to create private data for @var{obfd}.  */
+
+static boolean
+vms_bfd_set_private_flags (abfd, flags)
+     bfd *abfd;
+     flagword flags;
+{
+#if VMS_DEBUG
+  vms_debug (1,"vms_bfd_set_private_flags(%p, %lx)\n", abfd, (long)flags);
+#endif
+  return true;
+}
+
+
+/* Called to copy BFD private section data from one object file
+   to another.  */
+
+static boolean
+vms_bfd_copy_private_section_data (srcbfd, srcsec, dstbfd, dstsec)
+     bfd *srcbfd;
+     asection *srcsec;
+     bfd *dstbfd;
+     asection *dstsec;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_copy_private_section_data(%p, %s, %p, %s)\n",
+		 srcbfd, srcsec->name, dstbfd, dstsec->name);
+#endif
+  return true;
+}
+
+/* Called to copy BFD private symbol data from one object file
+   to another.  */
+
+static boolean 
+vms_bfd_copy_private_symbol_data (ibfd, isym, obfd, osym)
+     bfd *ibfd;
+     asymbol *isym;
+     bfd *obfd;
+     asymbol *osym;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_copy_private_symbol_data(%p, %s, %p, %s)\n",
+		 ibfd, isym->name, obfd, osym->name);
+#endif
+  return true;
+}
+
+/*-- Part 4.3, core file ----------------------------------------------------*/
+
+/* Return a read-only string explaining which program was running
+   when it failed and produced the core file abfd.  */
+
+static char *
+vms_core_file_failing_command (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_core_file_failing_command(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Returns the signal number which caused the core dump which
+   generated the file the BFD abfd is attached to.  */
+
+static int
+vms_core_file_failing_signal (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_core_file_failing_signal(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Return true if the core file attached to core_bfd was generated
+   by a run of the executable file attached to exec_bfd, false otherwise.  */
+
+static boolean
+vms_core_file_matches_executable_p (abfd, bbfd)
+     bfd *abfd;
+     bfd *bbfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_core_file_matches_executable_p(%p, %p)\n", abfd, bbfd);
+#endif
+  return false;
+}
+
+/*-- Part 4.4, archive ------------------------------------------------------*/
+
+/* ???	do something with an archive map.
+   Return false on error, true otherwise.  */
+
+static boolean
+vms_slurp_armap (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_slurp_armap(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* ???	do something with an extended name table.
+   Return false on error, true otherwise.  */
+
+static boolean
+vms_slurp_extended_name_table (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_slurp_extended_name_table(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* ???	do something with an extended name table.
+   Return false on error, true otherwise.  */
+
+static boolean
+vms_construct_extended_name_table (abfd, tabloc, tablen, name)
+     bfd *abfd;
+     char **tabloc;
+     bfd_size_type *tablen;
+     const char **name;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_construct_extended_name_table(%p)\n", abfd);
+#endif
+  return false;
+}
+
+
+/* Truncate the name of an archive to match system-dependent restrictions  */
+
+static void
+vms_truncate_arname (abfd, pathname, arhdr)
+     bfd *abfd;
+     CONST char *pathname;
+     char *arhdr;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_truncate_arname(%p, %s, %s)\n", abfd, pathname, arhdr);
+#endif
+  return;
+}
+
+
+/* ???	write archive map  */
+
+static boolean
+vms_write_armap (arch, elength, map, orl_count, stridx)
+     bfd *arch;
+     unsigned int elength;
+     struct orl *map;
+     unsigned int orl_count;
+     int stridx;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_write_armap(%p, %d, %p, %d %d)\n",
+	arch, elength, map, orl_count, stridx);
+#endif
+  return true;
+}
+
+/* Read archive header ???  */
+
+static PTR
+vms_read_ar_hdr (abfd)
+    bfd * abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_read_ar_hdr(%p)\n", abfd);
+#endif
+  return (PTR)0;
+}
+
+
+/* Provided a BFD, @var{archive}, containing an archive and NULL, open
+   an input BFD on the first contained element and returns that.
+   Subsequent calls should pass the archive and the previous return value
+   to return a created BFD to the next contained element.
+   NULL is returned when there are no more.  */
+
+static bfd *
+vms_openr_next_archived_file (arch, prev)
+     bfd *arch;
+     bfd *prev;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_openr_next_archived_file(%p, %p)\n", arch, prev);
+#endif
+  return false;
+}
+
+
+/* Return the BFD which is referenced by the symbol in ABFD indexed by
+   INDEX.  INDEX should have been returned by bfd_get_next_mapent.  */
+
+static bfd *
+vms_get_elt_at_index (abfd, index)
+     bfd *abfd;
+     symindex index;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_elt_at_index(%p, %p)\n", abfd, index);
+#endif
+  return _bfd_generic_get_elt_at_index(abfd, index);
+}
+
+
+/* ???
+   -> bfd_generic_stat_arch_elt  */
+
+static int
+vms_generic_stat_arch_elt (abfd, stat)
+     bfd *abfd;
+     struct stat *stat;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_generic_stat_arch_elt(%p, %p)\n", abfd, stat);
+#endif
+  return bfd_generic_stat_arch_elt(abfd, stat);
+}
+
+
+/* This is a new function in bfd 2.5  */
+
+static boolean
+vms_update_armap_timestamp (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_update_armap_timestamp(%p)\n", abfd);
+#endif
+  return true;
+}
+
+/*-- Part 4.5, symbols --------------------------------------------------------*/
+
+/* Return the number of bytes required to store a vector of pointers
+   to asymbols for all the symbols in the BFD abfd, including a
+   terminal NULL pointer. If there are no symbols in the BFD,
+   then return 0.  If an error occurs, return -1.  */
+
+static long
+vms_get_symtab_upper_bound (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_symtab_upper_bound(%p), %d symbols\n", abfd, PRIV(gsd_sym_count));
+#endif
+  return (PRIV(gsd_sym_count)+1) * sizeof(asymbol *);
+}
+
+
+/* Copy symbols from hash table to symbol vector
+
+   called from bfd_hash_traverse in vms_get_symtab
+   init counter to 0 if entry == 0  */
+
+static boolean
+copy_symbols (entry, arg)
+     struct bfd_hash_entry *entry;
+     PTR arg;
+{
+  bfd *abfd = (bfd *) arg;
+
+  if (entry == NULL)	/* init counter */
+    PRIV(symnum) = 0;
+  else			/* fill vector, inc counter */
+    PRIV(symcache)[PRIV(symnum)++] = ((vms_symbol_entry *)entry)->symbol;
+
+  return true;
+}
+
+
+/* Read the symbols from the BFD abfd, and fills in the vector
+   location with pointers to the symbols and a trailing NULL.
+
+   return # of symbols read  */
+
+static long
+vms_get_symtab (abfd, symbols)
+     bfd *abfd;
+     asymbol **symbols;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_symtab(%p, <ret>)\n", abfd);
+#endif
+
+	/* init counter */
+  (void)copy_symbols((struct bfd_hash_entry *)0, abfd);
+
+	/* traverse table and fill symbols vector */
+
+  PRIV(symcache) = symbols;
+  bfd_hash_traverse(PRIV(vms_symbol_table), copy_symbols, (PTR)abfd);
+
+  symbols[PRIV(gsd_sym_count)] = NULL;
+
+  return PRIV(gsd_sym_count);
+}
+
+
+/* Create a new asymbol structure for the BFD abfd and return a pointer
+   to it.
+   This routine is necessary because each back end has private information
+   surrounding the asymbol. Building your own asymbol and pointing to it
+   will not create the private information, and will cause problems later on.  */
+
+asymbol *
+_bfd_vms_make_empty_symbol (abfd)
+     bfd *abfd;
+{
+  asymbol *symbol = (asymbol *)bfd_zalloc(abfd, sizeof(asymbol));
+
+#if VMS_DEBUG
+  vms_debug (1, "_bfd_vms_make_empty_symbol(%p)\n", abfd);
+#endif
+
+  if (symbol == 0)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return 0;
+    }
+  symbol->the_bfd = abfd;
+
+  return symbol;
+}
+
+
+/* Print symbol to file according to how. how is one of
+   bfd_print_symbol_name	just print the name
+   bfd_print_symbol_more	print more (???)
+   bfd_print_symbol_all	print all we know, which is not much right now :-)  */
+
+static void
+vms_print_symbol (abfd, file, symbol, how)
+     bfd *abfd;
+     PTR file;
+     asymbol *symbol;
+     bfd_print_symbol_type how;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_print_symbol(%p, %p, %p, %d)\n", abfd, file, symbol, how);
+#endif
+
+  switch (how)
+    {
+      case bfd_print_symbol_name:
+      case bfd_print_symbol_more:
+	fprintf((FILE *)file," %s", symbol->name);
+      break;
+
+      break;
+
+      case bfd_print_symbol_all:
+	{
+	  CONST char *section_name = symbol->section->name;
+
+	  bfd_print_symbol_vandf((PTR)file,symbol);
+
+	  fprintf((FILE *)file," %-8s %s", section_name, symbol->name);
+        }
+      break;
+    }
+  return;
+}
+
+
+/* Return information about symbol in ret.
+
+   fill type, value and name
+   type:
+	A	absolute
+	B	bss segment symbol
+	C	common symbol
+	D	data segment symbol
+	f	filename
+	t	a static function symbol
+	T	text segment symbol
+	U	undefined
+	-	debug  */
+
+static void
+vms_get_symbol_info (abfd, symbol, ret)
+     bfd *abfd;
+     asymbol *symbol;
+     symbol_info *ret;
+{
+  asection *sec;
+
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_symbol_info(%p, %p, %p)\n", abfd, symbol, ret);
+#endif
+
+  sec = symbol->section;
+
+  if (ret == 0)
+    return;
+
+  if (bfd_is_com_section (sec))
+    ret->type = 'C';
+  else if (bfd_is_abs_section (sec))
+    ret->type = 'A';
+  else if (bfd_is_und_section (sec))
+    ret->type = 'U';
+  else if (bfd_is_ind_section (sec))
+    ret->type = 'I';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
+    ret->type = 'T';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
+    ret->type = 'D';
+  else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
+    ret->type = 'B';
+  else
+    ret->type = '-';
+
+  if (ret->type != 'U')
+    ret->value = symbol->value + symbol->section->vma;
+  else
+    ret->value = 0;
+  ret->name = symbol->name;
+
+  return;
+}
+
+
+/* Return true if the given symbol sym in the BFD abfd is
+   a compiler generated local label, else return false.  */
+
+static boolean
+vms_bfd_is_local_label_name (abfd, name)
+     bfd *abfd;
+     const char *name;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_is_local_label_name(%p, %s)\n", abfd, name);
+#endif
+  return name[0] == '$';
+}
+
+
+/* Get source line number for symbol  */
+
+static alent *
+vms_get_lineno (abfd, symbol)
+     bfd *abfd;
+     asymbol *symbol;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_lineno(%p, %p)\n", abfd, symbol);
+#endif
+  return 0;
+}
+
+
+/* Provided a BFD, a section and an offset into the section, calculate and
+   return the name of the source file and the line nearest to the wanted
+   location.  */
+
+static boolean
+vms_find_nearest_line (abfd, section, symbols, offset, file, func, line)
+     bfd *abfd;
+     asection *section;
+     asymbol **symbols;
+     bfd_vma offset;
+     CONST char **file;
+     CONST char **func;
+     unsigned int *line;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_find_nearest_line(%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
+	      abfd, section->name, symbols, (long int)offset);
+#endif
+  return false;
+}
+
+
+/* Back-door to allow format-aware applications to create debug symbols
+   while using BFD for everything else.  Currently used by the assembler
+   when creating COFF files.  */
+
+static asymbol *
+vms_bfd_make_debug_symbol (abfd, ptr, size)
+     bfd *abfd;
+     void *ptr;
+     unsigned long size;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_make_debug_symbol(%p, %p, %ld)\n", abfd, ptr, size);
+#endif
+  return 0;
+}
+
+
+/* Read minisymbols.  For minisymbols, we use the unmodified a.out
+   symbols.  The minisymbol_to_symbol function translates these into
+   BFD asymbol structures.  */
+
+static long
+vms_read_minisymbols (abfd, dynamic, minisymsp, sizep)
+     bfd *abfd;
+     boolean dynamic;
+     PTR *minisymsp;
+     unsigned int *sizep;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_read_minisymbols(%p, %d, %p, %d)\n", abfd, dynamic, minisymsp, *sizep);
+#endif
+  return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
+}
+
+/* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
+   unmodified a.out symbol.  The SYM argument is a structure returned
+   by bfd_make_empty_symbol, which we fill in here.  */
+
+static asymbol *
+vms_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
+     bfd *abfd;
+     boolean dynamic;
+     const PTR minisym;
+     asymbol *sym;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_minisymbol_to_symbol(%p, %d, %p, %p)\n", abfd, dynamic, minisym, sym);
+#endif
+  return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
+}
+
+/*-- Part 4.6, relocations --------------------------------------------------*/
+
+/* Return the number of bytes required to store the relocation information
+   associated with section sect attached to bfd abfd.
+   If an error occurs, return -1.  */
+
+static long
+vms_get_reloc_upper_bound (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_reloc_upper_bound(%p, %s)\n", abfd, section->name);
+#endif
+  return -1L;
+}
+
+
+/* Call the back end associated with the open BFD abfd and translate the
+   external form of the relocation information attached to sec into the
+   internal canonical form.  Place the table into memory at loc, which has
+   been preallocated, usually by a call to bfd_get_reloc_upper_bound.
+   Returns the number of relocs, or -1 on error.  */
+
+static long
+vms_canonicalize_reloc (abfd, section, location, symbols)
+     bfd *abfd;
+     asection *section;
+     arelent **location;
+     asymbol **symbols;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_canonicalize_reloc(%p, %s, <ret>, <ret>)\n", abfd, section->name);
+#endif
+  return false;
+}
+
+/*---------------------------------------------------------------------------*/
+/* this is just copied from ecoff-alpha, needs to be fixed probably */
+
+/* How to process the various reloc types.  */
+
+static bfd_reloc_status_type
+reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
+     bfd *abfd;
+     arelent *reloc;
+     asymbol *sym;
+     PTR data;
+     asection *sec;
+     bfd *output_bfd;
+     char **error_message;
+{
+#if VMS_DEBUG
+  vms_debug (1, "reloc_nil(abfd %p, output_bfd %p)\n", abfd, output_bfd);
+  vms_debug (2, "In section %s, symbol %s\n",
+	sec->name, sym->name);
+  vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
+		reloc->sym_ptr_ptr[0]->name,
+		(unsigned long)reloc->address,
+		(unsigned long)reloc->addend, reloc->howto->name);
+  vms_debug (2, "data at %p\n", data);
+/*  _bfd_hexdump (2, data, bfd_get_reloc_size(reloc->howto),0); */
+#endif
+
+  return bfd_reloc_ok;
+}
+
+/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
+   from smaller values.  Start with zero, widen, *then* decrement.  */
+#define MINUS_ONE	(((bfd_vma)0) - 1)
+
+static reloc_howto_type alpha_howto_table[] =
+{
+  HOWTO (ALPHA_R_IGNORE,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 8,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "IGNORE",		/* name */
+	 true,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 true),			/* pcrel_offset */
+
+  /* A 64 bit reference to a symbol.  */
+  HOWTO (ALPHA_R_REFQUAD,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "REFQUAD",		/* name */
+	 true,			/* partial_inplace */
+	 MINUS_ONE,		/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 21 bit branch.  The native assembler generates these for
+     branches within the text segment, and also fills in the PC
+     relative offset in the instruction.  */
+  HOWTO (ALPHA_R_BRADDR,	/* type */
+	 2,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 21,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "BRADDR",		/* name */
+	 true,			/* partial_inplace */
+	 0x1fffff,		/* src_mask */
+	 0x1fffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A hint for a jump to a register.  */
+  HOWTO (ALPHA_R_HINT,		/* type */
+	 2,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 14,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "HINT",		/* name */
+	 true,			/* partial_inplace */
+	 0x3fff,		/* src_mask */
+	 0x3fff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 16 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL16,	/* type */
+	 0,			/* rightshift */
+	 1,			/* size (0 = byte, 1 = short, 2 = long) */
+	 16,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "SREL16",		/* name */
+	 true,			/* partial_inplace */
+	 0xffff,		/* src_mask */
+	 0xffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* 32 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL32,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "SREL32",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 64 bit PC relative offset.  */
+  HOWTO (ALPHA_R_SREL64,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 true,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "SREL64",		/* name */
+	 true,			/* partial_inplace */
+	 MINUS_ONE,		/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Push a value on the reloc evaluation stack.  */
+  HOWTO (ALPHA_R_OP_PUSH,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "OP_PUSH",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Store the value from the stack at the given address.  Store it in
+     a bitfield of size r_size starting at bit position r_offset.  */
+  HOWTO (ALPHA_R_OP_STORE,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "OP_STORE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 MINUS_ONE,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Subtract the reloc address from the value on the top of the
+     relocation stack.  */
+  HOWTO (ALPHA_R_OP_PSUB,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "OP_PSUB",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Shift the value on the top of the relocation stack right by the
+     given value.  */
+  HOWTO (ALPHA_R_OP_PRSHIFT,	/* type */
+	 0,			/* rightshift */
+	 0,			/* size (0 = byte, 1 = short, 2 = long) */
+	 0,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "OP_PRSHIFT",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* Hack. Linkage is done by linker.  */
+  HOWTO (ALPHA_R_LINKAGE,	/* type */
+	 0,			/* rightshift */
+	 8,			/* size (0 = byte, 1 = short, 2 = long) */
+	 256,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_dont, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "LINKAGE",		/* name */
+	 false,			/* partial_inplace */
+	 0,			/* src_mask */
+	 0,			/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 32 bit reference to a symbol.  */
+  HOWTO (ALPHA_R_REFLONG,	/* type */
+	 0,			/* rightshift */
+	 2,			/* size (0 = byte, 1 = short, 2 = long) */
+	 32,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_bitfield, /* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "REFLONG",		/* name */
+	 true,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+  /* A 64 bit reference to a procedure, written as 32 bit value.  */
+  HOWTO (ALPHA_R_CODEADDR,	/* type */
+	 0,			/* rightshift */
+	 4,			/* size (0 = byte, 1 = short, 2 = long) */
+	 64,			/* bitsize */
+	 false,			/* pc_relative */
+	 0,			/* bitpos */
+	 complain_overflow_signed,/* complain_on_overflow */
+	 reloc_nil,		/* special_function */
+	 "CODEADDR",		/* name */
+	 false,			/* partial_inplace */
+	 0xffffffff,		/* src_mask */
+	 0xffffffff,		/* dst_mask */
+	 false),		/* pcrel_offset */
+
+};
+
+/* Return a pointer to a howto structure which, when invoked, will perform
+   the relocation code on data from the architecture noted.  */
+
+static const struct reloc_howto_struct *
+vms_bfd_reloc_type_lookup (abfd, code)
+     bfd *abfd;
+     bfd_reloc_code_real_type code;
+{
+  int alpha_type;
+
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_reloc_type_lookup(%p, %d)\t", abfd, code);
+#endif
+
+  switch (code)
+    {
+      case BFD_RELOC_16:		alpha_type = ALPHA_R_SREL16;	break;
+      case BFD_RELOC_32:		alpha_type = ALPHA_R_REFLONG;	break;
+      case BFD_RELOC_64:		alpha_type = ALPHA_R_REFQUAD;	break;
+      case BFD_RELOC_CTOR:		alpha_type = ALPHA_R_REFQUAD;	break;
+      case BFD_RELOC_23_PCREL_S2:	alpha_type = ALPHA_R_BRADDR;	break;
+      case BFD_RELOC_ALPHA_HINT:	alpha_type = ALPHA_R_HINT;	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_64_PCREL:		alpha_type = ALPHA_R_SREL64;	break;
+      case BFD_RELOC_ALPHA_LINKAGE:	alpha_type = ALPHA_R_LINKAGE;	break;
+      case BFD_RELOC_ALPHA_CODEADDR:	alpha_type = ALPHA_R_CODEADDR;	break;
+      default:
+	(*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
+	return (const struct reloc_howto_struct *) NULL;
+    }
+#if VMS_DEBUG
+  vms_debug (2, "reloc is %s\n", alpha_howto_table[alpha_type].name);
+#endif
+  return &alpha_howto_table[alpha_type];
+}
+
+
+/*-- Part 4.7, writing an object file ---------------------------------------*/
+
+/* Set the architecture and machine type in BFD abfd to arch and mach.
+   Find the correct pointer to a structure and insert it into the arch_info
+   pointer.  */
+
+static boolean
+vms_set_arch_mach (abfd, arch, mach)
+     bfd *abfd;
+     enum bfd_architecture arch;
+     unsigned long mach;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_set_arch_mach(%p, %d, %ld)\n", abfd, arch, mach);
+#endif
+  abfd->arch_info = bfd_scan_arch("alpha");
+
+  return true;
+}
+
+
+/* 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
+   offset offset for count bytes.
+
+   Normally true is returned, else false. Possible error returns are:
+   o bfd_error_no_contents - The output section does not have the
+	SEC_HAS_CONTENTS attribute, so nothing can be written to it.
+   o and some more too  */
+
+static boolean
+vms_set_section_contents (abfd, section, location, offset, count)
+     bfd *abfd;
+     asection *section;
+     PTR location;
+     file_ptr offset;
+     bfd_size_type count;
+{
+#if VMS_DEBUG
+  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);
+  vms_debug (2, "secraw %d, seccooked %d\n", (int)section->_raw_size, (int)section->_cooked_size);
+#endif
+  return _bfd_save_vms_section(abfd, section, location, offset, count);
+}
+
+
+/*-- Part 4.8, linker -------------------------------------------------------*/
+
+/* Get the size of the section headers.  */
+
+static int
+vms_sizeof_headers (abfd, reloc)
+     bfd *abfd;
+     boolean reloc;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_sizeof_headers(%p, %s)\n", abfd, (reloc)?"True":"False");
+#endif
+  return 0;
+}
+
+
+/* Provides default handling of relocation effort for back ends
+   which can't be bothered to do it efficiently.  */
+
+static bfd_byte *
+vms_bfd_get_relocated_section_contents (abfd, link_info, link_order, data,
+					 relocateable, symbols)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+     struct bfd_link_order *link_order;
+     bfd_byte *data;
+     boolean relocateable;
+     asymbol **symbols;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_get_relocated_section_contents(%p, %p, %p, %p, %s, %p)\n",
+			abfd, link_info, link_order, data, (relocateable)?"True":"False", symbols);
+#endif
+  return 0;
+}
+
+
+/* ???  */
+
+static boolean
+vms_bfd_relax_section (abfd, section, link_info, again)
+     bfd *abfd;
+     asection *section;
+     struct bfd_link_info *link_info;
+     boolean *again;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_relax_section(%p, %s, %p, <ret>)\n",
+					abfd, section->name, link_info);
+#endif
+  return true;
+}
+
+static boolean
+vms_bfd_gc_sections (abfd, link_info)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_gc_sections(%p, %p)\n", abfd, link_info);
+#endif
+  return true;
+}
+
+
+/* Create a hash table for the linker.  Different backends store
+   different information in this table.  */
+
+static struct bfd_link_hash_table *
+vms_bfd_link_hash_table_create (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_link_hash_table_create(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Add symbols from this object file into the hash table.  */
+
+static boolean
+vms_bfd_link_add_symbols (abfd, link_info)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_link_add_symbols(%p, %p)\n", abfd, link_info);
+#endif
+  return false;
+}
+
+
+/* Do a link based on the link_order structures attached to each
+   section of the BFD.  */
+
+static boolean
+vms_bfd_final_link (abfd, link_info)
+     bfd *abfd;
+     struct bfd_link_info *link_info;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_final_link(%p, %p)\n", abfd, link_info);
+#endif
+  return true;
+}
+
+/* Should this section be split up into smaller pieces during linking.  */
+
+static boolean
+vms_bfd_link_split_section (abfd, section)
+     bfd *abfd;
+     asection *section;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_link_split_section(%p, %s)\n", abfd, section->name);
+#endif
+  return false;
+}
+
+/*-- Part 4.9, dynamic symbols and relocations ------------------------------*/
+
+/* Get the amount of memory required to hold the dynamic symbols.  */
+
+static long
+vms_get_dynamic_symtab_upper_bound (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_dynamic_symtab_upper_bound(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+static boolean
+vms_bfd_print_private_bfd_data (abfd, file)
+    bfd *abfd;
+    void *file;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_bfd_print_private_bfd_data(%p)\n", abfd);
+#endif
+  return 0;
+}
+
+
+/* Read in the dynamic symbols.  */
+
+static long
+vms_canonicalize_dynamic_symtab (abfd, symbols)
+     bfd *abfd;
+     asymbol **symbols;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_canonicalize_dynamic_symtab(%p, <ret>)\n", abfd);
+#endif
+  return 0L;
+}
+
+
+/* Get the amount of memory required to hold the dynamic relocs.  */
+
+static long
+vms_get_dynamic_reloc_upper_bound (abfd)
+     bfd *abfd;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_get_dynamic_reloc_upper_bound(%p)\n", abfd);
+#endif
+  return 0L;
+}
+
+
+/* Read in the dynamic relocs.  */
+
+static long
+vms_canonicalize_dynamic_reloc (abfd, arel, symbols)
+     bfd *abfd;
+     arelent **arel;
+     asymbol **symbols;
+{
+#if VMS_DEBUG
+  vms_debug (1, "vms_canonicalize_dynamic_reloc(%p)\n", abfd);
+#endif
+  return 0L;
+}