Tue Jun 18 14:42:58 1996 Klaus Kaempf <kkaempf@progis.de>

	Added support for Alpha OpenVMS:
	* evax.h, evax-alpha.c, evax-egsd.c, evax-emh.c: New files.
	* evax-etir.c, evax-misc.c, hosts/alphavms.h: New files.
	* config.h-vms, makefile.vms: New files.
	* config.bfd (alpha-*-*vms*): New target.
	* configure.in (evax_alpha_vec): New target vector.
	* configure: Rebuild.
	* reloc.c (BFD_RELOC_SWREL32, BFD_RELOC_SWREL64): Define.
	(BFD_RELOC_ALPHA_LINKAGE, BFD_RELOC_ALPHA_BASEREG): Define.
	* targets.c (bfd_target_evax_flavour): Define.
	(evax_alpha_vec): Declare.
	(bfd_target_vector): Add ecoffalpha_little_vec and evax_alpha_vec
	if BFD64 is defined.
	* bfd-in2.h, libbfd.h: Rebuild.
	* Makefile.in: Rebuild dependencies.
	(BFD64_BACKENDS): Add evax-alpha.o, evax-egsd.o, evax-etir.o,
	evax-emh.o, and evax-misc.o.
	(BFD64_BACKENDS_CFILES): Add evax-alpha.c, evax-egsd.c,
	evax-etir.c, evax-emh.c, and evax-misc.c.
	(HFILES): Add evax.h.

1 files changed, 1553 insertions, 0 deletions

diff --git a/bfd/evax-etir.c b/bfd/evax-etir.c
new file mode 100644
index 0000000..b9c53bc
--- /dev/null
+++ b/bfd/evax-etir.c
@@ -0,0 +1,1553 @@
+/* evax-etir.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
+   Copyright 1996 Free Software Foundation, Inc.
+   ETIR record handling functions
+
+   go and read the openVMS linker manual (esp. appendix B)
+   if you don't know what's going on here :-)
+
+   Written by Klaus Kämpf (kkaempf@progis.de)
+   of proGIS Softwareentwicklung, Aachen, Germany
+
+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.  */
+
+
+/* The following type abbreviations are used:
+
+	cs	counted string (ascii string with length byte)
+	by	byte (1 byte)
+	sh	short (2 byte, 16 bit)
+	lw	longword (4 byte, 32 bit)
+	qw	quadword (8 byte, 64 bit)
+	da	data stream  */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include "bfd.h"
+#include "sysdep.h"
+#include "bfdlink.h"
+#include "libbfd.h"
+
+#include "evax.h"
+
+#if 0
+static void location_save
+  PARAMS ((bfd *abfd, unsigned long index, unsigned long loc, int section));
+static unsigned long location_restore
+  PARAMS ((bfd *abfd, unsigned long index, int *section));
+#endif /* 0 */
+
+static void image_set_ptr PARAMS ((bfd *abfd, int psect, uquad offset));
+static void image_inc_ptr PARAMS ((bfd *abfd, uquad offset));
+static void image_dump PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
+static void image_write_b PARAMS ((bfd *abfd, unsigned int value));
+static void image_write_w PARAMS ((bfd *abfd, unsigned int value));
+static void image_write_l PARAMS ((bfd *abfd, unsigned long value));
+static void image_write_q PARAMS ((bfd *abfd, uquad value));
+
+/*-----------------------------------------------------------------------------*/
+
+#if 0
+
+/* Save location counter at index  */
+
+static void
+location_save (abfd, index, loc, section)
+     bfd *abfd;
+     unsigned long index;
+     unsigned long loc;
+     int section;
+{
+  PRIV(location_stack)[index].value = loc;
+  PRIV(location_stack)[index].psect = section;
+
+  return;
+}
+
+/* Restore location counter from index  */
+
+static unsigned long
+location_restore (abfd, index, section)
+     bfd *abfd;
+     unsigned long index;
+     int *section;
+{
+  if (section != NULL)
+    *section = PRIV(location_stack)[index].psect;
+  return PRIV(location_stack)[index].value;
+}
+
+#endif /* 0 */
+
+/* routines to fill sections contents during etir read */
+
+/* Initialize image buffer pointer to be filled  */
+
+static void
+image_set_ptr (abfd, psect, offset)
+     bfd *abfd;
+     int psect;
+     uquad offset;
+{
+#if EVAX_DEBUG
+  evax_debug (4, "image_set_ptr(%d=%s, %d)\n",
+		psect, PRIV(sections)[psect]->name, offset);
+#endif
+
+  PRIV(image_ptr) = PRIV(sections)[psect]->contents + offset;
+  return;
+}
+
+
+/* Increment image buffer pointer by offset  */
+
+static void
+image_inc_ptr (abfd, offset)
+     bfd *abfd;
+     uquad offset;
+{
+#if EVAX_DEBUG
+  evax_debug (4, "image_inc_ptr(%d)\n", offset);
+#endif
+
+  PRIV(image_ptr) += offset;
+
+  return;
+}
+
+
+/* Dump multiple bytes to section image  */
+
+static void
+image_dump (abfd, ptr, size, offset)
+    bfd *abfd;
+    unsigned char *ptr;
+    int size;
+    int offset;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_dump from (%p, %d) to (%p)\n", ptr, size, PRIV(image_ptr));
+  _bfd_hexdump (7, ptr, size, offset);
+#endif
+
+  while (size-- > 0)
+    *PRIV(image_ptr)++ = *ptr++;
+  return;
+}
+
+
+/* Write byte to section image  */
+
+static void
+image_write_b (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_b(%02x)\n", (int)value);
+#endif
+
+  *PRIV(image_ptr)++ = (value & 0xff);
+  return;
+}
+
+
+/* Write 2-byte word to image  */
+
+static void
+image_write_w (abfd, value)
+     bfd *abfd;
+     unsigned int value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_w(%04x)\n", (int)value);
+#endif
+
+  bfd_putl16 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 2;
+
+  return;
+}
+
+
+/* Write 4-byte long to image  */
+
+static void
+image_write_l (abfd, value)
+     bfd *abfd;
+     unsigned long value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_l(%08lx)\n", value);
+#endif
+
+  bfd_putl32 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 4;
+
+  return;
+}
+
+
+/* Write 4-byte long to image  */
+
+static void
+image_write_q (abfd, value)
+     bfd *abfd;
+     uquad value;
+{
+#if EVAX_DEBUG
+  evax_debug (6, "image_write_q(%016lx)\n", value);
+#endif
+
+  bfd_putl64 (value, PRIV(image_ptr));
+  PRIV(image_ptr) += 8;
+
+  return;
+}
+
+
+#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
+
+/* etir_sta
+  
+   evax stack commands
+  
+   handle sta_xxx commands in etir section
+   ptr points to data area in record
+  
+   see table B-8 of the openVMS linker manual  */
+
+static boolean
+etir_sta (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+
+  switch (cmd)
+    {
+      /* stack */
+
+      /* stack global
+	   arg: cs	symbol name
+
+	   stack 32 bit value of symbol (high bits set to 0)  */
+
+      case ETIR_S_C_STA_GBL:
+	{
+	  char *name;
+	  evax_symbol_entry *entry;
+
+	  name = _bfd_evax_save_counted_string ((char *)ptr);
+	  entry = (evax_symbol_entry *)
+		  bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	  if (entry == (evax_symbol_entry *)NULL)
+	    {
+#if EVAX_DEBUG
+	      evax_debug (3, "ETIR_S_C_STA_GBL: no symbol \"%s\"\n", name);
+#endif
+	      return false;
+	    }
+	  else
+	    {
+	      _bfd_evax_push (abfd, (uquad)(entry->symbol->value), -1);
+	    }
+	}
+      break;
+
+	/* stack longword
+	   arg: lw	value
+
+	   stack 32 bit value, sign extend to 64 bit  */
+
+      case ETIR_S_C_STA_LW:
+	_bfd_evax_push (abfd, (uquad)bfd_getl32 (ptr), -1);
+      break;
+
+	/* stack global
+	   arg: qw	value
+
+	   stack 64 bit value of symbol	 */
+
+      case ETIR_S_C_STA_QW:
+	_bfd_evax_push (abfd, (uquad)bfd_getl64(ptr), -1);
+      break;
+
+	/* stack psect base plus quadword offset
+	   arg: lw	section index
+	  	qw	signed quadword offset (low 32 bits)
+
+	   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;
+	  int psect;
+
+	  psect = bfd_getl32 (ptr);
+	  if (psect >= PRIV(egsd_sec_count))
+	    {
+	      (*_bfd_error_handler) ("Bad section index in ETIR_S_C_STA_PQ");
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+	  dummy = bfd_getl64 (ptr+4);
+	  _bfd_evax_push (abfd, dummy, psect);
+        }
+      break;
+
+	/* all not supported  */
+
+      case ETIR_S_C_STA_LI:
+      case ETIR_S_C_STA_MOD:
+      case ETIR_S_C_STA_CKARG:
+
+	(*_bfd_error_handler) ("Unsupported STA cmd %d", cmd);
+	return false;
+      break;
+
+      default:
+	(*_bfd_error_handler) ("Reserved STA cmd %d", cmd);
+	return false;
+      break;
+  }
+  return true;
+}
+
+
+/*
+   etir_sto
+  
+   evax store commands
+  
+   handle sto_xxx commands in etir section
+   ptr points to data area in record
+  
+   see table B-9 of the openVMS linker manual  */
+
+static boolean
+etir_sto (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  uquad dummy;
+  int psect;
+
+  switch (cmd)
+    {
+
+      /* store byte: pop stack, write byte
+	 arg: -  */
+
+    case ETIR_S_C_STO_B:
+      dummy = _bfd_evax_pop (abfd, &psect);
+#if 0
+      if (is_share)		/* FIXME */
+	(*_bfd_error_handler) ("ETIR_S_C_STO_B: byte fixups not supported");
+#endif
+      image_write_b (abfd, dummy & 0xff);	/* FIXME: check top bits */
+      break;
+
+      /* store word: pop stack, write word
+	 arg: -  */
+
+    case ETIR_S_C_STO_W:
+      dummy = _bfd_evax_pop (abfd, &psect);
+#if 0
+      if (is_share)		/* FIXME */
+	(*_bfd_error_handler) ("ETIR_S_C_STO_B: word fixups not supported");
+#endif
+      image_write_w (abfd, dummy & 0xffff);	/* FIXME: check top bits */
+      break;
+
+      /* store longword: pop stack, write longword
+	 arg: -  */
+
+    case ETIR_S_C_STO_LW:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      dummy += (PRIV(sections)[psect])->vma;
+      image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
+#if 0				/* FIXME */
+      if (is_rel)
+	evax_debug (3, "ETIR_S_C_STO_LW: Relocation !\n");
+      if (is_share)
+	evax_debug (3, "ETIR_S_C_STO_LW: Fix-up share !\n");
+#endif
+      break;
+
+      /* store quadword: pop stack, write quadword
+	 arg: -  */
+
+    case ETIR_S_C_STO_QW:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      dummy += (PRIV(sections)[psect])->vma;
+      image_write_q(abfd, dummy);		/* FIXME: check top bits */
+#if 0				/* FIXME */
+      if (is_rel)
+	evax_debug (3, "ETIR_S_C_STO_LW: Relocation !\n");
+      if (is_share)
+	evax_debug (3, "ETIR_S_C_STO_LW: Fix-up share !\n");
+#endif
+      break;
+
+      /* store immediate repeated: pop stack for repeat count
+	 arg: lw	byte count
+	 da	data  */
+
+    case ETIR_S_C_STO_IMMR:
+      {
+	unsigned long size;
+
+	size = bfd_getl32 (ptr);
+	dummy = (unsigned long)_bfd_evax_pop (abfd, NULL);
+	while (dummy-- > 0L)
+	  image_dump (abfd, ptr+4, size, 0);
+      }
+      break;
+
+      /* store global: write symbol value
+	 arg: cs	global symbol name  */
+
+    case ETIR_S_C_STO_GBL:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *)bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+	    (*_bfd_error_handler) ("ETIR_S_C_STO_GBL: no symbol \"%s\"",
+				   name);
+	    return false;
+	  }
+	else
+	  image_write_q (abfd, (uquad)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* store code address: write address of entry point
+	 arg: cs	global symbol name (procedure)  */
+
+    case ETIR_S_C_STO_CA:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *) bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+	    (*_bfd_error_handler) ("ETIR_S_C_STO_CA: no symbol \"%s\"",
+				   name);
+	    return false;
+	  }
+	else
+	  image_write_q (abfd, (uquad)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* not supported  */
+
+    case ETIR_S_C_STO_RB:
+    case ETIR_S_C_STO_AB:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_RB/AB: Not supported");
+      break;
+
+    /* store offset to psect: pop stack, add low 32 bits to base of psect
+       arg: -  */
+
+    case ETIR_S_C_STO_OFF:
+      {
+	uquad q;
+	int psect;
+
+	q = _bfd_evax_pop (abfd, &psect);
+	q += (PRIV(sections)[psect])->vma;
+	image_write_q (abfd, q);
+      }
+      break;
+
+      /* store immediate
+	 arg: lw	count of bytes
+	 da	data  */
+
+    case ETIR_S_C_STO_IMM:
+      {
+	int size;
+
+	size = bfd_getl32 (ptr);
+	image_dump (abfd, ptr+4, size, 0);
+      }
+      break;
+
+      /* this code is 'reserved to digital' according to the openVMS linker manual,
+	 however it is generated by the DEC C compiler and defined in the include file.
+	 FIXME, since the following is just a guess
+	 store global longword: store 32bit value of symbol
+	 arg: cs	symbol name  */
+
+    case ETIR_S_C_STO_GBL_LW:
+      {
+	evax_symbol_entry *entry;
+	char *name;
+
+	name = _bfd_evax_save_counted_string ((char *)ptr);
+	entry = (evax_symbol_entry *)bfd_hash_lookup (PRIV(evax_symbol_table), name, false, false);
+	if (entry == (evax_symbol_entry *)NULL)
+	  {
+#if EVAX_DEBUG
+	    evax_debug (3, "ETIR_S_C_STO_GBL_LW: no symbol \"%s\"\n", name);
+#endif
+	    return false;
+	  }
+	else
+	  image_write_l (abfd, (unsigned long)(entry->symbol->value));	/* FIXME, reloc */
+      }
+      break;
+
+      /* not supported  */
+
+    case ETIR_S_C_STO_LP_PSB:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_LP_PSB: Not supported");
+      break;
+
+    /* */
+
+    case ETIR_S_C_STO_HINT_GBL:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_HINT_GBL: not implemented");
+      break;
+
+    /* */
+
+    case ETIR_S_C_STO_HINT_PS:
+      (*_bfd_error_handler) ("ETIR_S_C_STO_HINT_PS: not implemented");
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved STO cmd %d", cmd);
+      break;
+    }
+
+  return true;
+}
+
+/* stack operator commands
+   all 32 bit signed arithmetic
+   all word just like a stack calculator
+   arguments are popped from stack, results are pushed on stack
+  
+   see table B-10 of the openVMS linker manual  */
+
+static boolean
+etir_opr (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  long op1, op2;
+
+  switch (cmd)
+    {
+      /* operation */
+
+      /* no-op  */
+
+    case ETIR_S_C_OPR_NOP:
+      break;
+
+      /* add  */
+
+    case ETIR_S_C_OPR_ADD:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 + op2), -1);
+      break;
+
+      /* subtract  */
+
+    case ETIR_S_C_OPR_SUB:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op2 - op1), -1);
+      break;
+
+      /* multiply  */
+
+    case ETIR_S_C_OPR_MUL:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 * op2), -1);
+      break;
+
+      /* divide  */
+
+    case ETIR_S_C_OPR_DIV:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      if (op2 == 0)
+	_bfd_evax_push (abfd, (uquad)0L, -1);
+      else
+	_bfd_evax_push (abfd, (uquad)(op2 / op1), -1);
+      break;
+
+      /* logical and  */
+
+    case ETIR_S_C_OPR_AND:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 & op2), -1);
+      break;
+
+      /* logical inclusive or	 */
+
+    case ETIR_S_C_OPR_IOR:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 | op2), -1);
+      break;
+
+      /* logical exclusive or  */
+
+    case ETIR_S_C_OPR_EOR:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 ^ op2), -1);
+      break;
+
+      /* negate  */
+
+    case ETIR_S_C_OPR_NEG:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(-op1), -1);
+      break;
+
+      /* complement  */
+
+    case ETIR_S_C_OPR_COM:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      _bfd_evax_push (abfd, (uquad)(op1 ^ -1L), -1);
+      break;
+
+      /* insert field  */
+
+    case ETIR_S_C_OPR_INSV:
+      (void)_bfd_evax_pop (abfd, NULL);
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_INSV: Not supported");
+      break;
+
+    /* arithmetic shift  */
+
+    case ETIR_S_C_OPR_ASH:
+      op1 = (long)_bfd_evax_pop (abfd, NULL);
+      op2 = (long)_bfd_evax_pop (abfd, NULL);
+      if (op2 < 0)		/* shift right */
+	op1 >>= -op2;
+      else			/* shift left */
+	op1 <<= op2;
+      _bfd_evax_push (abfd, (uquad)op1, -1);
+      break;
+
+      /* unsigned shift  */
+
+    case ETIR_S_C_OPR_USH:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_USH: Not supported");
+      break;
+
+      /* rotate  */
+
+    case ETIR_S_C_OPR_ROT:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_ROT: Not supported");
+      break;
+
+      /* select  */
+
+    case ETIR_S_C_OPR_SEL:
+      if ((long)_bfd_evax_pop (abfd, NULL) & 0x01L)
+	(void)_bfd_evax_pop (abfd, NULL);
+      else
+	{
+	  op1 = (long)_bfd_evax_pop (abfd, NULL);
+	  (void)_bfd_evax_pop (abfd, NULL);
+	  _bfd_evax_push (abfd, (uquad)op1, -1);
+	}
+      break;
+
+      /* redefine symbol to current location  */
+
+    case ETIR_S_C_OPR_REDEF:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_REDEF: Not supported");
+      break;
+
+      /* define a literal  */
+
+    case ETIR_S_C_OPR_DFLIT:
+      (*_bfd_error_handler) ("ETIR_S_C_OPR_DFLIT: Not supported");
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved OPR cmd %d", cmd);
+      break;
+    }
+
+  return true;
+}
+
+
+/* control commands
+  
+   see table B-11 of the openVMS linker manual  */
+
+static boolean
+etir_ctl (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  uquad	 dummy;
+  int psect;
+
+  switch (cmd)
+    {
+      /* set relocation base: pop stack, set image location counter
+	 arg: -  */
+
+    case ETIR_S_C_CTL_SETRB:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      image_set_ptr (abfd, psect, dummy);
+      break;
+
+      /* augment relocation base: increment image location counter by offset
+	 arg: lw	offset value  */
+
+    case ETIR_S_C_CTL_AUGRB:
+      dummy = bfd_getl32 (ptr);
+      image_inc_ptr (abfd, dummy);
+      break;
+
+      /* define location: pop index, save location counter under index
+	 arg: -  */
+
+    case ETIR_S_C_CTL_DFLOC:
+      dummy = _bfd_evax_pop (abfd, NULL);
+      /* FIXME */
+      break;
+
+      /* set location: pop index, restore location counter from index
+	 arg: -  */
+
+    case ETIR_S_C_CTL_STLOC:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      /* FIXME */
+      break;
+
+      /* stack defined location: pop index, push location counter from index
+	 arg: -  */
+
+    case ETIR_S_C_CTL_STKDL:
+      dummy = _bfd_evax_pop (abfd, &psect);
+      /* FIXME */
+      break;
+
+    default:
+      (*_bfd_error_handler) ("Reserved CTL cmd %d", cmd);
+      break;
+    }
+  return true;
+}
+
+
+/* store conditional commands
+  
+   see table B-12 and B-13 of the openVMS linker manual  */
+
+static boolean
+etir_stc (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+
+  switch (cmd)
+    {
+      /* 200 Store-conditional Linkage Pair
+	 arg:  */
+
+    case ETIR_S_C_STC_LP:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_LP: not supported");
+      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, 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) ("ETIR_S_C_STC_GBL: not supported");
+      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) ("ETIR_S_C_STC_GCA: not supported");
+      break;
+
+      /* 204 Store-conditional Address at psect + offset
+	 arg:	lw	linkage index
+	 lw	psect index
+	 qw	offset  */
+
+    case ETIR_S_C_STC_PS:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_PS: not supported");
+      break;
+
+      /* 205 Store-conditional NOP at address of global
+	 arg:  */
+
+    case ETIR_S_C_STC_NOP_GBL:
+
+      /* 206 Store-conditional NOP at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_NOP_PS:
+
+      /* 207 Store-conditional BSR at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_BSR_GBL:
+
+      /* 208 Store-conditional BSR at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_BSR_PS:
+
+      /* 209 Store-conditional LDA at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_LDA_GBL:
+
+      /* 210 Store-conditional LDA at psect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_LDA_PS:
+
+      /* 211 Store-conditional BSR or Hint at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_BOH_GBL:
+
+      /* 212 Store-conditional BSR or Hint at pect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_BOH_PS:
+
+      /* 213 Store-conditional NOP,BSR or HINT at global address
+	 arg:  */
+
+    case ETIR_S_C_STC_NBH_GBL:
+
+      /* 214 Store-conditional NOP,BSR or HINT at psect + offset
+	 arg:  */
+
+    case ETIR_S_C_STC_NBH_PS:
+      (*_bfd_error_handler) ("ETIR_S_C_STC_xx: (%d) not supported", cmd);
+      break;
+
+    default:
+#if EVAX_DEBUG
+      evax_debug (3,  "Reserved STC cmd %d", cmd);
+#endif
+      break;
+    }
+  return true;
+}
+
+
+/* handle command from ETIR section  */
+
+static boolean
+tir_cmd (abfd, cmd, ptr)
+     bfd *abfd;
+     int cmd;
+     unsigned char *ptr;
+{
+  static struct {
+    int mincod;
+    int maxcod;
+    boolean (*explain) PARAMS((bfd *, int, unsigned char *));
+  } tir_table[] = {
+    { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
+    { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
+    { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
+    { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
+    { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
+    { -1, -1, NULL }
+  };
+
+  int i = 0;
+  boolean res = true;
+
+  while (tir_table[i].mincod >= 0)
+    {
+      if ( (tir_table[i].mincod <= cmd) 
+	&& (cmd <= tir_table[i].maxcod))
+	{
+	  res = tir_table[i].explain (abfd, cmd, ptr);
+	  break;
+	}
+      i++;
+    }
+
+  return res;
+}
+
+
+/* Text Information and Relocation Records (OBJ$C_TIR)
+   handle etir record  */
+
+static boolean
+analyze_etir (abfd, ptr, length)
+     bfd *abfd;
+     unsigned char *ptr;
+     unsigned int length;
+{
+  int cmd;
+  unsigned char *maxptr;
+  boolean res = true;
+
+  maxptr = ptr + length;
+
+  while (ptr < maxptr)
+    {
+      cmd = bfd_getl16 (ptr);
+      length = bfd_getl16 (ptr + 2);
+      res = tir_cmd (abfd, cmd, ptr+4);
+      if (!res)
+	break;
+      ptr += length;
+    }
+  return res;
+}
+
+
+/* process ETIR record
+  
+   return 0 on success, -1 on error  */
+
+int
+_bfd_evax_slurp_etir (abfd)
+     bfd *abfd;
+{
+
+#if EVAX_DEBUG
+  evax_debug (2, "ETIR\n");
+#endif
+
+  PRIV(evax_rec) += 4;	/* skip type, size */
+  PRIV(rec_size) -= 4;
+  if (analyze_etir (abfd, PRIV(evax_rec), PRIV(rec_size)))
+    return 0;
+
+  return -1;
+}
+
+
+/* process EDBG record
+   return 0 on success, -1 on error
+  
+   not implemented yet  */
+
+int
+_bfd_evax_slurp_edbg (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "EDBG\n");
+#endif
+
+  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
+  return 0;
+}
+
+
+/* process ETBT record
+   return 0 on success, -1 on error
+  
+   not implemented yet  */
+
+int
+_bfd_evax_slurp_etbt (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "ETBT\n");
+#endif
+
+  return 0;
+}
+
+/*----------------------------------------------------------------------*/
+/*									*/
+/*	WRITE ETIR SECTION						*/
+/*									*/
+/*	this is still under construction and therefore not documented	*/
+/*									*/
+/*----------------------------------------------------------------------*/
+
+static void start_etir_record PARAMS ((bfd *abfd, int index, uquad offset, boolean justoffset));
+static void sto_imm PARAMS ((bfd *abfd, evax_section *sptr, bfd_vma vaddr, int index));
+static void end_etir_record PARAMS ((bfd *abfd));
+
+static void
+sto_imm (abfd, sptr, vaddr, index)
+     bfd *abfd;
+     evax_section *sptr;
+     bfd_vma vaddr;
+     int index;
+{
+  int size;
+  int ssize;
+  unsigned char *cptr;
+
+#if EVAX_DEBUG
+  evax_debug (8, "sto_imm %d bytes\n", sptr->size);
+  _bfd_hexdump (9, sptr->contents, (int)sptr->size, (int)vaddr);
+#endif
+
+  ssize = sptr->size;
+  cptr = sptr->contents;
+
+  while (ssize > 0)
+    {
+
+      size = ssize;				/* try all the rest */
+
+      if (_bfd_evax_output_check (abfd, size) < 0)
+	{					/* doesn't fit, split ! */
+	  end_etir_record (abfd);
+	  start_etir_record (abfd, index, vaddr, false);
+	  size = _bfd_evax_output_check (abfd, 0);	/* get max size */
+	  if (size > ssize)			/* more than what's left ? */
+	    size = ssize;
+	}
+
+      _bfd_evax_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
+      _bfd_evax_output_long (abfd, (unsigned long)(size));
+      _bfd_evax_output_dump (abfd, cptr, size);
+      _bfd_evax_output_flush (abfd);
+
+#if EVAX_DEBUG
+      evax_debug (10, "dumped %d bytes\n", size);
+      _bfd_hexdump (10, cptr, (int)size, (int)vaddr);
+#endif
+
+      vaddr += size;
+      ssize -= size;
+      cptr += size;
+    }
+
+  return;
+}
+
+/*-------------------------------------------------------------------*/
+
+/* start ETIR record for section #index at virtual addr offset.  */
+
+static void
+start_etir_record (abfd, index, offset, justoffset)
+    bfd *abfd;
+    int index;
+    uquad offset;
+    boolean justoffset;
+{
+  if (!justoffset)
+    {
+      _bfd_evax_output_begin (abfd, EOBJ_S_C_ETIR, -1);	/* one ETIR per section */
+      _bfd_evax_output_push (abfd);
+    }
+
+  _bfd_evax_output_begin (abfd, ETIR_S_C_STA_PQ, -1);	/* push start offset */
+  _bfd_evax_output_long (abfd, (unsigned long)index);
+  _bfd_evax_output_quad (abfd, (uquad)offset);
+  _bfd_evax_output_flush (abfd);
+
+  _bfd_evax_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1);	/* start = pop() */
+  _bfd_evax_output_flush (abfd);
+
+  return;
+}
+
+
+/* end etir record  */
+static void
+end_etir_record (abfd)
+    bfd *abfd;
+{
+  _bfd_evax_output_pop (abfd);
+  _bfd_evax_output_end (abfd); 
+}
+
+/* write section contents for bfd abfd  */
+
+int
+_bfd_evax_write_etir (abfd)
+     bfd *abfd;
+{
+  asection *section;
+  evax_section *sptr;
+  int nextoffset;
+  char uname[200];
+  char *nptr, *uptr;
+
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_etir(%p)\n", abfd);
+#endif
+
+  _bfd_evax_output_alignment (abfd, 4);
+
+  nextoffset = 0;
+  PRIV(evax_linkage_index) = 1;
+
+  /* dump all other sections  */
+
+  section = abfd->sections;
+
+  while (section != NULL)
+    {
+
+#if EVAX_DEBUG
+      evax_debug (4, "writing %d. section '%s' (%d bytes)\n", section->index, section->name, (int)(section->_raw_size));
+#endif
+
+      if (section->flags & SEC_RELOC)
+	{
+	  int i;
+
+	  if ((i = section->reloc_count) <= 0)
+	    {
+	      (*_bfd_error_handler) ("SEC_RELOC with no relocs in section %s",
+				     section->name);
+	    }
+#if EVAX_DEBUG
+	  else
+	    {
+	      arelent **rptr;
+	      evax_debug (4, "%d relocations:\n", i);
+	      rptr = section->orelocation;
+	      while (i-- > 0)
+		{
+		  evax_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++;
+		}
+	    }
+#endif
+	}
+
+      if (section->flags & SEC_HAS_CONTENTS)
+	{
+	  bfd_vma vaddr;		/* virtual addr in section */
+
+	  sptr = _bfd_get_evax_section (abfd, section->index);
+	  if (sptr == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_contents);
+	      return -1;
+	    }
+
+	  vaddr = (bfd_vma)(sptr->offset);
+
+	  start_etir_record (abfd, section->index, (uquad) sptr->offset,
+			     false);
+
+	  while (sptr != NULL)				/* one STA_PQ, CTL_SETRB per evax_section */
+	    {
+
+	      if (section->flags & SEC_RELOC)			/* check for relocs */
+		{
+		  arelent **rptr = section->orelocation;
+		  int i = section->reloc_count;
+		  for (;;)
+		    {
+		      bfd_size_type addr = (*rptr)->address;
+		      int len = bfd_get_reloc_size ((*rptr)->howto);
+		      if (sptr->offset < addr)		/* sptr starts before reloc */
+			{
+			  int 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)	/* 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))
+				  {
+				    if (_bfd_evax_output_check (abfd,
+								strlen((char *)sym->name))
+					< 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_GBL_LW,
+							    -1);
+				    uptr = uname;
+				    nptr = (char *)sym->name;
+				    while (*nptr)
+				      {
+					if (islower (*nptr))
+					  *uptr = toupper (*nptr);
+					else
+					  *uptr = *nptr;
+					nptr++;
+					uptr++;
+				      }
+				    *uptr = 0;
+				    _bfd_evax_output_counted (abfd, uname);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else if (bfd_is_abs_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd, 16) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_LW,
+							    -1);
+				    _bfd_evax_output_quad (abfd,
+							   (uquad)sym->value);
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_LW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else
+				  {
+				    if (_bfd_evax_output_check (abfd, 32) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_PQ,
+							    -1);
+				    _bfd_evax_output_long (abfd,
+							   (unsigned long)(sec->index));
+				    _bfd_evax_output_quad (abfd,
+							   ((uquad)(*rptr)->addend
+							    + (uquad)sym->value));
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_LW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+			      }
+			      break;
+
+			    case ALPHA_R_REFQUAD:
+			      {
+				if (bfd_is_und_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd,
+								strlen((char *)sym->name))
+					< 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_GBL,
+							    -1);
+				    uptr = uname;
+				    nptr = (char *)sym->name;
+				    while (*nptr)
+				      {
+					if (islower (*nptr))
+					  *uptr = toupper (*nptr);
+					else
+					  *uptr = *nptr;
+					nptr++;
+					uptr++;
+				      }
+				    *uptr = 0;
+				    _bfd_evax_output_counted (abfd, uname);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else if (bfd_is_abs_section (sym->section))
+				  {
+				    if (_bfd_evax_output_check (abfd, 16) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_QW,
+							    -1);
+				    _bfd_evax_output_quad (abfd,
+							   (uquad)sym->value);
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_QW,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+				else
+				  {
+				    if (_bfd_evax_output_check (abfd, 32) < 0)
+				      {
+					end_etir_record (abfd);
+					start_etir_record (abfd,
+							   section->index,
+							   vaddr, false);
+				      }
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STA_PQ,
+							    -1);
+				    _bfd_evax_output_long (abfd,
+							   (unsigned long)(sec->index));
+				    _bfd_evax_output_quad (abfd,
+							   ((uquad)(*rptr)->addend
+							    + (uquad)sym->value));
+				    _bfd_evax_output_flush (abfd);
+				    _bfd_evax_output_begin (abfd,
+							    ETIR_S_C_STO_OFF,
+							    -1);
+				    _bfd_evax_output_flush (abfd);
+				  }
+			      }
+			      break;
+
+			    case ALPHA_R_HINT:
+			      {
+				int hint_size;
+
+				hint_size = sptr->size;
+				sptr->size = len;
+				sto_imm (abfd, sptr, vaddr, section->index);
+				sptr->size = hint_size;
+#if 0
+				evax_output_begin(abfd, ETIR_S_C_STO_HINT_GBL, -1);
+				evax_output_long(abfd, (unsigned long)(sec->index));
+				evax_output_quad(abfd, (uquad)addr);
+				uptr = uname;
+				nptr = (char *)(*(*rptr)->sym_ptr_ptr)->name;
+				while (*nptr)
+				  {
+				    if (islower (*nptr))
+				      *uptr = toupper (*nptr);
+				    else
+				      *uptr = *nptr;
+				    nptr++;
+				    uptr++;
+				  }
+				*uptr = 0;
+
+				evax_output_counted(abfd, uname);
+				evax_output_flush(abfd);
+#endif
+			      }
+			      break;
+#if 0
+			    case ALPHA_R_BRADDR:
+			      break;
+			    case ALPHA_R_SREL16:
+			      break;
+			    case ALPHA_R_SREL32:
+			      break;
+			    case ALPHA_R_SREL64:
+			      break;
+			    case ALPHA_R_OP_PUSH:
+			      break;
+			    case ALPHA_R_OP_STORE:
+			      break;
+			    case ALPHA_R_OP_PSUB:
+			      break;
+			    case ALPHA_R_OP_PRSHIFT:
+			      break;
+#endif
+			    case ALPHA_R_LINKAGE:
+			      {
+				if (_bfd_evax_output_check (abfd, 64) < 0)
+				  {
+				    end_etir_record (abfd);
+				    start_etir_record (abfd, section->index,
+						       vaddr, false);
+				  }
+				_bfd_evax_output_begin (abfd,
+							ETIR_S_C_STC_LP_PSB,
+							-1);
+				_bfd_evax_output_long (abfd,
+						       (unsigned long)PRIV(evax_linkage_index));
+				PRIV(evax_linkage_index) += 2;
+				uptr = uname;
+				nptr = (char *)(*(*rptr)->sym_ptr_ptr)->name;
+				while (*nptr)
+				  {
+				    if (islower (*nptr))
+				      *uptr = toupper (*nptr);
+				    else
+				      *uptr = *nptr;
+				    nptr++;
+				    uptr++;
+				  }
+				*uptr = 0;
+				_bfd_evax_output_counted (abfd, uname);
+				_bfd_evax_output_byte (abfd, 0);
+				_bfd_evax_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++;
+			    }
+			}
+		      else					/* sptr starts after reloc */
+			{
+			  i--;				/* check next reloc */
+			  rptr++;
+			}
+
+		      if (i==0)				/* all reloc checked */
+			{
+			  if (sptr->size > 0)
+			    {
+			      sto_imm (abfd, sptr, vaddr, section->index);	/* dump rest */
+			      vaddr += sptr->size;
+			    }
+			  break;
+			}
+		    } /* for (;;) */
+		} /* if SEC_RELOC */
+	      else						/* no relocs, just dump */
+		{
+		  sto_imm (abfd, sptr, vaddr, section->index);
+		  vaddr += sptr->size;
+		}
+
+	      sptr = sptr->next;
+
+	    } /* while (sptr != 0) */
+
+	  end_etir_record (abfd);
+
+	} /* has_contents */
+
+      section = section->next;
+    }
+
+  _bfd_evax_output_alignment(abfd, 2);
+  return 0;
+}
+
+
+/* write traceback data for bfd abfd  */
+
+int
+_bfd_evax_write_etbt (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_etbt(%p)\n", abfd);
+#endif
+
+  return 0;
+}
+
+
+/* write debug info for bfd abfd  */
+
+int
+_bfd_evax_write_edbg (abfd)
+     bfd *abfd;
+{
+#if EVAX_DEBUG
+  evax_debug (2, "evax_write_edbg(%p)\n", abfd);
+#endif
+
+  return 0;
+}