2009-02-23 Tristan Gingold <gingold@adacore.com>

	* vms.h: Update copyright year, fix comments, reorder declarations.
	(_bfd_save_vms_section): Remove the prototype.
	(EGPS_S_V_NO_SHIFT): New constant.
	(bfd_vms_set_section_flags): New prototype.
	(EGPS_S_B_ALIGN, EGPS_S_W_FLAGS, EGPS_S_L_ALLOC, EGPS_S_B_NAMLNG): New
	constants.
	(EGSY_S_W_FLAGS): Ditto.
	(EGSY_S_V_QUAD_VAL): Ditto.
	(ESDF_S_L_VALUE, ESDF_S_L_PSINDX, ESDF_S_B_NAMLNG): Ditto.
	(EGST_S_W_FLAGS, EGST_S_Q_LP_1, EGST_S_Q_LP_2, EGST_S_L_PSINDX,
	EGST_S_B_NAMLNG): Ditto.
	(ESRF_S_B_NAMLNG): Ditto.
	(ETIR_S_C_HEADER_SIZE): Ditto.
	(EGPS_S_V_ALLOC_64BIT): Ditto.
	(DST_S_C_EPILOG): Ditto.
	(DST_S_C_SRC_SETLNUM_L, DST_S_C_SRC_SETLNUM_W) : Ditto.
	(DST_S_C_SRC_INCRLNUM_B): Ditto.
	(DST_S_B_PCLINE_UNSBYTE, DST_S_W_PCLINE_UNSWORD): Ditto.
	(DST_S_L_PCLINE_UNSLONG): Ditto.
	(DST_S_B_MODBEG_NAME, DST_S_L_RTNBEG_ADDRESS) : Ditto
	(DST_S_B_RTNBEG_NAME, DST_S_L_RTNEND_SIZE): Ditto
	(DST_S_C_SOURCE_HEADER_SIZE): Ditto.
	(DST_S_B_SRC_DF_LENGTH, DST_S_W_SRC_DF_FILEID): Ditto.
	(DST_S_B_SRC_DF_FILENAME, DST_S_B_SRC_UNSBYTE): Ditto.
	(DST_S_B_SRC_UNSBYTE): Ditto.
	(DST_S_W_SRC_UNSWORD, DST_S_L_SRC_UNSLONG): Ditto.
	Add prototypes.
	(vms_section, vms_reloc): Remove types.
	(hdr_struc): Replaced by ...
	(hdr_struct): ... new type.
	(EMH_S_W_HDRTYP, EMH_S_B_STRLVL, EMH_S_L_ARCH1): New constants.
	(EMH_S_L_ARCH2, EMH_S_L_RECSIZ, EMH_S_B_NAMLNG): Ditto.
	(EMH_DATE_LENGTH): Ditto.
	(eom_struc): Replaced by ...
	(eom_struct): ... new type.
	(EEOM_S_L_TOTAL_LPS, EEOM_S_W_COMCOD, EEOM_S_B_TFRFLG): New constants.
	(EEOM_S_L_PSINDX, EEOM_S_L_TFRADR): Ditto.
	(EIHD_S_K_MAJORID, EIHD_S_K_MINORID, EIHD_S_K_EXE): Ditto.
	(EIHD_S_L_SIZE, EIHD_S_L_ISDOFF, EIHD_S_L_SYMDBGOFF): Ditto.
	(EIHD_S_Q_SYMVVA, EIHD_S_L_IMGTYPE): Ditto.
	(EISD_S_L_EISDSIZE, EISD_S_L_SECSIZE, EISD_S_Q_VIR_ADDR): Ditto.
	(EISD_S_L_FLAGS, EISD_S_L_VBN, EISD_S_R_CONTROL): Ditto.
	(EISD_S_L_IDENT, EISD_S_T_GBLNAM): Ditto.
	(EISD_S_M_GBL, EISD_S_M_CRF, EISD_S_M_DZRO, EISD_S_M_WRT): Ditto.
	(EISD_S_M_INITALCODE, EISD_S_M_BASED, EISD_S_M_FIXUPVEC): Ditto.
	(EISD_S_M_RESIDENT, EISD_S_M_VECTOR, EISD_S_M_PROTECT): Ditto.
	(EISD_S_M_LASTCLU, EISD_S_M_EXE, EISD_S_M_NONSHRADR): Ditto.
	(EISD_S_M_QUAD_LENGTH, EISD_S_M_ALLOC_64BIT): Ditto.
	(EIHS_S_L_DSTVBN, EIHS_S_L_DSTSIZE, EIHS_S_L_GSTVBN): Ditto.
	(EIHS_S_L_GSTSIZE, EIHS_S_L_DMTVBN, EIHS_S_L_DMTBYTES): Ditto.
	(DBG_S_L_DMT_MODBEG, DBG_S_L_DST_SIZE): Ditto.
	(DBG_S_W_DMT_PSECT_COUNT, DBG_S_C_DMT_HEADER_SIZE): Ditto.
	(DBG_S_L_DMT_PSECT_START, DBG_S_L_DMT_PSECT_LENGTH)
	(DBG_S_C_DMT_PSECT_SIZE): Ditto.
	(enum file_type_enum): New type.
	(struct location_struct): Removed.
	(struct fileinfo, struct srecinfo, struct lineinfo): New types.
	(struct funcinfo, struct module): Ditto.
	(struct vms_private_data_struct): Update fields.
	(struct vms_section_data_struct): New type.

	* vms.c: Update copyright year, fix comments,
	Fix includes for DECC, add prototypes.
	(vms_initialize): Use bfd_alloc instead of bfd_zalloc and remove
	some initializers.
	Use flavour to set is_vax, location_stack is removed.
	(struct pair): Declare.
	(fill_section_ptr): Initialize variables at declaration.
	Add guard to set SECTION_SYM flag, handlde und section.
	(vms_fixup_sections): Use struct pair for fill_section_ptr argument.
	(_bfd_vms_slurp_object_records): New function, replaces previous
	vms_object_p.
	(vms_slurp_module): New function.
	(vms_slurp_image): Ditto.
	(vms_object_p): Complete rewrite.
	(vms_mkobject): Use is_vax field to slect architecture.
	(free_reloc_stream): New function.
	(vms_convert_to_var): Ditto.
	(vms_convert_to_var_1): Ditto.
	(vms_convert_to_var_unix_filename): Ditto.
	(vms_close_and_cleanup): Call free_reloc_stream, convert file to
	VAR format on VMS.
	(vms_new_section_hook): Set alignment to 0, allocate private data.
	(vms_get_section_contents): Load content.
	(vms_get_symbol_info): Handle undefined section.
	(vms_find_nearest_line): Handle.
	(alloc_reloc_stream): New function.
	(vms_slurp_reloc_table): Ditto.
	(vms_get_reloc_upper_bound): Make it real.
	(vms_canonicalize_reloc): Do the real work.
	(alpha_howto_table): Add ALPHA_R_NOP, ALPHA_R_BSR, ALPHA_R_LDA,
	ALPHA_R_BOH.
	(vms_bfd_reloc_type_lookup): Handle NOP, BSR, LDA and BOH.
	(vms_set_arch_mach): Check arch.
	(vms_set_section_contents): Copy the content after allocation.
	(vms_alpha_vec): Update object flags.

	* vms-tir.c: Update copyright year, fix comments,
	add prototypes for new functions.
	(dst_define_location): New function.
	(dst_restore_location): New function.
	(dst_retrieve_location): New function.
	(dst_check_allocation): New function.
	(image_dump): Call dst_check_allocation.
	(image_write_b): Ditto.
	(image_write_w): Ditto.
	(image_write_l): Ditto.
	(image_write_q): Ditto.
	(cmd_name): Handle STA_LW, STA_QW, STO_OFF, STO_IMM, STO_IMMR, STO_LW,
	STO_QW, OPR_ADD, CTL_SETRB, STC_LP_PSB, CTL_DFLOC, CTL_STLOC,
	CTL_STKDL.
	Call error handler instead of abort if name is not known.
	(etir_sta): Add quarter_relocs argument and set it.
	Fix cast.
	(etir_sto): Ditto.
	(etir_opr): Ditto, return FALSE in case of error.
	(etir_ctl): Add quarter_relocs argument and set it, fix cast.
	Fix CTL_DFLOC, CTL_STLOC, CTL_STKDL.
	(etir_stc): Add quarter_relocs argument and set it, fix cast.
	Fix STC_LP, STC_LP_PSB, STC_GBL and STC_CGA.
	Handle STC_LP_PSB, STC_BSR_GBL, STC_LDA_GBL, STC_BOH_GBL.
	Move STC_NOP_PS, STC_BSR_PS, STC_LDA_PS, STC_BOH_PS, STC_NBH_PS.
	Return FALSE in case of error.
	(tir_sta): Change sign of psect.
	(tir_ctl): Ditto.
	(tir_cmd): Fix cast. Makes tir_table static const.
	(etir_cmd): Add quarter_relocs argument, makes etir_table const,
	add argument to explain.
	(analyze_etir): Initialize maxptr, add quarter_relocs
	declaration, move some declarations into inner scopes.
	Handle quarter_relocs and STO_IMM.
	(_bfd_vms_slurp_tir): Use constant instead of hard-coded values.
	(_bfd_vms_slurp_relocs): New function.
	(_bfd_vms_decode_relocs): New function.
	(sto_imm): Rewritten.
	(start_first_etbt_record): New function.
	(start_another_etbt_record): Ditto.
	(etir_output_check): Ditto.
	(defer_reloc_p): Ditto.
	(_bfd_vms_write_tir): Remove nextoffset, convert a while-loop to
	a for-loop.  Correctly deals with contents, deals with .vmsdebug,
	rewritte relocations handling.
	(_bfd_vms_write_tbt): Removed.
	(_bfd_vms_write_dbg): Ditto.

	* vms-misc.c: Update copyright year, Fix comments.
	(_bfd_vms_get_header_values): Use 'size' instead of 'length'.
	(maybe_adjust_record_pointer_for_object): New function.
	(_bfd_vms_get_first_record): New function, replaces ...
	(_bfd_vms_get_record): ..  removed.
	(_bfd_vms_get_object_record): New function.
	(_bfd_vms_get_object_record): New function.
	(vms_get_remaining_object_record): New function, replaces ...
	(_bfd_vms_get_next_record): ... removed.
	(add_new_contents): Removed.
	(_bfd_save_vms_section): Removed.
	(_bfd_get_vms_section): Removed.
	(_bfd_vms_output_flush): Write in VAR format.
	(new_symbol): Don't make UND section.

	* vms-hdr.c: Update copyright year, update list of record handled.
	(_bfd_vms_slurp_hdr): rec_length renamed to rec_size.
	(_bfd_vms_write_hdr): Strip vms and unix patches,
	add comments, truncate module name at 31 characters,
	use constants instead of hard-coded value,
	write BFD version instead of a fixed string.
	(_bfd_vms_slurp_ihd): New function.
	(_bfd_vms_slurp_isd): Ditto.
	(_bfd_vms_slurp_ihs): Ditto.
	(new_module): Ditto.
	(parse_module): Ditto
	(build_module_list): Ditto.
	(module_find_nearest_line): Ditto.
	(_bfd_vms_find_nearest_dst_line): Ditto.
	(vms_slurp_debug): Ditto.
	(_bfd_vms_slurp_dbg): Ditto.
	(_bfd_vms_slurp_tbt): Ditto.
	(_bfd_vms_write_dbg): Ditto.
	(_bfd_vms_write_tbt): Ditto.

	* vms-gsd.c: Update copyright year, update list of records handled.
	(EVAX_LITERALS_NAME): New macro.
	(evax_section_flags): Add an entry for EVAX_LITERALS_NAME.
	(gpsflagdesc, gsyflagdesc): Moved out of _bfd_vms_slurp_gsd.
	(register_universal_symbol): New function and prototype.
	(_bfd_vms_slurp_gsd): Fix indentations and casts,
	improve debug messages,
	use constants instead of hard-coded value,
	fix missing endianness conversion,
	handle global symbol (SYMG).
	(bfd_vms_set_section_flags): New function.
	(_bfd_vms_write_gsd): Don't write .vmsdebug section,
	handle section literals,
	fix indentation,
	handle section bfd and vms flags,
	don't output LIB$INITIALIZE symbol,
	fix handling of weak symbols,
	fix evax vs vax procedure descriptor,
	handle absolute symbols.

	* reloc.c (BFD_RELOC_ALPHA_NOP, BFD_RELOC_ALPHA_BSR,
	BFD_RELOC_ALPHA_LDA, BFD_RELOC_ALPHA_BOH): New relocations.

	* makefile.vms (DEFS): Fix flags for VMS.

	* bfdio.c (real_fopen): Handle multiple VMS fopen attributes.

	* bfd-in2.h: Regenerated.
	* libbfd.h: Regenerated.

1 files changed, 1065 insertions, 494 deletions

diff --git a/bfd/vms-tir.c b/bfd/vms-tir.c
index e6ec6eb..5bc61da 100644
--- a/bfd/vms-tir.c
+++ b/bfd/vms-tir.c
@@ -1,12 +1,12 @@
 /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
    EVAX (openVMS/Alpha) files.
-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008
-   Free Software Foundation, Inc.
+   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007,
+   2008, 2009 Free Software Foundation, Inc.
 
    TIR record handling functions
    ETIR record handling functions
 
-   go and read the openVMS linker manual (esp. appendix B)
+   Go and read the openVMS linker manual (esp. appendix B)
    if you don't know what's going on here :-)
 
    Written by Klaus K"ampf (kkaempf@rmi.de)
@@ -26,7 +26,6 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
-
 /* The following type abbreviations are used:
 
 	cs	counted string (ascii string with length byte)
@@ -41,6 +40,33 @@
 #include "bfdlink.h"
 #include "libbfd.h"
 #include "vms.h"
+
+static int check_section (bfd *, int);
+static void image_set_ptr (bfd *abfd, int psect, uquad offset);
+static void image_inc_ptr (bfd *abfd, uquad offset);
+static void dst_define_location (bfd *abfd, uquad loc);
+static void dst_restore_location (bfd *abfd, uquad loc);
+static unsigned int dst_retrieve_location (bfd *abfd, uquad loc);
+static void dst_check_allocation (bfd *abfd, unsigned int size);
+static void image_dump (bfd *abfd, unsigned char *ptr, int size, int offset);
+static void image_write_b (bfd *abfd, unsigned int value);
+static void image_write_w (bfd *abfd, unsigned int value);
+static void image_write_l (bfd *abfd, unsigned long value);
+static void image_write_q (bfd *abfd, uquad value);
+static bfd_boolean etir_sta (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_sto (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_opr (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_ctl (bfd *, int, unsigned char *, int *);
+static bfd_boolean etir_stc (bfd *, int, unsigned char *, int *);
+static asection *new_section (bfd *, int);
+static int alloc_section (bfd *, unsigned int);
+static int etir_cmd (bfd *, int, unsigned char *, int *);
+static int analyze_tir (bfd *, unsigned char *, unsigned int);
+static int analyze_etir (bfd *, unsigned char *, unsigned int);
+static unsigned char *tir_opr (bfd *, unsigned char *);
+static const char *tir_cmd_name (int);
+static const char *cmd_name (int);
+
 
 static int
 check_section (bfd * abfd, int size)
@@ -92,6 +118,77 @@ image_inc_ptr (bfd * abfd, uquad offset)
   PRIV (image_ptr) += offset;
 }
 
+/* Save current DST location counter under specified index.  */
+
+static void
+dst_define_location (bfd *abfd, uquad loc)
+{
+  asection *dst_section = PRIV (dst_section);
+
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_define_location (%d)\n", (int)loc);
+#endif
+
+  /* Grow the ptr offset table if necessary.  */
+  if (loc + 1 > PRIV (dst_ptr_offsets_count))
+    {
+      PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
+					   (loc + 1) * sizeof (unsigned int));
+      PRIV (dst_ptr_offsets_count) = loc + 1;
+    }
+
+  PRIV (dst_ptr_offsets)[loc] = PRIV (image_ptr) - dst_section->contents;
+}
+
+/* Restore saved DST location counter from specified index.  */
+
+static void
+dst_restore_location (bfd *abfd, uquad loc)
+{
+  asection *dst_section = PRIV (dst_section);
+
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_restore_location (%d)\n", (int)loc);
+#endif
+
+  PRIV (image_ptr) = dst_section->contents + PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Retrieve saved DST location counter from specified index.  */
+
+static unsigned int
+dst_retrieve_location (bfd *abfd, uquad loc)
+{
+#if VMS_DEBUG
+  _bfd_vms_debug (4, "dst_retrieve_location (%d)\n", (int)loc);
+#endif
+
+  return PRIV (dst_ptr_offsets)[loc];
+}
+
+/* Check that the DST section is big enough for the specified
+   amount of bytes.  */
+
+static void
+dst_check_allocation (bfd *abfd, unsigned int size)
+{
+  asection *dst_section = PRIV (dst_section);
+
+  bfd_size_type used = PRIV (image_ptr) - dst_section->contents;
+  bfd_size_type left = dst_section->size - used;
+
+  /* Grow the DST section as necessary */
+  if (size > left)
+    {
+      dst_section->size *= 2;
+      dst_section->contents
+	= bfd_realloc (dst_section->contents, dst_section->size);
+      PRIV (image_ptr) = dst_section->contents + used;
+
+      dst_check_allocation (abfd, size);
+    }
+}
+
 /* Dump multiple bytes to section image.  */
 
 static void
@@ -109,6 +206,9 @@ image_dump (bfd * abfd,
   if (PRIV (is_vax) && check_section (abfd, size))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, size);
+
   while (size-- > 0)
     *PRIV (image_ptr)++ = *ptr++;
 }
@@ -125,6 +225,9 @@ image_write_b (bfd * abfd, unsigned int value)
   if (PRIV (is_vax) && check_section (abfd, 1))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 1);
+
   *PRIV (image_ptr)++ = (value & 0xff);
 }
 
@@ -140,6 +243,9 @@ image_write_w (bfd * abfd, unsigned int value)
   if (PRIV (is_vax) && check_section (abfd, 2))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 2);
+
   bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
   PRIV (image_ptr) += 2;
 }
@@ -156,6 +262,9 @@ image_write_l (bfd * abfd, unsigned long value)
   if (PRIV (is_vax) && check_section (abfd, 4))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 4);
+
   bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
   PRIV (image_ptr) += 4;
 }
@@ -172,6 +281,9 @@ image_write_q (bfd * abfd, uquad value)
   if (PRIV (is_vax) && check_section (abfd, 8))
     return;
 
+  if (PRIV (dst_section))
+    dst_check_allocation (abfd, 8);
+
   bfd_putl64 (value, PRIV (image_ptr));
   PRIV (image_ptr) += 8;
 }
@@ -182,6 +294,8 @@ cmd_name (int cmd)
   switch (cmd)
     {
     case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
+    case ETIR_S_C_STA_LW: return "ETIR_S_C_STA_LW";
+    case ETIR_S_C_STA_QW: return "ETIR_S_C_STA_QW";
     case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
     case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
     case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
@@ -192,10 +306,16 @@ cmd_name (int cmd)
     case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
     case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
     case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
+    case ETIR_S_C_STO_OFF: return "ETIR_S_C_STO_OFF";
+    case ETIR_S_C_STO_IMM: return "ETIR_S_C_STO_IMM";
+    case ETIR_S_C_STO_IMMR: return "ETIR_S_C_STO_IMMR";
+    case ETIR_S_C_STO_LW: return "ETIR_S_C_STO_LW";
+    case ETIR_S_C_STO_QW: return "ETIR_S_C_STO_QW";
     case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
     case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
     case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
     case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
+    case ETIR_S_C_OPR_ADD: return "ETIR_S_C_OPR_ADD";
     case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
     case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
     case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
@@ -215,34 +335,41 @@ cmd_name (int cmd)
     case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
     case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
     case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
+    case ETIR_S_C_CTL_SETRB: return "ETIR_S_C_CTL_SETRB";
+    case ETIR_S_C_STC_LP_PSB: return "ETIR_S_C_STC_LP_PSB";
+    case ETIR_S_C_CTL_DFLOC: return "ETIR_S_C_CTL_DFLOC";
+    case ETIR_S_C_CTL_STLOC: return "ETIR_S_C_CTL_STLOC";
+    case ETIR_S_C_CTL_STKDL: return "ETIR_S_C_CTL_STKDL";
 
     default:
       /* These names have not yet been added to this switch statement.  */
-      abort ();
+      (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
     }
+
+  return NULL;
 }
 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
 
 /* etir_sta
 
-   vms stack commands
+   Vms stack commands.
 
-   handle sta_xxx commands in etir section
-   ptr points to data area in record
+   Handle sta_xxx commands in etir section,
+   ptr points to data area in record.
 
-   see table B-8 of the openVMS linker manual.  */
+   See table B-8 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
+etir_sta (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
     {
-      /* stack global
+      /* Stack global
 	 arg: cs	symbol name
 
 	 stack 32 bit value of symbol (high bits set to 0).  */
@@ -265,37 +392,50 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
 	else
 	  _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
       }
+      *quarter_relocs = 1;
       break;
 
-      /* stack longword
+      /* Stack longword
 	 arg: lw	value
 
 	 stack 32 bit value, sign extend to 64 bit.  */
     case ETIR_S_C_STA_LW:
       _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
+      /* This one is special as it is both part of the section header
+         and of the ALPHA_R_REFLONG relocation.  */
+      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_DFLOC)
+	*quarter_relocs = 0;
+      else if (*quarter_relocs)
+	*quarter_relocs += 1;
+      else
+	*quarter_relocs = 2;
       break;
 
-      /* stack global
+      /* Stack quadword
 	 arg: qw	value
 
 	 stack 64 bit value of symbol.  */
     case ETIR_S_C_STA_QW:
       _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
+      if (*quarter_relocs)
+	*quarter_relocs += 1;
+      else
+	*quarter_relocs = 2;
       break;
 
-      /* stack psect base plus quadword offset
+      /* Stack psect base plus quadword offset
 	 arg: lw	section index
 	 qw	signed quadword offset (low 32 bits)
 
-	 stack qw argument and section index
+	 Stack qw argument and section index
 	 (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB).  */
     case ETIR_S_C_STA_PQ:
       {
 	uquad dummy;
-	unsigned int psect;
+	int psect;
 
 	psect = bfd_getl32 (ptr);
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  {
 	    (*_bfd_error_handler) (_("bad section index in %s"),
 				   cmd_name (cmd));
@@ -305,23 +445,31 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
 	dummy = bfd_getl64 (ptr + 4);
 	_bfd_vms_push (abfd, dummy, (int) psect);
       }
+      /* This one is special as it is both part of the section header
+         and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
+      if (bfd_getl16 (ptr - 4 + bfd_getl16 (ptr - 2)) == ETIR_S_C_CTL_SETRB)
+	*quarter_relocs = 0;
+      else
+	*quarter_relocs = 2;
       break;
 
     case ETIR_S_C_STA_LI:
     case ETIR_S_C_STA_MOD:
     case ETIR_S_C_STA_CKARG:
       (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
+      *quarter_relocs = 0;
       return FALSE;
-      break;
 
     default:
       (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
+      *quarter_relocs = 0;
       return FALSE;
-      break;
     }
+
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sta true\n");
 #endif
+
   return TRUE;
 }
 
@@ -335,14 +483,14 @@ etir_sta (bfd * abfd, int cmd, unsigned char *ptr)
    see table B-9 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
+etir_sto (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
   uquad dummy;
   int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
@@ -353,6 +501,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy = _bfd_vms_pop (abfd, &psect);
       /* FIXME: check top bits.  */
       image_write_b (abfd, (unsigned int) dummy & 0xff);
+      *quarter_relocs = 0;
       break;
 
       /* Store word: pop stack, write word
@@ -361,6 +510,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy = _bfd_vms_pop (abfd, &psect);
       /* FIXME: check top bits */
       image_write_w (abfd, (unsigned int) dummy & 0xffff);
+      *quarter_relocs = 0;
       break;
 
       /* Store longword: pop stack, write longword
@@ -370,6 +520,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy += (PRIV (sections)[psect])->vma;
       /* FIXME: check top bits.  */
       image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
+      if (*quarter_relocs == 2)
+	*quarter_relocs = 4;
+      else
+	*quarter_relocs += 1;
       break;
 
       /* Store quadword: pop stack, write quadword
@@ -379,6 +533,10 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
       dummy += (PRIV (sections)[psect])->vma;
       /* FIXME: check top bits.  */
       image_write_q (abfd, dummy);
+      if (*quarter_relocs == 2)
+	*quarter_relocs = 4;
+      else
+	*quarter_relocs += 1;
       break;
 
       /* Store immediate repeated: pop stack for repeat count
@@ -393,6 +551,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	while (dummy-- > 0)
 	  image_dump (abfd, ptr+4, size, 0);
       }
+      *quarter_relocs = 0;
       break;
 
       /* Store global: write symbol value
@@ -406,15 +565,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 						      name, FALSE, FALSE);
 	if (entry == NULL)
-	  {
-	    (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
-				   cmd_name (cmd), name);
-	    return FALSE;
-	  }
+	  /* FIXME, reloc.  */
+	  image_write_q (abfd, (uquad) (0));
 	else
 	  /* FIXME, reloc.  */
 	  image_write_q (abfd, (uquad) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
       /* Store code address: write address of entry point
@@ -428,15 +585,13 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
 						      name, FALSE, FALSE);
 	if (entry == NULL)
-	  {
-	    (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
-				   cmd_name (cmd), name);
-	    return FALSE;
-	  }
+	  /* FIXME, reloc.  */
+	  image_write_q (abfd, (uquad) (0));
 	else
 	  /* FIXME, reloc.  */
 	  image_write_q (abfd, (uquad) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
       /* Store offset to psect: pop stack, add low 32 bits to base of psect
@@ -450,6 +605,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	q += (PRIV (sections)[psect1])->vma;
 	image_write_q (abfd, q);
       }
+      *quarter_relocs += 2;
       break;
 
       /* Store immediate
@@ -462,6 +618,7 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	size = bfd_getl32 (ptr);
 	image_dump (abfd, ptr+4, size, 0);
       }
+      *quarter_relocs = 0;
       break;
 
       /* This code is 'reserved to digital' according to the openVMS
@@ -489,22 +646,26 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
 	  /* FIXME, reloc.  */
 	  image_write_l (abfd, (unsigned long) (entry->symbol->value));
       }
+      *quarter_relocs = 4;
       break;
 
     case ETIR_S_C_STO_RB:
     case ETIR_S_C_STO_AB:
     case ETIR_S_C_STO_LP_PSB:
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
 
     case ETIR_S_C_STO_HINT_GBL:
     case ETIR_S_C_STO_HINT_PS:
       (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
 
     default:
       (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
-      break;
+      *quarter_relocs = 0;
+      return FALSE;
     }
 
   return TRUE;
@@ -518,15 +679,22 @@ etir_sto (bfd * abfd, int cmd, unsigned char *ptr)
    see table B-10 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
+etir_opr (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
+	  int *quarter_relocs)
 {
   long op1, op2;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
+  /* No relocation uses OPR commands except ETIR_S_C_OPR_ADD.  */
+  if (cmd == ETIR_S_C_OPR_ADD)
+    *quarter_relocs += 1;
+  else
+    *quarter_relocs = 0;
+
   switch (cmd)
     {
     case ETIR_S_C_OPR_NOP:      /* No-op.  */
@@ -604,7 +772,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
     case ETIR_S_C_OPR_REDEF:     /* Redefine symbol to current location.  */
     case ETIR_S_C_OPR_DFLIT:     /* Define a literal.  */
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
+      return FALSE;
 
     case ETIR_S_C_OPR_SEL:      /* Select.  */
       if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
@@ -619,7 +787,7 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
 
     default:
       (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
-      break;
+      return FALSE;
     }
 
   return TRUE;
@@ -630,16 +798,19 @@ etir_opr (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
    See table B-11 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
+etir_ctl (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
-  uquad	 dummy;
+  uquad dummy;
   int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
+  /* No relocation uses CTL commands.  */
+  *quarter_relocs = 0;
+
   switch (cmd)
     {
       /* Det relocation base: pop stack, set image location counter
@@ -660,27 +831,28 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
 	 arg: none.  */
     case ETIR_S_C_CTL_DFLOC:
       dummy = _bfd_vms_pop (abfd, NULL);
-      /* FIXME */
+      dst_define_location (abfd, dummy);
       break;
 
       /* Set location: pop index, restore location counter from index
 	 arg: none.  */
     case ETIR_S_C_CTL_STLOC:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME */
+      dummy = _bfd_vms_pop (abfd, NULL);
+      dst_restore_location (abfd, dummy);
       break;
 
       /* Stack defined location: pop index, push location counter from index
 	 arg: none.  */
     case ETIR_S_C_CTL_STKDL:
-      dummy = _bfd_vms_pop (abfd, &psect);
-      /* FIXME.  */
+      dummy = _bfd_vms_pop (abfd, NULL);
+      _bfd_vms_push (abfd, dst_retrieve_location (abfd, dummy), -1);
       break;
 
     default:
       (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
-      break;
+      return FALSE;
     }
+
   return TRUE;
 }
 
@@ -689,11 +861,12 @@ etir_ctl (bfd * abfd, int cmd, unsigned char *ptr)
    See table B-12 and B-13 of the openVMS linker manual.  */
 
 static bfd_boolean
-etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
+etir_stc (bfd *abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED,
+	  int *quarter_relocs)
 {
 #if VMS_DEBUG
   _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   switch (cmd)
@@ -701,32 +874,17 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
       /* 200 Store-conditional Linkage Pair
 	 arg: none.  */
     case ETIR_S_C_STC_LP:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
-
-      /* 201 Store-conditional Linkage Pair with Procedure Signature
-	 arg:	lw	linkage index
-		cs	procedure name
-		by	signature length
-		da	signature.  */
-    case ETIR_S_C_STC_LP_PSB:
-      image_inc_ptr (abfd, (uquad) 16);	/* skip entry,procval */
-      break;
 
       /* 202 Store-conditional Address at global address
 	 arg:	lw	linkage index
 		cs	global name.  */
 
     case ETIR_S_C_STC_GBL:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
 
       /* 203 Store-conditional Code Address at global address
 	 arg:	lw	linkage index
 		cs	procedure name.  */
     case ETIR_S_C_STC_GCA:
-      (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
-      break;
 
       /* 204 Store-conditional Address at psect + offset
 	 arg:	lw	linkage index
@@ -734,56 +892,82 @@ etir_stc (bfd * abfd, int cmd, unsigned char *ptr ATTRIBUTE_UNUSED)
 		qw	offset.  */
     case ETIR_S_C_STC_PS:
       (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
+      *quarter_relocs = 0;
+      return FALSE;
+
+      /* 201 Store-conditional Linkage Pair with Procedure Signature
+	 arg:	lw	linkage index
+		cs	procedure name
+		by	signature length
+		da	signature.  */
+
+    case ETIR_S_C_STC_LP_PSB:
+      image_inc_ptr (abfd, (uquad) 16);	/* skip entry,procval */
+      *quarter_relocs = 4;
       break;
 
       /* 205 Store-conditional NOP at address of global
 	 arg: none.  */
     case ETIR_S_C_STC_NOP_GBL:
-
-      /* 206 Store-conditional NOP at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_NOP_PS:
+      /* ALPHA_R_NOP */
 
       /* 207 Store-conditional BSR at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_BSR_GBL:
 
-      /* 208 Store-conditional BSR at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_BSR_PS:
+    case ETIR_S_C_STC_BSR_GBL:
+      /* ALPHA_R_BSR */
 
       /* 209 Store-conditional LDA at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_LDA_GBL:
 
-      /* 210 Store-conditional LDA at psect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_LDA_PS:
+    case ETIR_S_C_STC_LDA_GBL:
+      /* ALPHA_R_LDA */
 
       /* 211 Store-conditional BSR or Hint at global address
 	 arg: none.  */
-    case ETIR_S_C_STC_BOH_GBL:
 
-      /* 212 Store-conditional BSR or Hint at pect + offset
-	 arg: none.  */
-    case ETIR_S_C_STC_BOH_PS:
+    case ETIR_S_C_STC_BOH_GBL:
+      *quarter_relocs = 4;
+      break;
 
       /* 213 Store-conditional NOP,BSR or HINT at global address
 	 arg: none.  */
+
     case ETIR_S_C_STC_NBH_GBL:
 
-      /* 214 Store-conditional NOP,BSR or HINT at psect + offset
+      /* 206 Store-conditional NOP at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_NOP_PS:
+
+      /* 208 Store-conditional BSR at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_BSR_PS:
+
+      /* 210 Store-conditional LDA at psect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_LDA_PS:
+
+      /* 212 Store-conditional BSR or Hint at pect + offset
+	 arg: none.  */
+
+    case ETIR_S_C_STC_BOH_PS:
+
+      /* 214 Store-conditional NOP, BSR or HINT at psect + offset
 	 arg: none.  */
     case ETIR_S_C_STC_NBH_PS:
-      /* FIXME */
-      break;
+      (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd));
+      *quarter_relocs = 0;
+      return FALSE;
 
     default:
-#if VMS_DEBUG
-      _bfd_vms_debug (3,  "reserved STC cmd %d", cmd);
-#endif
-      break;
+      (*_bfd_error_handler) (_("reserved STC cmd %d"), cmd);
+      *quarter_relocs = 0;
+      return FALSE;
     }
+
   return TRUE;
 }
 
@@ -851,10 +1035,10 @@ alloc_section (bfd * abfd, unsigned int idx)
 
 /* tir_sta
 
-   vax stack commands
+   Vax stack commands.
 
-   Handle sta_xxx commands in tir section
-   ptr points to data area in record
+   Handle sta_xxx commands in tir section,
+   ptr points to data area in record.
 
    See table 7-3 of the VAX/VMS linker manual.  */
 
@@ -924,7 +1108,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		by	signed byte offset.  */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PB)
 	  psect = *ptr++;
@@ -934,12 +1118,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = (long) *ptr++;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -951,7 +1135,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		sh	signed short offset.  */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PW)
 	  psect = *ptr++;
@@ -961,12 +1145,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = bfd_getl16 (ptr); ptr+=2;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -978,7 +1162,7 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 		lw	signed longword offset.	 */
       {
 	unsigned long dummy;
-	unsigned int psect;
+	int psect;
 
 	if (cmd == TIR_S_C_STA_PL)
 	  psect = *ptr++;
@@ -988,12 +1172,12 @@ tir_sta (bfd * abfd, unsigned char *ptr)
 	    ptr += 2;
 	  }
 
-	if (psect >= PRIV (section_count))
+	if ((unsigned int) psect >= PRIV (section_count))
 	  alloc_section (abfd, psect);
 
 	dummy = bfd_getl32 (ptr); ptr += 4;
 	dummy += (PRIV (sections)[psect])->vma;
-	_bfd_vms_push (abfd, (uquad) dummy, (int) psect);
+	_bfd_vms_push (abfd, (uquad) dummy, psect);
       }
       break;
 
@@ -1457,7 +1641,7 @@ static unsigned char *
 tir_ctl (bfd * abfd, unsigned char *ptr)
 {
   unsigned long dummy;
-  unsigned int psect;
+  int psect;
 
 #if VMS_DEBUG
   _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
@@ -1468,10 +1652,10 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_SETRB:
       /* Set relocation base: pop stack, set image location counter
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
-      if (psect >= PRIV (section_count))
+      dummy = _bfd_vms_pop (abfd, &psect);
+      if ((unsigned int) psect >= PRIV (section_count))
 	alloc_section (abfd, psect);
-      image_set_ptr (abfd, (int) psect, (uquad) dummy);
+      image_set_ptr (abfd, psect, (uquad) dummy);
       break;
 
     case TIR_S_C_CTL_AUGRB:
@@ -1492,7 +1676,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_STLOC:
       /* Set location: pop index, restore location counter from index
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
+      dummy = _bfd_vms_pop (abfd, &psect);
       (*_bfd_error_handler) (_("%s: not fully implemented"),
 			     tir_cmd_name (ptr[-1]));
       break;
@@ -1500,7 +1684,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
     case TIR_S_C_CTL_STKDL:
       /* Stack defined location: pop index, push location counter from index
 	 arg: none.  */
-      dummy = _bfd_vms_pop (abfd, (int *) &psect);
+      dummy = _bfd_vms_pop (abfd, &psect);
       (*_bfd_error_handler) (_("%s: not fully implemented"),
 			     tir_cmd_name (ptr[-1]));
       break;
@@ -1517,7 +1701,7 @@ tir_ctl (bfd * abfd, unsigned char *ptr)
 static unsigned char *
 tir_cmd (bfd * abfd, unsigned char *ptr)
 {
-  struct
+  static const struct
   {
     int mincod;
     int maxcod;
@@ -1535,7 +1719,7 @@ tir_cmd (bfd * abfd, unsigned char *ptr)
 
 #if VMS_DEBUG
   _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   if (*ptr & 0x80)
@@ -1570,13 +1754,13 @@ tir_cmd (bfd * abfd, unsigned char *ptr)
 /* Handle command from ETIR section.  */
 
 static int
-etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
+etir_cmd (bfd *abfd, int cmd, unsigned char *ptr, int *quarter_relocs)
 {
-  static struct
+  static const struct
   {
     int mincod;
     int maxcod;
-    bfd_boolean (*explain) (bfd *, int, unsigned char *);
+    bfd_boolean (*explain) (bfd *, int, unsigned char *, int *);
   }
   etir_table[] =
   {
@@ -1591,8 +1775,8 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
   int i = 0;
 
 #if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
-  _bfd_hexdump (8, ptr, 16, (int) ptr);
+  _bfd_vms_debug (4, "etir_cmd: %s(%d)\n", cmd_name (cmd), cmd);
+  _bfd_hexdump (8, ptr, 16, (long) ptr);
 #endif
 
   while (etir_table[i].mincod >= 0)
@@ -1600,7 +1784,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
       if ( (etir_table[i].mincod <= cmd)
 	   && (cmd <= etir_table[i].maxcod))
 	{
-	  if (!etir_table[i].explain (abfd, cmd, ptr))
+	  if (!etir_table[i].explain (abfd, cmd, ptr, quarter_relocs))
 	    return -1;
 	  break;
 	}
@@ -1608,7 +1792,7 @@ etir_cmd (bfd * abfd, int cmd, unsigned char *ptr)
     }
 
 #if VMS_DEBUG
-  _bfd_vms_debug (4, "etir_cmd: = 0\n");
+  _bfd_vms_debug (4, "etir_cmd: result = 0\n");
 #endif
   return 0;
 }
@@ -1643,28 +1827,67 @@ analyze_tir (bfd * abfd, unsigned char *ptr, unsigned int length)
 static int
 analyze_etir (bfd * abfd, unsigned char *ptr, unsigned int length)
 {
-  int cmd;
-  unsigned char *maxptr;
+  unsigned char *maxptr = ptr + length;
+  /* Relocations are made of 1, 2 or 4 ETIR commands.
+     We therefore count them using quarters.  */
+  int quarter_relocs = 0;
   int result = 0;
 
 #if VMS_DEBUG
   _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
 #endif
 
-  maxptr = ptr + length;
-
   while (ptr < maxptr)
     {
-      cmd = bfd_getl16 (ptr);
-      length = bfd_getl16 (ptr + 2);
-      result = etir_cmd (abfd, cmd, ptr+4);
+      int cmd = bfd_getl16 (ptr);
+      int cmd_length = bfd_getl16 (ptr + 2);
+      result = etir_cmd (abfd, cmd, ptr + 4, &quarter_relocs);
       if (result != 0)
 	break;
-      ptr += length;
+
+      /* If we have a relocation, we record its length to size
+	 future buffers and bump the reloc count of the section.  */
+      if (quarter_relocs)
+	{
+	  vms_section_data (PRIV (image_section))->reloc_size += cmd_length;
+	  abfd->flags |= HAS_RELOC;
+
+	  if (quarter_relocs == 4)
+	    {
+	      PRIV (image_section)->reloc_count++;
+
+#if VMS_DEBUG
+	      _bfd_vms_debug (4, "-> reloc %d at 0x%x\n",
+			      PRIV (image_section)->reloc_count-1,
+			      ptr - (maxptr - length));
+#endif
+
+	      quarter_relocs = 0;
+	    }
+	  else if (quarter_relocs > 4)
+	    {
+
+#if VMS_DEBUG
+	      _bfd_vms_debug (4, "Reloc count error (%d) in section %s\n",
+			      PRIV (image_section)->reloc_count,
+			      PRIV (image_section)->name);
+#endif
+
+	      quarter_relocs = 0;
+	    }
+	}
+
+      /* If we have a Store Immediate, we reserve space for the
+	 count argument.  */
+      else if (cmd == ETIR_S_C_STO_IMM)
+        vms_section_data (PRIV (image_section))->reloc_size
+	  += ETIR_S_C_HEADER_SIZE + 4;
+
+      ptr += cmd_length;
     }
 
 #if VMS_DEBUG
-  _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
+  _bfd_vms_debug (3, "analyze_etir: result = %d\n", result);
 #endif
 
   return result;
@@ -1685,8 +1908,8 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype)
   switch (objtype)
     {
     case EOBJ_S_C_ETIR:
-      PRIV (vms_rec) += 4;	/* Skip type, size.  */
-      PRIV (rec_size) -= 4;
+      PRIV (vms_rec) += ETIR_S_C_HEADER_SIZE;
+      PRIV (rec_size) -= ETIR_S_C_HEADER_SIZE;
       result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
       break;
     case OBJ_S_C_TIR:
@@ -1702,33 +1925,361 @@ _bfd_vms_slurp_tir (bfd * abfd, int objtype)
   return result;
 }
 
-/* Process EDBG record
-   Return 0 on success, -1 on error
-
-   Not implemented yet.  */
+ /* Slurp relocs from ETIR sections and (temporarily) save them
+    in the per-section reloc buffer.  */
 
 int
-_bfd_vms_slurp_dbg (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
+_bfd_vms_slurp_relocs (bfd *abfd)
 {
+  struct vms_section_data_struct *vsd;
+  unsigned char *begin = PRIV (vms_rec) + 4;
+  unsigned char *end = PRIV (vms_rec) + PRIV (rec_size);
+  unsigned char *ptr;
+  int cmd, length, slurped_length;
+
 #if VMS_DEBUG
-  _bfd_vms_debug (2, "DBG/EDBG\n");
+  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: %d bytes\n", PRIV (rec_size));
+#endif
+
+  for (ptr = begin; ptr < end; ptr += length)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+      slurped_length = length;
+
+      switch (cmd)
+	{
+	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
+	  /* This one is special as it is both part of the section header
+	     and of the ALPHA_R_REFLONG and ALPHA_R_REFQUAD relocations.  */
+	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_SETRB)
+	    {
+	      int psect = bfd_getl32 (ptr + ETIR_S_C_HEADER_SIZE);
+	      PRIV (image_section) = PRIV (sections)[psect];
+	      continue;
+	    }
+
+	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
+			       /* ALPHA_R_REFQUAD und_section, step 1 */
+	  break;
+
+	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG und_section, step 2 */
+			      /* ALPHA_R_REFLONG abs_section, step 1 */
+	  /* This one is special as it is both part of the section header
+	     and of the ALPHA_R_REFLONG relocation.  */
+	  if (bfd_getl16 (ptr + length) == ETIR_S_C_CTL_DFLOC)
+	    {
+	      PRIV (image_section) = PRIV (dst_section);
+	      continue;
+	    }
+
+	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD und_section, step 2 */
+			      /* ALPHA_R_REFQUAD abs_section, step 1 */
+
+	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
+			      /* ALPHA_R_REFLONG abs_section, step 2 */
+			      /* ALPHA_R_REFLONG others, step 2 */
+
+	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
+			      /* ALPHA_R_REFQUAD abs_section, step 2 */
+
+	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
+
+	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
+			       /* ALPHA_R_REFQUAD und_section, step 3 */
+
+	case ETIR_S_C_STO_CA:      /* ALPHA_R_CODEADDR */
+	case ETIR_S_C_STO_GBL:     /* ALPHA_R_REFQUAD und_section */
+	case ETIR_S_C_STO_GBL_LW:  /* ALPHA_R_REFLONG und_section */
+	case ETIR_S_C_STC_LP_PSB:  /* ALPHA_R_LINKAGE */
+	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
+	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
+	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
+	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
+	  break;
+
+	case ETIR_S_C_STO_IMM:
+	  if (PRIV (image_section)->reloc_count == 0)
+	    continue;
+	  /* This is not a relocation, but we nevertheless slurp the
+	     count argument.  We'll use it to compute the addresses
+	     of the relocations.  */
+	  slurped_length = ETIR_S_C_HEADER_SIZE + 4;
+	  break;
+
+	default:
+	  continue;
+	}
+
+      vsd = vms_section_data (PRIV (image_section));
+      memcpy (vsd->reloc_stream + vsd->reloc_offset, ptr, slurped_length);
+      vsd->reloc_offset += slurped_length;
+      if (vsd->reloc_offset > vsd->reloc_size)
+        {
+	  (*_bfd_error_handler) (_("Reloc size error in section %s"),
+			         PRIV (image_section)->name);
+	  return -1;
+	}
+    }
+
+#if VMS_DEBUG
+  _bfd_vms_debug (3, "_bfd_vms_slurp_relocs: result = 0\n");
 #endif
 
-  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
   return 0;
 }
 
-/* Process ETBT record
-   Return 0 on success, -1 on error
-
-   Not implemented yet.  */
+/* Decode relocs from the reloc buffer of the specified section
+   and internalize them in the specified buffer.  */
 
 int
-_bfd_vms_slurp_tbt (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
+_bfd_vms_decode_relocs (bfd *abfd, arelent *relocs, asection *section,
+			asymbol **symbols ATTRIBUTE_UNUSED)
 {
+  int saved_cmd, saved_sym_offset, saved_sec_offset, saved_addend_offset;
+  int cmd, sym_offset, sec_offset, address_offset, addend_offset;
+  struct vms_section_data_struct *vsd = vms_section_data (section);
+  bfd_reloc_code_real_type reloc_code;
+  vms_symbol_entry *entry;
+  bfd_vma vaddr = 0;
+  unsigned char *begin = vsd->reloc_stream;
+  unsigned char *end = vsd->reloc_stream + vsd->reloc_size;
+  unsigned char *ptr, *arg_ptr;
+  const char *name;
+  int length;
+
 #if VMS_DEBUG
-  _bfd_vms_debug (2, "TBT/ETBT\n");
+  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: %d bytes\n", vsd->reloc_size);
+#endif
+
+  #define PUSH_CMD()					\
+    {							\
+      saved_cmd = cmd;					\
+      saved_sym_offset = sym_offset - length;		\
+      saved_sec_offset = sec_offset - length;		\
+      saved_addend_offset = addend_offset - length;	\
+      continue;						\
+    }
+
+  #define POP_CMD()					\
+    {							\
+      cmd = saved_cmd;					\
+      saved_cmd = ETIR_S_C_MAXSTCCOD + 1;		\
+      sym_offset = saved_sym_offset;			\
+      sec_offset = saved_sec_offset;			\
+      addend_offset= saved_addend_offset;		\
+    }
+
+  #define CMD_PUSHED (saved_cmd != ETIR_S_C_MAXSTCCOD + 1)
+
+  #define NO_OFFSET -128
+
+  saved_cmd = ETIR_S_C_MAXSTCCOD + 1;
+  saved_sym_offset = NO_OFFSET;
+  saved_sec_offset = NO_OFFSET;
+  saved_addend_offset = NO_OFFSET;
+
+  for (ptr = begin; ptr < end; ptr += length)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+
+      arg_ptr = ptr + ETIR_S_C_HEADER_SIZE;
+      sym_offset = NO_OFFSET;
+      sec_offset = NO_OFFSET;
+      address_offset = NO_OFFSET;
+      addend_offset = NO_OFFSET;
+
+      switch (cmd)
+	{
+	case ETIR_S_C_STA_GBL: /* ALPHA_R_REFLONG und_section, step 1 */
+			       /* ALPHA_R_REFQUAD und_section, step 1 */
+	  sym_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_PQ: /* ALPHA_R_REF{LONG|QUAD}, others part 1 */
+	  sec_offset = 0;
+	  addend_offset = 4;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_LW: /* ALPHA_R_REFLONG abs_section, step 1 */
+			      /* ALPHA_R_REFLONG und_section, step 2 */
+	  if (CMD_PUSHED)
+	    {
+	      POP_CMD ()
+	      if (cmd != ETIR_S_C_STA_GBL)
+		{
+		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+					 cmd_name (cmd),
+					 cmd_name (ETIR_S_C_STA_LW));
+		  return 0;
+		}
+	      cmd = ETIR_S_C_STA_LW;
+	    }
+	  addend_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STA_QW: /* ALPHA_R_REFQUAD abs_section, step 1 */
+			      /* ALPHA_R_REFQUAD und_section, step 2 */
+	  if (CMD_PUSHED)
+	    {
+	      POP_CMD ()
+	      if (cmd != ETIR_S_C_STA_GBL)
+		{
+		  (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+					 cmd_name (cmd),
+					 cmd_name (ETIR_S_C_STA_QW));
+		  return 0;
+		}
+	      cmd = ETIR_S_C_STA_QW;
+	    }
+	  addend_offset = 0;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STO_LW: /* ALPHA_R_REFLONG und_section, step 4 */
+			      /* ALPHA_R_REFLONG abs_section, step 2 */
+			      /* ALPHA_R_REFLONG others, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_OPR_ADD
+	      && cmd != ETIR_S_C_STA_LW
+	      && cmd != ETIR_S_C_STA_PQ)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_LW));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_32;
+	  break;
+
+	case ETIR_S_C_STO_QW: /* ALPHA_R_REFQUAD und_section, step 4 */
+			      /* ALPHA_R_REFQUAD abs_section, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_OPR_ADD && cmd != ETIR_S_C_STA_QW)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_QW));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_64;
+	  break;
+
+	case ETIR_S_C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_STA_PQ)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_STO_OFF));
+	      return 0;
+	    }
+	  reloc_code = BFD_RELOC_64;
+	  break;
+
+	case ETIR_S_C_OPR_ADD: /* ALPHA_R_REFLONG und_section, step 3 */
+			       /* ALPHA_R_REFQUAD und_section, step 3 */
+	  POP_CMD ()
+	  if (cmd != ETIR_S_C_STA_LW && cmd != ETIR_S_C_STA_QW)
+	    {
+	      (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
+	        cmd_name (cmd), cmd_name (ETIR_S_C_OPR_ADD));
+	      return 0;
+	    }
+	  cmd = ETIR_S_C_OPR_ADD;
+	  PUSH_CMD ()
+
+	case ETIR_S_C_STO_CA: /* ALPHA_R_CODEADDR */
+	  reloc_code = BFD_RELOC_ALPHA_CODEADDR;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STO_GBL: /* ALPHA_R_REFQUAD und_section */
+	  reloc_code = BFD_RELOC_64;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STO_GBL_LW: /* ALPHA_R_REFLONG und_section */
+	  reloc_code = BFD_RELOC_32;
+	  sym_offset = 0;
+	  break;
+
+	case ETIR_S_C_STC_LP_PSB: /* ALPHA_R_LINKAGE */
+	  reloc_code = BFD_RELOC_ALPHA_LINKAGE;
+	  sym_offset = 4;
+	  break;
+
+	case ETIR_S_C_STC_NOP_GBL: /* ALPHA_R_NOP */
+	  reloc_code = BFD_RELOC_ALPHA_NOP;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_BSR_GBL: /* ALPHA_R_BSR */
+	  reloc_code = BFD_RELOC_ALPHA_BSR;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_LDA_GBL: /* ALPHA_R_LDA */
+	  reloc_code = BFD_RELOC_ALPHA_LDA;
+	  goto call_reloc;
+
+	case ETIR_S_C_STC_BOH_GBL: /* ALPHA_R_BOH */
+	  reloc_code = BFD_RELOC_ALPHA_BOH;
+	  goto call_reloc;
+
+	call_reloc:
+	  sym_offset = 32;
+	  address_offset = 8;
+	  addend_offset = 24;
+	  break;
+
+	case ETIR_S_C_STO_IMM:
+	  vaddr += bfd_getl32 (arg_ptr);
+	  length = ETIR_S_C_HEADER_SIZE + 4;
+	  continue;
+
+	default:
+	  continue;
+	}
+
+      relocs->howto = bfd_reloc_type_lookup (abfd, reloc_code);
+
+      if (sym_offset > NO_OFFSET)
+	{
+	  name = _bfd_vms_save_counted_string (arg_ptr + sym_offset);
+	  entry = (vms_symbol_entry *)
+	    bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
+	  if (entry == NULL)
+	    {
+	      (*_bfd_error_handler) (_("Unknown symbol %s in command %s"),
+				     name, cmd_name (cmd));
+	      relocs->sym_ptr_ptr = NULL;
+	    }
+	  else
+	    /* ??? This is a hack.  We should point in 'symbols'.  */
+	    relocs->sym_ptr_ptr = &entry->symbol;
+	}
+      else if (sec_offset > NO_OFFSET)
+	relocs->sym_ptr_ptr
+	  = PRIV (sections)[bfd_getl32 (arg_ptr + sec_offset)]->symbol_ptr_ptr;
+      else
+	relocs->sym_ptr_ptr = NULL;
+
+      if (address_offset > NO_OFFSET)
+	relocs->address = bfd_getl64 (arg_ptr + address_offset);
+      else
+	relocs->address = vaddr;
+
+      if (addend_offset > NO_OFFSET)
+	relocs->addend = bfd_getl64 (arg_ptr + addend_offset);
+      else
+	relocs->addend = 0;
+
+      vaddr += bfd_get_reloc_size (relocs->howto);
+      relocs++;     
+    }
+
+  #undef PUSH_CMD
+  #undef POP_CMD
+  #undef NO_OFFSET
+
+#if VMS_DEBUG
+  _bfd_vms_debug (3, "_bfd_vms_decode_relocs: result = 0\n");
 #endif
 
   return 0;
@@ -1750,6 +2301,20 @@ _bfd_vms_slurp_lnk (bfd * abfd ATTRIBUTE_UNUSED,
   return 0;
 }
 
+/* WRITE ETIR SECTION
+
+   This is still under construction and therefore not documented.  */
+
+static void start_etir_record (bfd *abfd, int index, uquad offset,
+			       bfd_boolean justoffset);
+static void start_first_etbt_record (bfd *abfd);
+static void start_another_etbt_record (bfd *abfd);
+static void sto_imm (bfd *abfd, bfd_size_type, unsigned char *, bfd_vma vaddr,
+		     int index, const char *name);
+static void end_etir_record (bfd *abfd);
+static void etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr,
+			       int checklen);
+
 /* Start ETIR record for section #index at virtual addr offset.  */
 
 static void
@@ -1780,25 +2345,20 @@ end_etir_record (bfd * abfd)
   _bfd_vms_output_end (abfd);
 }
 
-/* WRITE ETIR SECTION
-
-   This is still under construction and therefore not documented.  */
+/* Output a STO_IMM command for SSIZE bytes of data from CPR at virtual
+   address VADDR in section specified by INDEX and NAME.  */
 
 static void
-sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
+sto_imm (bfd *abfd, bfd_size_type ssize, unsigned char *cptr, bfd_vma vaddr,
+	 int index, const char *name)
 {
-  int size;
-  int ssize;
-  unsigned char *cptr;
+  bfd_size_type size;
 
 #if VMS_DEBUG
-  _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
-  _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr);
+  _bfd_vms_debug (8, "sto_imm %d bytes\n", ssize);
+  _bfd_hexdump (9, cptr, (int) ssize, (int) vaddr);
 #endif
 
-  ssize = sptr->size;
-  cptr = sptr->contents;
-
   while (ssize > 0)
     {
       /* Try all the rest.  */
@@ -1808,11 +2368,14 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
 	{
 	  /* Doesn't fit, split !  */
 	  end_etir_record (abfd);
-	  start_etir_record (abfd, index, vaddr, FALSE);
-	  /* Get max size.  */
-	  size = _bfd_vms_output_check (abfd, 0);
-	  /* More than what's left ?  */
-	  if (size > ssize)
+
+	  if (name [0] && name[1] == 'v' && !strcmp (name, ".vmsdebug"))
+	    start_another_etbt_record (abfd);
+	  else
+	    start_etir_record (abfd, index, vaddr, FALSE);
+
+	  size = _bfd_vms_output_check (abfd, 0);	/* get max size */
+	  if (size > ssize)			/* more than what's left ? */
 	    size = ssize;
 	}
 
@@ -1827,8 +2390,63 @@ sto_imm (bfd * abfd, vms_section *sptr, bfd_vma vaddr, int index)
 #endif
 
       vaddr += size;
-      ssize -= size;
       cptr += size;
+      ssize -= size;
+    }
+}
+
+/* Start ETBT record for section #index at virtual addr offset.  */
+
+static void
+start_first_etbt_record (bfd *abfd)
+{
+  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
+  _bfd_vms_output_push (abfd);
+
+  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);	/* push start offset */
+  _bfd_vms_output_long (abfd, (unsigned long) 0);
+  _bfd_vms_output_flush (abfd);
+
+  _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_DFLOC, -1);	/* start = pop() */
+  _bfd_vms_output_flush (abfd);
+}
+
+static void
+start_another_etbt_record (bfd *abfd)
+{
+  _bfd_vms_output_begin (abfd, EOBJ_S_C_ETBT, -1);
+  _bfd_vms_output_push (abfd);
+}
+
+static void
+etir_output_check (bfd *abfd, asection *section, bfd_vma vaddr, int checklen)
+{
+  if (_bfd_vms_output_check (abfd, checklen) < 0)
+    {
+      end_etir_record (abfd);
+      if (section->name[0] && section->name[1] == 'v'
+	  && !strcmp (section->name, ".vmsdebug"))
+	start_another_etbt_record (abfd);
+      else
+	start_etir_record (abfd, section->index, vaddr, FALSE);
+    }
+}
+
+/* Return whether RELOC must be deferred till the end.  */
+
+static int
+defer_reloc_p (arelent *reloc)
+{
+  switch (reloc->howto->type)
+    {
+    case ALPHA_R_NOP:
+    case ALPHA_R_LDA:
+    case ALPHA_R_BSR:
+    case ALPHA_R_BOH:
+      return 1;
+
+    default:
+      return 0;
     }
 }
 
@@ -1838,8 +2456,6 @@ int
 _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
 {
   asection *section;
-  vms_section *sptr;
-  int nextoffset;
 
 #if VMS_DEBUG
   _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
@@ -1847,391 +2463,346 @@ _bfd_vms_write_tir (bfd * abfd, int objtype ATTRIBUTE_UNUSED)
 
   _bfd_vms_output_alignment (abfd, 4);
 
-  nextoffset = 0;
   PRIV (vms_linkage_index) = 1;
 
-  /* Dump all other sections.  */
-  section = abfd->sections;
-
-  while (section != NULL)
+  for (section = abfd->sections; section; section = section->next)
     {
-
 #if VMS_DEBUG
       _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
 		      section->index, section->name,
 		      (int) (section->size));
 #endif
 
+      if (!(section->flags & SEC_HAS_CONTENTS)
+	  || bfd_is_com_section (section))
+	continue;
+
+      if (!section->contents)
+	{
+	  bfd_set_error (bfd_error_no_contents);
+	  return -1;
+	}
+
+      if (section->name[0]
+	  && section->name[1] == 'v'
+	  && !strcmp (section->name, ".vmsdebug"))
+	start_first_etbt_record (abfd);
+      else
+	start_etir_record (abfd, section->index, 0, FALSE);
+
       if (section->flags & SEC_RELOC)
 	{
-	  int i;
+	  bfd_vma curr_addr = 0;
+	  unsigned char *curr_data = section->contents;
+	  bfd_size_type size;
+	  int pass2_needed = 0;
+	  int pass2_in_progress = 0;
+	  unsigned int irel;
+
+	  if (section->reloc_count <= 0)
+	    (*_bfd_error_handler)
+	      (_("SEC_RELOC with no relocs in section %s"), section->name);
 
-	  if ((i = section->reloc_count) <= 0)
-	    (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
-				   section->name);
 #if VMS_DEBUG
 	  else
 	    {
-	      arelent **rptr;
+	      int i = section->reloc_count;
+	      arelent **rptr = section->orelocation;
 	      _bfd_vms_debug (4, "%d relocations:\n", i);
-	      rptr = section->orelocation;
 	      while (i-- > 0)
 		{
-		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
+		  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, "
+				     "addr %08lx, off %08lx, len %d: %s\n",
 				  (*(*rptr)->sym_ptr_ptr)->name,
 				  (*(*rptr)->sym_ptr_ptr)->section->name,
 				  (long) (*(*rptr)->sym_ptr_ptr)->value,
 				  (*rptr)->address, (*rptr)->addend,
 				  bfd_get_reloc_size ((*rptr)->howto),
-				  (*rptr)->howto->name);
+				   ( *rptr)->howto->name);
 		  rptr++;
 		}
 	    }
 #endif
-	}
 
-      if ((section->flags & SEC_HAS_CONTENTS)
-	  && (! bfd_is_com_section (section)))
-	{
-	  /* Virtual addr in section.  */
-	  bfd_vma vaddr;
-
-	  sptr = _bfd_get_vms_section (abfd, section->index);
-	  if (sptr == NULL)
+	new_pass:
+	  for (irel = 0; irel < section->reloc_count; irel++)
 	    {
-	      bfd_set_error (bfd_error_no_contents);
-	      return -1;
-	    }
+	      struct evax_private_udata_struct *udata;
+	      arelent *rptr = section->orelocation [irel];
+	      bfd_vma addr = rptr->address;
+	      asymbol *sym = *rptr->sym_ptr_ptr;
+	      asection *sec = sym->section;
+	      int defer = defer_reloc_p (rptr);
+	      unsigned int slen;
+	      char *hash;
+
+	      if (pass2_in_progress)
+		{
+		  /* Non-deferred relocs have already been output.  */
+		  if (!defer)
+		    continue;
+		}
+	      else
+		{
+		  /* Deferred relocs must be output at the very end.  */
+		  if (defer)
+		    {
+		      pass2_needed = 1;
+		      continue;
+		    }
 
-	  vaddr = (bfd_vma) (sptr->offset);
+		  /* Regular relocs are intertwined with binary data.  */
+	          if (curr_addr > addr)
+		    (*_bfd_error_handler) (_("Size error in section %s"),
+					   section->name);
+		  size = addr - curr_addr;
+		  sto_imm (abfd, size, curr_data, curr_addr,
+		          section->index, section->name);
+		  curr_data += size;
+		  curr_addr += size;
+		}
 
-	  start_etir_record (abfd, section->index, (uquad) sptr->offset,
-			     FALSE);
+	      size = bfd_get_reloc_size (rptr->howto);
 
-	  while (sptr != NULL)
-	    {
-	      /* One STA_PQ, CTL_SETRB per vms_section.  */
-	      if (section->flags & SEC_RELOC)
-		{
-		  /* Check for relocs.  */
-		  arelent **rptr = section->orelocation;
-		  int i = section->reloc_count;
+	      switch (rptr->howto->type)
+	        {
+		case ALPHA_R_IGNORE:
+		  break;
 
-		  for (;;)
+		case ALPHA_R_REFLONG:
+		  if (bfd_is_und_section (sym->section))
 		    {
-		      bfd_size_type addr = (*rptr)->address;
-		      bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
-		      if (sptr->offset < addr)
-			{
-			  /* Sptr starts before reloc.  */
-			  bfd_size_type before = addr - sptr->offset;
-			  if (sptr->size <= before)
-			    {
-			      /* Complete before.  */
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			      break;
-			    }
-			  else
-			    {
-			      /* Partly before.  */
-			      int after = sptr->size - before;
-
-			      sptr->size = before;
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			      sptr->contents += before;
-			      sptr->offset += before;
-			      sptr->size = after;
-			    }
-			}
-		      else if (sptr->offset == addr)
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
 			{
-			  /* Sptr starts at reloc.  */
-			  asymbol *sym = *(*rptr)->sym_ptr_ptr;
-			  asection *sec = sym->section;
-
-			  switch ((*rptr)->howto->type)
-			    {
-			    case ALPHA_R_IGNORE:
-			      break;
-
-			    case ALPHA_R_REFLONG:
-			      {
-				if (bfd_is_und_section (sym->section))
-				  {
-				    int slen = strlen ((char *) sym->name);
-				    char *hash;
-
-				    if (_bfd_vms_output_check (abfd, slen) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_GBL_LW,
-							   -1);
-				    hash = (_bfd_vms_length_hash_symbol
-					    (abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				    _bfd_vms_output_counted (abfd, hash);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else if (bfd_is_abs_section (sym->section))
-				  {
-				    if (_bfd_vms_output_check (abfd, 16) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_LW,
-							   -1);
-				    _bfd_vms_output_quad (abfd,
-							  (uquad) sym->value);
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_LW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else
-				  {
-				    if (_bfd_vms_output_check (abfd, 32) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_PQ,
-							   -1);
-				    _bfd_vms_output_long (abfd,
-							  (unsigned long) (sec->index));
-				    _bfd_vms_output_quad (abfd,
-							  ((uquad) (*rptr)->addend
-							   + (uquad) sym->value));
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_LW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-			      }
-			      break;
-
-			    case ALPHA_R_REFQUAD:
-			      {
-				if (bfd_is_und_section (sym->section))
-				  {
-				    int slen = strlen ((char *) sym->name);
-				    char *hash;
-
-				    if (_bfd_vms_output_check (abfd, slen) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_GBL,
-							   -1);
-				    hash = (_bfd_vms_length_hash_symbol
-					    (abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				    _bfd_vms_output_counted (abfd, hash);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else if (bfd_is_abs_section (sym->section))
-				  {
-				    if (_bfd_vms_output_check (abfd, 16) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_QW,
-							   -1);
-				    _bfd_vms_output_quad (abfd,
-							  (uquad) sym->value);
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_QW,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-				else
-				  {
-				    if (_bfd_vms_output_check (abfd, 32) < 0)
-				      {
-					end_etir_record (abfd);
-					start_etir_record (abfd,
-							   section->index,
-							   vaddr, FALSE);
-				      }
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STA_PQ,
-							   -1);
-				    _bfd_vms_output_long (abfd,
-							  (unsigned long) (sec->index));
-				    _bfd_vms_output_quad (abfd,
-							  ((uquad) (*rptr)->addend
-							   + (uquad) sym->value));
-				    _bfd_vms_output_flush (abfd);
-				    _bfd_vms_output_begin (abfd,
-							   ETIR_S_C_STO_OFF,
-							   -1);
-				    _bfd_vms_output_flush (abfd);
-				  }
-			      }
-			      break;
-
-			    case ALPHA_R_HINT:
-			      {
-				int hint_size;
-				char *hash ATTRIBUTE_UNUSED;
-
-				hint_size = sptr->size;
-				sptr->size = len;
-				sto_imm (abfd, sptr, vaddr, section->index);
-				sptr->size = hint_size;
-			      }
-			      break;
-			    case ALPHA_R_LINKAGE:
-			      {
-				char *hash;
-
-				if (_bfd_vms_output_check (abfd, 64) < 0)
-				  {
-				    end_etir_record (abfd);
-				    start_etir_record (abfd, section->index,
-						       vaddr, FALSE);
-				  }
-				_bfd_vms_output_begin (abfd,
-						       ETIR_S_C_STC_LP_PSB,
-						       -1);
-				_bfd_vms_output_long (abfd,
-						      (unsigned long) PRIV (vms_linkage_index));
-				PRIV (vms_linkage_index) += 2;
-				hash = (_bfd_vms_length_hash_symbol
-					(abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				_bfd_vms_output_counted (abfd, hash);
-				_bfd_vms_output_byte (abfd, 0);
-				_bfd_vms_output_flush (abfd);
-			      }
-			      break;
-
-			    case ALPHA_R_CODEADDR:
-			      {
-				int slen = strlen ((char *) sym->name);
-				char *hash;
-				if (_bfd_vms_output_check (abfd, slen) < 0)
-				  {
-				    end_etir_record (abfd);
-				    start_etir_record (abfd,
-						       section->index,
-						       vaddr, FALSE);
-				  }
-				_bfd_vms_output_begin (abfd,
-						       ETIR_S_C_STO_CA,
-						       -1);
-				hash = (_bfd_vms_length_hash_symbol
-					(abfd, sym->name, EOBJ_S_C_SYMSIZ));
-				_bfd_vms_output_counted (abfd, hash);
-				_bfd_vms_output_flush (abfd);
-			      }
-			      break;
-
-			    default:
-			      (*_bfd_error_handler) (_("Unhandled relocation %s"),
-						     (*rptr)->howto->name);
-			      break;
-			    }
-
-			  vaddr += len;
-
-			  if (len == sptr->size)
-			    {
-			      break;
-			    }
-			  else
-			    {
-			      sptr->contents += len;
-			      sptr->offset += len;
-			      sptr->size -= len;
-			      i--;
-			      rptr++;
-			    }
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
+			  _bfd_vms_output_long (abfd, (unsigned long) addend);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+			  _bfd_vms_output_flush (abfd);
 			}
 		      else
 			{
-			  /* Sptr starts after reloc.  */
-			  i--;
-			  /* Check next reloc.  */
-			  rptr++;
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL_LW, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
 			}
+		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_LW, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
+						    + (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      /* ??? Table B-8 of the OpenVMS Linker Utilily Manual
+			 says that we should have a ETIR_S_C_STO_OFF here.
+			 But the relocation would not be BFD_RELOC_32 then.
+			 This case is very likely unreachable.  */
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_LW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  break;
 
-		      if (i == 0)
+		case ALPHA_R_REFQUAD:
+		  if (bfd_is_und_section (sym->section))
+		    {
+		      bfd_vma addend = rptr->addend;
+		      slen = strlen ((char *) sym->name);
+		      hash = _bfd_vms_length_hash_symbol
+			       (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		      etir_output_check (abfd, section, curr_addr, slen);
+		      if (addend)
+			{
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
+			  _bfd_vms_output_quad (abfd, (uquad) addend);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_OPR_ADD, -1);
+			  _bfd_vms_output_flush (abfd);
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
+			  _bfd_vms_output_flush (abfd);
+			}
+		      else
 			{
-			  /* All reloc checked.  */
-			  if (sptr->size > 0)
-			    {
-			      /* Dump rest.  */
-			      sto_imm (abfd, sptr, vaddr, section->index);
-			      vaddr += sptr->size;
-			    }
-			  break;
+			  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_GBL, -1);
+			  _bfd_vms_output_counted (abfd, hash);
+			  _bfd_vms_output_flush (abfd);
 			}
 		    }
+		  else if (bfd_is_abs_section (sym->section))
+		    {
+		      etir_output_check (abfd, section, curr_addr, 16);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_QW, -1);
+		      _bfd_vms_output_quad (abfd, (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_QW, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  else
+		    {
+		      etir_output_check (abfd, section, curr_addr, 32);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);
+		      _bfd_vms_output_long (abfd, (unsigned long) sec->index);
+		      _bfd_vms_output_quad (abfd, (uquad) rptr->addend
+						    + (uquad) sym->value);
+		      _bfd_vms_output_flush (abfd);
+		      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_OFF, -1);
+		      _bfd_vms_output_flush (abfd);
+		    }
+		  break;
+
+		case ALPHA_R_HINT:
+		  sto_imm (abfd, size, curr_data, curr_addr,
+			   section->index, section->name);
+		  break;
+		
+		case ALPHA_R_LINKAGE:
+		  etir_output_check (abfd, section, curr_addr, 64);
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LP_PSB, -1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) PRIV (vms_linkage_index));
+		  PRIV (vms_linkage_index) += 2;
+		  hash = _bfd_vms_length_hash_symbol
+			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		  _bfd_vms_output_counted (abfd, hash);
+		  _bfd_vms_output_byte (abfd, 0);
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_CODEADDR:
+		  slen = strlen ((char *) sym->name);
+		  hash = _bfd_vms_length_hash_symbol
+			   (abfd, sym->name, EOBJ_S_C_SYMSIZ);
+		  etir_output_check (abfd, section, curr_addr, slen);
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STO_CA, -1);
+		  _bfd_vms_output_counted (abfd, hash);
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_NOP:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_NOP_GBL, -1);
+		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0x47ff041f);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_BSR:
+		  (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
+		  break;
+
+		case ALPHA_R_LDA:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				     32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_LDA_GBL, -1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->lkindex + 1);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0x237B0000);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->bsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			    (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		case ALPHA_R_BOH:
+		  udata
+		    = (struct evax_private_udata_struct *) rptr->sym_ptr_ptr;
+		  etir_output_check (abfd, section, curr_addr,
+				       32 + 1 + strlen (udata->origname));
+		  _bfd_vms_output_begin (abfd, ETIR_S_C_STC_BOH_GBL, -1);
+		  _bfd_vms_output_long (abfd, (unsigned long) udata->lkindex);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->address);
+		  _bfd_vms_output_long (abfd, (unsigned long) 0xD3400000);
+		  _bfd_vms_output_long
+		    (abfd, (unsigned long) udata->enbsym->section->index);
+		  _bfd_vms_output_quad (abfd, (uquad) rptr->addend);
+		  _bfd_vms_output_counted
+		    (abfd, _bfd_vms_length_hash_symbol
+			     (abfd, udata->origname, EOBJ_S_C_SYMSIZ));
+		  _bfd_vms_output_flush (abfd);
+		  break;
+
+		default:
+		  (*_bfd_error_handler) (_("Unhandled relocation %s"),
+		  			 rptr->howto->name);
+		  break;
 		}
-	      else
+
+	      curr_data += size;
+	      curr_addr += size;
+	    } /* End of relocs loop.  */
+
+	  if (!pass2_in_progress)
+	    {
+	      /* Output rest of section.  */
+	      if (curr_addr > section->size)
+		(*_bfd_error_handler) (_("Size error in section %s"),
+				       section->name);
+	      size = section->size - curr_addr;
+	      sto_imm (abfd, size, curr_data, curr_addr,
+		       section->index, section->name);
+	      curr_data += size;
+	      curr_addr += size;
+
+	      if (pass2_needed)
 		{
-		  /* No relocs, just dump.  */
-		  sto_imm (abfd, sptr, vaddr, section->index);
-		  vaddr += sptr->size;
+		  pass2_in_progress = 1;
+		  goto new_pass;
 		}
-
-	      sptr = sptr->next;
 	    }
-
-	  end_etir_record (abfd);
 	}
+  
+      else /* (section->flags & SEC_RELOC) */
+	sto_imm (abfd, section->size, section->contents, 0,
+		 section->index, section->name);
 
-      section = section->next;
+      end_etir_record (abfd);
     }
 
   _bfd_vms_output_alignment (abfd, 2);
   return 0;
 }
-
-/* Write traceback data for bfd abfd.  */
-
-int
-_bfd_vms_write_tbt (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
-#endif
-
-  return 0;
-}
-
-/* Write debug info for bfd abfd.  */
-
-int
-_bfd_vms_write_dbg (bfd * abfd ATTRIBUTE_UNUSED,
-		    int objtype ATTRIBUTE_UNUSED)
-{
-#if VMS_DEBUG
-  _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
-#endif
-
-  return 0;
-}