Commit the gas and ld portions for the mvme88k port.

5 files changed, 2256 insertions, 0 deletions

diff --git a/gnu/usr.bin/gas/config/Makefile.mvme88k b/gnu/usr.bin/gas/config/Makefile.mvme88k
new file mode 100644
index 00000000000..79ba9099b30
--- /dev/null
+++ b/gnu/usr.bin/gas/config/Makefile.mvme88k
@@ -0,0 +1,5 @@
+#	from: @(#)Makefile.hp300	6.1 (Berkeley) 3/3/91
+#	$Id: Makefile.mvme88k,v 1.1 1997/04/23 21:24:39 rahnds Exp $
+
+#CFLAGS+=	-DPIC
+SRCS+=		tc-mvme88k.c atof-ieee.c
diff --git a/gnu/usr.bin/gas/config/tc-mvme88k.c b/gnu/usr.bin/gas/config/tc-mvme88k.c
new file mode 100644
index 00000000000..8ad422b7035
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-mvme88k.c
@@ -0,0 +1,1435 @@
+/* m88k.c -- Assembler for the Motorola 88000
+   Contributed by Devon Bowen of Buffalo University
+   and Torbjorn Granlund of the Swedish Institute of Computer Science.
+   Copyright (C) 1989-1992 Free Software Foundation, Inc.
+
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS 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, or (at your option)
+   any later version.
+   
+   GAS 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 GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include "as.h"
+#include "opcode/m88k.h"
+
+struct m88k_insn
+{
+  unsigned long opcode;
+  expressionS exp;
+  enum reloc_type reloc;
+};
+
+#if __STDC__ == 1
+
+static int calcop(struct m88k_opcode *format, char *param, struct m88k_insn *insn);
+
+#else /* not __STDC__ */
+
+static int calcop();
+
+#endif /* not __STDC__ */
+
+char *getval ();
+char *get_reg ();
+char *get_imm16 ();
+char *get_bf ();
+char *get_pcr ();
+char *get_cmp ();
+char *get_cnd ();
+char *get_cr ();
+char *get_fcr ();
+char *get_vec9 ();
+
+struct field_val_assoc
+{
+  char *name;
+  unsigned val;
+};
+
+struct field_val_assoc cr_regs[] =
+{
+  {"PID", 0},
+  {"PSR", 1},
+  {"EPSR", 2},
+  {"SSBR", 3},
+  {"SXIP", 4},
+  {"SNIP", 5},
+  {"SFIP", 6},
+  {"VBR", 7},
+  {"DMT0", 8},
+  {"DMD0", 9},
+  {"DMA0", 10},
+  {"DMT1", 11},
+  {"DMD1", 12},
+  {"DMA1", 13},
+  {"DMT2", 14},
+  {"DMD2", 15},
+  {"DMA2", 16},
+  {"SR0", 17},
+  {"SR1", 18},
+  {"SR2", 19},
+  {"SR3", 20},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc fcr_regs[] =
+{
+  {"FPECR", 0},
+  {"FPHS1", 1},
+  {"FPLS1", 2},
+  {"FPHS2", 3},
+  {"FPLS2", 4},
+  {"FPPT", 5},
+  {"FPRH", 6},
+  {"FPRL", 7},
+  {"FPIT", 8},
+
+  {"FPSR", 62},
+  {"FPCR", 63},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc cmpslot[] =
+{
+/* Integer  Floating point */
+		{"nc", 0},
+		{"cp", 1},
+  {"eq", 2},
+  {"ne", 3},
+  {"gt", 4},
+  {"le", 5},
+  {"lt", 6},
+  {"ge", 7},
+  {"hi", 8},	{"ou", 8},
+  {"ls", 9},	{"ib", 9},
+  {"lo", 10},	{"in", 10},
+  {"hs", 11},	{"ob", 11},
+
+  {NULL, 0},
+};
+
+struct field_val_assoc cndmsk[] =
+{
+  {"gt0", 1},
+  {"eq0", 2},
+  {"ge0", 3},
+  {"lt0", 12},
+  {"ne0", 13},
+  {"le0", 14},
+
+  {NULL, 0},
+};
+
+extern char *myname;
+static struct hash_control *op_hash = NULL;
+
+/* These bits should be turned off in the first address of every segment */
+int md_seg_align = 7;
+
+/* This is the number to put at the beginning of the a.out file */
+long omagic = OMAGIC;
+
+/* These chars start a comment anywhere in a source file (except inside
+   another comment */
+const char comment_chars[] = "#|";
+
+/* These chars only start a comment at the beginning of a line. */
+const char line_comment_chars[] = ";";
+
+/* Chars that can be used to separate mant from exp in floating point nums */
+char EXP_CHARS[] = "eE";
+
+/* Chars that mean this number is a floating point constant */
+/* as in 0f123.456 */
+/* or    0H1.234E-12 (see exp chars above) */
+char FLT_CHARS[] = "dDfF";
+
+extern void float_cons (), cons (), s_globl (), s_line (),
+  s_space (), s_set (), stringer (), s_lcomm ();
+static void s_bss ();
+
+const pseudo_typeS md_pseudo_table[] = {
+	{"align", s_align_bytes, 0 },
+	{"def", s_set, 0},
+	{"dfloat", float_cons, 'd'},
+	{"ffloat", float_cons, 'f'},
+	{"global", s_globl, 0},
+	{"half", cons, 2 },
+	{"bss", s_bss, 0},
+	{"string", stringer, 0},
+	{"word", cons, 4 },
+	{"zero", s_space, 0},
+	{0}
+};
+
+const int md_reloc_size = 12; /* Size of relocation record */
+
+void
+md_begin ()
+{
+  char *retval = NULL;
+  unsigned int i = 0;
+
+  /* initialize hash table */
+
+  op_hash = hash_new ();
+  if (op_hash == NULL)
+    as_fatal ("Could not initialize hash table");
+
+  /* loop until you see the end of the list */
+
+  while (*m88k_opcodes[i].name)
+    {
+      char *name = m88k_opcodes[i].name;
+
+      /* hash each mnemonic and record its position */
+
+      retval = hash_insert (op_hash, name, &m88k_opcodes[i]);
+
+      if (retval != NULL && *retval != '\0')
+	as_fatal ("Can't hash instruction '%s':%s",
+		 m88k_opcodes[i].name, retval);
+
+      /* skip to next unique mnemonic or end of list */
+
+      for (i++; !strcmp (m88k_opcodes[i].name, name); i++)
+	;
+    }
+}
+
+int
+md_parse_option (argP, cntP, vecP)
+     char **argP;
+     int *cntP;
+     char ***vecP;
+{
+	as_warn ("unknown option: -%s", *argP);
+	return(0);
+}
+
+void
+md_assemble (op)
+     char *op;
+{
+  char *param, *thisfrag;
+  struct m88k_opcode *format;
+  struct m88k_insn insn;
+
+  assert (op);
+
+  /* skip over instruction to find parameters */
+
+  for (param = op; *param != 0 && !isspace (*param); param++)
+    ;
+  if (*param != 0)
+    *param++ = 0;
+
+  /* try to find the instruction in the hash table */
+
+  if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL)
+    {
+      as_fatal ("Invalid mnemonic '%s'", op);
+      return;
+    }
+
+  /* try parsing this instruction into insn */
+
+  insn.exp.X_add_symbol = 0;
+  insn.exp.X_subtract_symbol = 0;
+  insn.exp.X_add_number = 0;
+  insn.exp.X_seg = 0;
+  insn.reloc = NO_RELOC;
+
+  while (!calcop(format, param, &insn))
+    {
+      /* if it doesn't parse try the next instruction */
+
+      if (!strcmp (format[0].name, format[1].name))
+	format++;
+      else
+	{
+	  as_fatal ("Parameter syntax error");
+	  return;
+	}
+    }
+
+  /* grow the current frag and plop in the opcode */
+
+  thisfrag = frag_more (4);
+  md_number_to_chars (thisfrag, insn.opcode, 4);
+
+  /* if this instruction requires labels mark it for later */
+
+  switch (insn.reloc)
+    {
+    case NO_RELOC:
+      break;
+
+    case RELOC_LO16:
+    case RELOC_HI16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal + 2,
+	       2,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       0,
+	       insn.reloc);
+      break;
+
+    case RELOC_IW16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal,
+	       4,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       0,
+	       insn.reloc);
+      break;
+
+    case RELOC_PC16:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal + 2,
+	       2,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       1,
+	       insn.reloc);
+      break;
+
+    case RELOC_PC26:
+      fix_new (frag_now,
+	       thisfrag - frag_now->fr_literal,
+	       4,
+	       insn.exp.X_add_symbol,
+	       insn.exp.X_subtract_symbol,
+	       insn.exp.X_add_number,
+	       1,
+	       insn.reloc);
+      break;
+
+    default:
+      as_fatal ("Unknown relocation type");
+      break;
+    }
+}
+
+int
+calcop (format, param, insn)
+     struct m88k_opcode *format;
+     char *param;
+     struct m88k_insn *insn;
+{
+  char *fmt = format->op_spec;
+  int f;
+  unsigned val;
+  unsigned opcode;
+
+  insn->opcode = format->opcode;
+  opcode = 0;
+
+  for (;;)
+    {
+      if (param == 0)
+	return 0;
+      f = *fmt++;
+      switch (f)
+	{
+	case 0:
+	  insn->opcode |= opcode;
+	  return *param == 0;
+
+	default:
+	  if (f != *param++)
+	    return 0;
+	  break;
+
+	case 'd':
+	  param = get_reg (param, &val);
+	  opcode |= val << 21;
+	  break;
+
+	case '1':
+	  param = get_reg (param, &val);
+	  opcode |= val << 16;
+	  break;
+
+	case '2':
+	  param = get_reg (param, &val);
+	  opcode |= val;
+	  break;
+
+	case '3':
+	  param = get_reg (param, &val);
+	  opcode |= (val << 16) | val;
+	  break;
+
+	case 'I':
+	  param = get_imm16 (param, insn);
+	  break;
+
+	case 'b':
+	  param = get_bf (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'p':
+	  param = get_pcr (param, insn, RELOC_PC16);
+	  break;
+
+	case 'P':
+	  param = get_pcr (param, insn, RELOC_PC26);
+	  break;
+
+	case 'B':
+	  param = get_cmp (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'M':
+	  param = get_cnd (param, &val);
+	  opcode |= val;
+	  break;
+
+	case 'c':
+	  param = get_cr (param, &val);
+	  opcode |= val << 5;
+	  break;
+
+	case 'f':
+	  param = get_fcr (param, &val);
+	  opcode |= val << 5;
+	  break;
+
+	case 'V':
+	  param = get_vec9 (param, &val);
+	  opcode |= val;
+	  break;
+
+	case '?':
+	  /* Having this here repeats the warning somtimes.
+	   But can't we stand that?  */
+	  as_warn ("Use of obsolete instruction");
+	  break;
+	}
+    }
+}
+
+char *
+match_name (param, assoc_tab, valp)
+     char *param;
+     struct field_val_assoc *assoc_tab;
+     unsigned *valp;
+{
+  int i;
+  char *name;
+  int name_len;
+
+  for (i = 0;; i++)
+    {
+      name = assoc_tab[i].name;
+      if (name == NULL)
+	return NULL;
+      name_len = strlen (name);
+      if (!strncmp (param, name, name_len))
+	{
+	  *valp = assoc_tab[i].val;
+	  return param + name_len;
+	}
+    }
+}
+
+char *
+get_reg (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned c;
+  unsigned regno;
+
+  c = *param++;
+  if (c == 'r')
+    {
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 32)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+  else if (c == 's' && param[0] == 'p')
+    {
+      *regnop = 31;
+      return param + 1;
+    }
+
+  return 0;
+}
+
+char *
+get_imm16 (param, insn)
+     char *param;
+     struct m88k_insn *insn;
+{
+  enum reloc_type reloc = NO_RELOC;
+  unsigned int val;
+  segT seg;
+  char *save_ptr;
+
+  if (!strncmp (param, "hi16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_HI16;
+      param += 4;
+    }
+  else if (!strncmp (param, "lo16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_LO16;
+      param += 4;
+    }
+  else if (!strncmp (param, "iw16", 4) && !isalnum (param[4]))
+    {
+      reloc = RELOC_IW16;
+      param += 4;
+    }
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  seg = expression (&insn->exp);
+  param = input_line_pointer;
+  input_line_pointer = save_ptr;
+
+  val = insn->exp.X_add_number;
+
+  if (seg == SEG_ABSOLUTE)
+    {
+      /* Insert the value now, and reset reloc to NO_RELOC.  */
+      if (reloc == NO_RELOC)
+	{
+	  /* Warn about too big expressions if not surrounded by xx16.  */
+	  if (val > 0xffff)
+	    as_warn ("Expression truncated to 16 bits");
+	}
+
+      if (reloc == RELOC_HI16)
+	val >>= 16;
+
+      insn->opcode |= val & 0xffff;
+      reloc = NO_RELOC;
+    }
+  else if (reloc == NO_RELOC)
+    /* We accept a symbol even without lo16, hi16, etc, and assume
+       lo16 was intended.  */
+    reloc = RELOC_LO16;
+
+  insn->reloc = reloc;
+
+  return param;
+}
+
+char *
+get_pcr (param, insn, reloc)
+     char *param;
+     struct m88k_insn *insn;
+     enum reloc_type reloc;
+{
+  char *saveptr, *saveparam;
+  segT seg;
+
+  saveptr = input_line_pointer;
+  input_line_pointer = param;
+
+  seg = expression (&insn->exp);
+
+  saveparam = input_line_pointer;
+  input_line_pointer = saveptr;
+
+  /* Botch: We should relocate now if SEG_ABSOLUTE.  */
+  insn->reloc = reloc;
+
+  return saveparam;
+}
+
+char *
+get_cmp (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned int val;
+  char *save_ptr;
+
+  save_ptr = param;
+
+  param = match_name (param, cmpslot, valp);
+  val = *valp;
+
+  if (param == NULL)
+    {
+      param = save_ptr;
+
+      save_ptr = input_line_pointer;
+      input_line_pointer = param;
+      val = get_absolute_expression ();
+      param = input_line_pointer;
+      input_line_pointer = save_ptr;
+
+      if (val >= 32)
+	{
+	  as_warn ("Expression truncated to 5 bits");
+	  val %= 32;
+	}
+    }
+
+  *valp = val << 21;
+  return param;
+}
+
+char *
+get_cnd (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned int val;
+
+  if (isdigit (*param))
+    {
+      param = getval (param, &val);
+
+      if (val >= 32)
+	{
+	  as_warn ("Expression truncated to 5 bits");
+	  val %= 32;
+	}
+    }
+  else
+    {
+      if (isupper (*param))
+	*param = tolower (*param);
+
+      if (isupper (param[1]))
+	param[1] = tolower (param[1]);
+
+      param = match_name (param, cndmsk, valp);
+
+      if (param == NULL)
+	return NULL;
+
+      val = *valp;
+    }
+
+  *valp = val << 21;
+  return param;
+}
+
+char *
+get_bf2 (param, bc)
+     char *param;
+     int bc;
+{
+  int depth = 0;
+  int c;
+
+  for (;;)
+    {
+      c = *param;
+      if (c == 0)
+	return param;
+      else if (c == '(')
+	depth++;
+      else if (c == ')')
+	depth--;
+      else if (c == bc && depth <= 0)
+	return param;
+      param++;
+    }
+}
+
+char *
+get_bf_offset_expression (param, offsetp)
+     char *param;
+     unsigned *offsetp;
+{
+  unsigned offset;
+
+  if (isalpha (param[0]))
+    {
+      if (isupper (param[0]))
+	param[0] = tolower (param[0]);
+      if (isupper (param[1]))
+	param[1] = tolower (param[1]);
+
+      param = match_name (param, cmpslot, offsetp);
+
+      return param;
+    }
+  else
+    {
+      input_line_pointer = param;
+      offset = get_absolute_expression ();
+      param = input_line_pointer;
+    }
+
+  *offsetp = offset;
+  return param;
+}
+
+char *
+get_bf (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned offset = 0;
+  unsigned width = 0;
+  char *xp;
+  char *save_ptr;
+
+  xp = get_bf2 (param, '<');
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  if (*xp == 0)
+    {
+      /* We did not find '<'.  We have an offset (width implicitly 32).  */
+      param = get_bf_offset_expression (param, &offset);
+      if (param == NULL)
+	return NULL;
+      input_line_pointer = save_ptr;
+    }
+  else
+    {
+      *xp++ = 0;		/* Overwrite the '<' */
+      param = get_bf2 (xp, '>');
+      if (*param == 0)
+	return NULL;
+      *param++ = 0;		/* Overwrite the '>' */
+
+      width = get_absolute_expression ();
+      xp =  get_bf_offset_expression (xp, &offset);
+      input_line_pointer = save_ptr;
+
+      if (xp + 1 != param)
+	return NULL;
+    }
+
+  *valp = ((width % 32) << 5) | (offset % 32);
+
+  return param;
+}
+
+char *
+get_cr (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned regno;
+  unsigned c;
+/*  int i; FIXME remove this */
+/*  int name_len; FIXME remove this */
+
+  if (!strncmp (param, "cr", 2))
+    {
+      param += 2;
+
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 64)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+
+  param = match_name (param, cr_regs, regnop);
+
+  return param;
+}
+
+char *
+get_fcr (param, regnop)
+     char *param;
+     unsigned *regnop;
+{
+  unsigned regno;
+  unsigned c;
+/*  int i; FIXME remove this */
+/*  int name_len; FIXME: remove this */
+
+  if (!strncmp (param, "fcr", 3))
+    {
+      param += 3;
+
+      regno = *param++ - '0';
+      if (regno < 10)
+	{
+	  if (regno == 0)
+	    {
+	      *regnop = 0;
+	      return param;
+	    }
+	  c = *param - '0';
+	  if (c < 10)
+	    {
+	      regno = regno * 10 + c;
+	      if (c < 64)
+		{
+		  *regnop = regno;
+		  return param + 1;
+		}
+	    }
+	  else
+	    {
+	      *regnop = regno;
+	      return param;
+	    }
+	}
+      return NULL;
+    }
+
+  param = match_name (param, fcr_regs, regnop);
+
+  return param;
+}
+
+char *
+get_vec9 (param, valp)
+     char *param;
+     unsigned *valp;
+{
+  unsigned val;
+  char *save_ptr;
+
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  val = get_absolute_expression ();
+  param = input_line_pointer;
+  input_line_pointer = save_ptr;
+
+  if (val >= 1 << 9)
+    as_warn ("Expression truncated to 9 bits");
+
+  *valp = val % (1 << 9);
+
+  return param;
+}
+  
+#define hexval(z) \
+  (isdigit (z) ? (z) - '0' :						\
+   islower (z) ? (z) - 'a' + 10 : 					\
+   isupper (z) ? (z) - 'A' + 10 : -1)
+
+char *
+getval (param, valp)
+     char *param;
+     unsigned int *valp;
+{
+  unsigned int val = 0;
+  unsigned int c;
+
+  c = *param++;
+  if (c == '0')
+    {
+      c = *param++;
+      if (c == 'x' || c == 'X')
+	{
+	  c = *param++;
+	  c = hexval (c);
+	  while (c < 16)
+	    {
+	      val = val * 16 + c;
+	      c = *param++;
+	      c = hexval (c);
+	    }
+	}
+      else
+	{
+	  c -= '0';
+	  while (c < 8)
+	    {
+	      val = val * 8 + c;
+	      c = *param++ - '0';
+	    }
+	}
+    }
+  else
+    {
+      c -= '0';
+      while (c < 10)
+	{
+	  val = val * 10 + c;
+	  c = *param++ - '0';
+	}
+    }
+
+  *valp = val;
+  return param - 1;
+}
+
+void
+md_number_to_chars (buf, val, nbytes)
+char *buf;
+long val;
+int nbytes;
+{
+  switch (nbytes)
+    {
+    case 4:
+      *buf++ = val >> 24;
+      *buf++ = val >> 16;
+    case 2:
+      *buf++ = val >> 8;
+    case 1:
+      *buf = val;
+      break;
+
+    default:
+      abort ();
+    }
+}
+
+#ifdef comment
+
+void
+md_number_to_imm (buf, val, nbytes, fixP, seg_type)
+unsigned char *buf;
+unsigned int val;
+int nbytes;
+fixS *fixP;
+int seg_type;
+{
+  if (seg_type != N_TEXT || fixP->fx_r_type == NO_RELOC)
+    {
+      switch (nbytes)
+	{
+	case 4:
+	  *buf++ = val >> 24;
+	  *buf++ = val >> 16;
+	case 2:
+	  *buf++ = val >> 8;
+	case 1:
+	  *buf = val;
+	  break;
+
+	default:
+	  abort ();
+	}
+      return;
+    }
+
+  switch (fixP->fx_r_type)
+    {
+    case RELOC_IW16:
+      buf[2] = val >> 8;
+      buf[3] = val;
+      break;
+
+    case RELOC_LO16:
+      buf[0] = val >> 8;
+      buf[1] = val;
+      break;
+
+    case RELOC_HI16:
+      buf[0] = val >> 24;
+      buf[1] = val >> 16;
+      break;
+
+    case RELOC_PC16:
+      val += 4;
+      buf[0] = val >> 10;
+      buf[1] = val >> 2;
+      break;
+
+    case RELOC_PC26:
+      val += 4;
+      buf[0] |= (val >> 26) & 0x03;
+      buf[1] = val >> 18;
+      buf[2] = val >> 10;
+      buf[3] = val >> 2;
+      break;
+
+    case RELOC_32:
+      buf[0] = val >> 24;
+      buf[1] = val >> 16;
+      buf[2] = val >> 8;
+      buf[3] = val;
+      break;
+
+    default:
+      as_fatal ("Bad relocation type");
+      break;
+    }
+}
+#endif /* comment */
+
+/* Apply a fixS to the frags, now that we know the value it ought to
+   hold. */
+
+void md_apply_fix(fixP, val)
+fixS *fixP;
+long val;
+{
+	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+	
+	fixP->fx_addnumber = val;
+	
+	
+	switch (fixP->fx_r_type) {
+		
+	case RELOC_IW16:
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case RELOC_LO16:
+		buf[0] = val >> 8;
+		buf[1] = val;
+		break;
+		
+	case RELOC_HI16:
+		buf[0] = val >> 24;
+		buf[1] = val >> 16;
+		break;
+		
+	case RELOC_PC16:
+		val += 4;
+		buf[0] = val >> 10;
+		buf[1] = val >> 2;
+		break;
+		
+	case RELOC_PC26:
+		val += 4;
+		buf[0] |= (val >> 26) & 0x03;
+		buf[1] = val >> 18;
+		buf[2] = val >> 10;
+		buf[3] = val >> 2;
+		break;
+		
+	case RELOC_32:
+		buf[0] = val >> 24;
+		buf[1] = val >> 16;
+		buf[2] = val >> 8;
+		buf[3] = val;
+		break;
+		
+	case NO_RELOC:
+		switch (fixP->fx_size) {
+		case 4:
+			*buf++ = val >> 24;
+			*buf++ = val >> 16;
+		case 2:
+			*buf++ = val >> 8;
+		case 1:
+			*buf = val;
+			break;
+			
+		default:
+			abort ();
+		}
+		
+	default:
+		as_bad("bad relocation type: 0x%02x", fixP->fx_r_type);
+		break;
+	}
+	
+	return;
+} /* md_apply_fix() */
+
+void
+md_number_to_disp (buf, val, nbytes)
+char *buf;
+int val;
+int nbytes;
+{
+  as_fatal ("md_number_to_disp not defined");
+  md_number_to_chars (buf, val, nbytes);
+}
+
+void
+md_number_to_field (buf, val, nbytes)
+char *buf;
+int val;
+int nbytes;
+{
+  as_fatal ("md_number_to_field not defined");
+  md_number_to_chars (buf, val, nbytes);
+}
+
+#define MAX_LITTLENUMS 6
+
+/* Turn a string in input_line_pointer into a floating point constant of type
+   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
+   emitted is stored in *sizeP. An error message is returned, or NULL on OK.
+ */
+char *
+md_atof (type, litP, sizeP)
+     char type;
+     char *litP;
+     int *sizeP;
+{
+  int	prec;
+  LITTLENUM_TYPE words[MAX_LITTLENUMS];
+  LITTLENUM_TYPE *wordP;
+  char	*t;
+  char	*atof_ieee ();
+
+  switch (type)
+    {
+    case 'f':
+    case 'F':
+    case 's':
+    case 'S':
+      prec = 2;
+      break;
+
+    case 'd':
+    case 'D':
+    case 'r':
+    case 'R':
+      prec = 4;
+      break;
+
+    case 'x':
+    case 'X':
+      prec = 6;
+      break;
+
+    case 'p':
+    case 'P':
+      prec = 6;
+      break;
+
+    default:
+      *sizeP=0;
+      return "Bad call to MD_ATOF()";
+    }
+  t=atof_ieee (input_line_pointer, type, words);
+  if (t)
+    input_line_pointer=t;
+
+  *sizeP=prec * sizeof (LITTLENUM_TYPE);
+  for (wordP=words;prec--;)
+    {
+      md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
+      litP+=sizeof (LITTLENUM_TYPE);
+    }
+  return "";	/* Someone should teach Dean about null pointers */
+}
+
+int md_short_jump_size = 4;
+
+void
+md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00;
+  fix_new (frag,
+	   ptr - frag->fr_literal,
+	   4,
+	   to_symbol,
+	   (symbolS *) 0,
+	   (long int) 0,
+	   0,
+	   RELOC_PC26);		/* Botch: Shouldn't this be RELOC_PC16? */
+}
+
+int md_long_jump_size = 4;
+
+void
+md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
+     char *ptr;
+     long from_addr, to_addr;
+     fragS *frag;
+     symbolS *to_symbol;
+{
+  ptr[0] = 0xc0; ptr[1] = 0x00; ptr[2] = 0x00; ptr[3] = 0x00;
+  fix_new (frag,
+	   ptr - frag->fr_literal,
+	   4,
+	   to_symbol,
+	   (symbolS *) 0,
+	   (long int) 0,
+	   0,
+	   RELOC_PC26);
+}
+
+int
+md_estimate_size_before_relax (fragP, segment_type)
+     fragS *fragP;
+     segT segment_type;
+{
+	as_fatal("Relaxation should never occur");
+	return(0);
+}
+
+const relax_typeS md_relax_table[] = {0};
+
+void
+md_convert_frag (headers, fragP)
+object_headers *headers;
+     fragS *fragP;
+{
+  as_fatal ("Relaxation should never occur");
+}
+
+void
+md_end ()
+{
+}
+
+#ifdef comment
+
+/*
+ * Risc relocations are completely different, so it needs
+ * this machine dependent routine to emit them.
+ */
+void
+emit_relocations (fixP, segment_address_in_file)
+    fixS *fixP;
+    relax_addressT segment_address_in_file;
+{
+    struct reloc_info_m88k ri;
+    symbolS *symbolP;
+    extern char *next_object_file_charP;
+
+    bzero ((char *) &ri, sizeof (ri));
+    for (; fixP; fixP = fixP->fx_next) {
+
+	if (fixP->fx_r_type >= NO_RELOC) {
+	    fprintf (stderr, "fixP->fx_r_type = %d\n", fixP->fx_r_type);
+	    abort ();
+	}
+
+	if ((symbolP = fixP->fx_addsy) != NULL) {
+	    ri.r_address = fixP->fx_frag->fr_address +
+	        fixP->fx_where - segment_address_in_file;
+	    if ((symbolP->sy_type & N_TYPE) == N_UNDF) {
+		ri.r_extern = 1;
+		ri.r_symbolnum = symbolP->sy_number;
+	    } else {
+		ri.r_extern = 0;
+		ri.r_symbolnum = symbolP->sy_type & N_TYPE;
+	    }
+	    if (symbolP && symbolP->sy_frag) {
+		ri.r_addend = symbolP->sy_frag->fr_address;
+	    }
+	    ri.r_type = fixP->fx_r_type;
+	    if (fixP->fx_pcrel) {
+/*		ri.r_addend -= fixP->fx_where;          */
+		ri.r_addend -= ri.r_address;            
+	    } else {
+		ri.r_addend = fixP->fx_addnumber;
+	    }
+
+/*	    md_ri_to_chars ((char *) &ri, ri);        */
+	    append (&next_object_file_charP, (char *)& ri, sizeof (ri));
+	}
+    }
+    return;
+}
+#endif /* comment */
+
+/* Translate internal representation of relocation info to target format.
+   
+   On m88k: first 4 bytes are normal unsigned long address,
+   next three bytes are index, most sig. byte first.
+   Byte 7 is broken up with bit 7 as external,
+   	bits 6, 5, & 4 unused, and the lower four bits as relocation
+	type.
+   Next 4 bytes are long addend. */
+
+void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
+char *where;
+fixS *fixP;
+relax_addressT segment_address_in_file;
+{
+	long r_index;
+	long r_extern;
+	long r_addend = 0;
+	long r_address;
+	
+	know(fixP->fx_addsy);
+	
+	if (!S_IS_DEFINED(fixP->fx_addsy)) {
+		r_extern = 1;
+		r_index = fixP->fx_addsy->sy_number;
+	} else {
+		r_extern = 0;
+		r_index = S_GET_TYPE(fixP->fx_addsy);
+	}
+	
+	/* this is easy */
+	md_number_to_chars(where,
+			   r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+			   4);
+	
+	/* now the fun stuff */
+	where[4] = (r_index >> 16) & 0x0ff;
+	where[5] = (r_index >> 8) & 0x0ff;
+	where[6] = r_index & 0x0ff;
+	where[7] = ((r_extern << 7)  & 0x80) | (0 & 0x70) | (fixP->fx_r_type & 0xf);
+	
+	/* Also easy */
+	if (fixP->fx_addsy->sy_frag) {
+		r_addend = fixP->fx_addsy->sy_frag->fr_address;
+	}
+	
+	if (fixP->fx_pcrel) {
+		r_addend -= r_address;
+	} else {
+		r_addend = fixP->fx_addnumber;
+	}
+	
+	md_number_to_chars(&where[8], r_addend, 4);
+	
+	return;
+} /* tc_aout_fix_to_chars() */
+
+
+static void
+s_bss()
+{
+  char *name;
+  char c;
+  char *p;
+  int temp, bss_align = 1;
+  symbolS *symbolP;
+  extern char is_end_of_line[256];
+
+  name = input_line_pointer;
+  c = get_symbol_end();
+  p = input_line_pointer;
+  *p = c;
+  SKIP_WHITESPACE();
+  if ( * input_line_pointer != ',' )
+    {
+      as_warn("Expected comma after name");
+      ignore_rest_of_line();
+      return;
+    }
+  input_line_pointer ++;
+  if ((temp = get_absolute_expression()) < 0)
+    {
+      as_warn("BSS length (%d.) <0! Ignored.", temp);
+      ignore_rest_of_line();
+      return;
+    }
+  *p = 0;
+  symbolP = symbol_find_or_make(name);
+  *p = c;
+  if (*input_line_pointer == ',')
+    {
+      input_line_pointer++;
+      bss_align = get_absolute_expression();
+      while (local_bss_counter % bss_align != 0)
+	local_bss_counter++;
+    }
+
+  if (!S_IS_DEFINED(symbolP)
+      || (S_GET_SEGMENT(symbolP) == SEG_BSS
+	  && S_GET_VALUE(symbolP) == local_bss_counter)) {
+	  S_SET_VALUE(symbolP, local_bss_counter);
+	  S_SET_SEGMENT(symbolP, SEG_BSS);
+	  symbolP->sy_frag  = &bss_address_frag;
+	  local_bss_counter += temp;
+  } else {
+	  as_warn( "Ignoring attempt to re-define symbol from %d. to %d.",
+		  S_GET_VALUE(symbolP), local_bss_counter );
+  }
+  while (!is_end_of_line[*input_line_pointer])
+    {
+      input_line_pointer++;
+    }
+
+  return;
+}
+
+/* We have no need to default values of symbols. */
+
+/* ARGSUSED */
+symbolS *md_undefined_symbol(name)
+char *name;
+{
+	return 0;
+} /* md_undefined_symbol() */
+
+/* Parse an operand that is machine-specific.
+   We just return without modifying the expression if we have nothing
+   to do. */
+
+/* ARGSUSED */
+void md_operand(expressionP)
+expressionS *expressionP;
+{
+} /* md_operand() */
+
+/* Round up a section size to the appropriate boundary. */
+long md_section_align(segment, size)
+segT segment;
+long size;
+{
+	return((size + 7) & ~7); /* Round all sects to multiple of 8 */
+} /* md_section_align() */
+
+/* Exactly what point is a PC-relative offset relative TO?
+   On the sparc, they're relative to the address of the offset, plus
+   its size.  This gets us to the following instruction.
+   (??? Is this right?  FIXME-SOON) */
+long md_pcrel_from(fixP)
+fixS *fixP;
+{
+	return(fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address);
+} /* md_pcrel_from() */
+
+ /* end of tc-m88k.c */
diff --git a/gnu/usr.bin/gas/config/tc-mvme88k.h b/gnu/usr.bin/gas/config/tc-mvme88k.h
new file mode 100644
index 00000000000..510b68703a1
--- /dev/null
+++ b/gnu/usr.bin/gas/config/tc-mvme88k.h
@@ -0,0 +1,42 @@
+/* m88k.h -- Assembler for the Motorola 88000
+   Contributed by Devon Bowen of Buffalo University
+   and Torbjorn Granlund of the Swedish Institute of Computer Science.
+   Copyright (C) 1989-1992 Free Software Foundation, Inc.
+
+   This file is part of GAS, the GNU Assembler.
+   
+   GAS 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, or (at your option)
+   any later version.
+   
+   GAS 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 GAS; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#define TC_M88K 1
+
+#define MID_M88K        151
+
+#define AOUT_MACHTYPE MID_M88K
+#define LOCAL_LABELS_FB
+
+#define NO_LISTING
+#define NO_DOT_PSEUDOS
+
+#define ALLOW_ATSIGN
+#define AT 3
+/* m88k allows @ as the first char in a local label */
+#define LOCAL_LABEL(name) (name[0] == '@' \
+			   && ( name[1] == 'L' || name[1] == '.' ))
+
+#define tc_crawl_symbol_chain(a)	{;} /* not used */
+#define tc_headers_hook(a)		{;} /* not used */
+#define tc_aout_pre_write_hook(x)	{;} /* not used */
+
+ /* end of tc-m88k.h */
diff --git a/gnu/usr.bin/ld/mvme88k/md.c b/gnu/usr.bin/ld/mvme88k/md.c
new file mode 100644
index 00000000000..20c6a53ca9c
--- /dev/null
+++ b/gnu/usr.bin/ld/mvme88k/md.c
@@ -0,0 +1,511 @@
+/*
+ * Copyright (c) 1993 Paul Kranenburg
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Paul Kranenburg.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *	$Id: md.c,v 1.1 1997/04/23 21:24:41 rahnds Exp $
+ */
+
+#include <sys/param.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <a.out.h>
+#include <stab.h>
+#include <string.h>
+
+#include "ld.h"
+
+/*
+ * Get relocation addend corresponding to relocation record RP
+ * from address ADDR
+ */
+long
+md_get_addend(rp, addr)
+struct relocation_info_m88k	*rp;
+unsigned char		*addr;
+{
+	return rp->r_addend;
+}
+
+/*
+ * Put RELOCATION at ADDR according to relocation record RP.
+ */
+void
+md_relocate(rp, relocation, addr, relocatable_output)
+struct relocation_info_m88k	*rp;
+long			relocation;
+unsigned char		*addr;
+{
+	if (relocatable_output) {
+		/*
+		 * Store relocation where the next link-edit run
+		 * will look for it.
+		 */
+		rp->r_addend = relocation;
+		return;
+	}
+
+	switch ((rp->r_type)) {
+	case RELOC_LO16:
+		put_short(addr,relocation & 0xffff);
+		break;
+	case RELOC_HI16:
+		put_short(addr,(relocation >>16) & 0xffff);
+		break;
+	case RELOC_PC16:
+		put_short(addr,(relocation)>>2);
+		break;
+	case RELOC_PC26:
+		put_b26(addr,(relocation)>>2);
+		break;
+	case RELOC_32:
+		put_long(addr,relocation);
+		break;
+	case RELOC_IW16:
+		printf ("oops\n"); exit(100);
+		break;
+	case NO_RELOC:
+		break;
+	case RELOC_GLOB_DAT:
+		put_long(addr,relocation);
+		break;
+/*
+	case RELOC_JMP_SLOT:
+		md_make_jmpslot(addr,,
+		break;
+*/
+	case RELOC_RELATIVE: 
+	printf("reloc_rel not supported %x\n",addr);
+	exit (15);
+		break;
+
+	default:
+		errx(1, "Unsupported relocation size: %x",
+		     (rp->r_type));
+	}
+#ifdef RTLD
+	_cachectl (addr, RELOC_TARGET_SIZE(rp)); /* maintain cache coherency */
+#endif
+}
+
+/*
+ * Machine dependent part of claim_rrs_reloc().
+ * Set RRS relocation type.
+ */
+int
+md_make_reloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+	r->r_address = rp->r_address;
+	r->r_type = rp->r_type;
+	r->r_jmptable = rp->r_jmptable;
+	r->r_pcrel = rp->r_pcrel;
+	r->r_baserel = rp->r_baserel;
+	r->r_extern = rp->r_extern;
+	r->r_symbolnum = rp->r_symbolnum;
+	r->r_addend = rp->r_addend;
+
+	return 0;
+}
+
+/*
+ * Set up a transfer from jmpslot at OFFSET (relative to the PLT table)
+ * to the binder slot (which is at offset 0 of the PLT).
+ */
+void
+md_make_jmpslot(sp, offset, index)
+jmpslot_t	*sp;
+long		offset;
+long		index;
+{
+	/*
+	 * On m68k machines, a long branch offset is relative to
+	 * the address of the offset.
+	 */
+	u_long	fudge = - (sizeof(sp->opcode) + offset);
+
+	sp->opcode = BSRL;
+	sp->addr[0] = fudge >> 16;
+	sp->addr[1] = fudge;
+	sp->reloc_index = index;
+#ifdef RTLD
+	_cachectl (sp, 6);		/* maintain cache coherency */
+#endif
+}
+
+/*
+ * Set up a "direct" transfer (ie. not through the run-time binder) from
+ * jmpslot at OFFSET to ADDR. Used by `ld' when the SYMBOLIC flag is on,
+ * and by `ld.so' after resolving the symbol.
+ * On the m68k, we use the BRA instruction which is PC relative, so no
+ * further RRS relocations will be necessary for such a jmpslot.
+ */
+void
+md_fix_jmpslot(sp, offset, addr)
+jmpslot_t	*sp;
+long		offset;
+u_long		addr;
+{
+	u_long	fudge = addr - (sizeof(sp->opcode) + offset);
+
+	sp->opcode = BRAL;
+	sp->addr[0] = fudge >> 16;
+	sp->addr[1] = fudge;
+	sp->reloc_index = 0;
+#ifdef RTLD
+	_cachectl (sp, 6);		/* maintain cache coherency */
+#endif
+}
+
+/*
+ * Update the relocation record for a RRS jmpslot.
+ */
+void
+md_make_jmpreloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+	jmpslot_t	*sp;
+
+	/*
+	 * Fix relocation address to point to the correct
+	 * location within this jmpslot.
+	 */
+	r->r_address += sizeof(sp->opcode);
+
+#if 0
+	/* Relocation size */
+	r->r_length = 2;
+#endif
+
+	/* Set relocation type */
+	r->r_jmptable = 1;
+#if 0
+	if (type & RELTYPE_RELATIVE)
+		r->r_relative = 1;
+#endif
+
+printf("jmp reloc not supported \n");
+exit (15);
+}
+
+/*
+ * Set relocation type for a RRS GOT relocation.
+ */
+void
+md_make_gotreloc(rp, r, type)
+struct relocation_info_m88k	*rp, *r;
+int			type;
+{
+#if 0
+	r->r_baserel = 1;
+	if (type & RELTYPE_RELATIVE)
+		r->r_relative = 1;
+
+	/* Relocation size */
+	r->r_length = 2;
+#endif
+printf("got not supported \n");
+exit (15);
+}
+
+/*
+ * Set relocation type for a RRS copy operation.
+ */
+void
+md_make_cpyreloc(rp, r)
+struct relocation_info_m88k	*rp, *r;
+{
+	r->r_address = rp->r_address;
+	r->r_type = rp->r_type;
+	r->r_jmptable = rp->r_jmptable;
+	r->r_pcrel = rp->r_pcrel;
+	r->r_baserel = rp->r_baserel;
+	r->r_extern = rp->r_extern;
+	r->r_symbolnum = rp->r_symbolnum;
+	r->r_addend = rp->r_addend;
+}
+
+void
+md_set_breakpoint(where, savep)
+long	where;
+long	*savep;
+{
+	*savep = *(long *)where;
+	*(short *)where = BPT;
+}
+
+#ifndef MID_M88K
+#define MID_M88K 151
+#endif
+
+#ifndef RTLD
+/*
+ * Initialize (output) exec header such that useful values are
+ * obtained from subsequent N_*() macro evaluations.
+ */
+void
+md_init_header(hp, magic, flags)
+struct exec	*hp;
+int		magic, flags;
+{
+	if (oldmagic)
+		hp->a_midmag = oldmagic;
+	else
+		N_SETMAGIC((*hp), magic, MID_M88K, flags);
+
+	/* TEXT_START depends on the value of outheader.a_entry.  */
+	if (!(link_mode & SHAREABLE))
+		hp->a_entry = PAGSIZ;
+}
+
+/*
+ * Check for acceptable foreign machine Ids
+ */
+int
+md_midcompat(hp)
+struct exec *hp;
+{
+	int	mid = N_GETMID(*hp);
+
+	if (mid == MID_M88K )
+		return 1;
+#if 0
+	return (((md_swap_long(hp->a_midmag)&0x00ff0000) >> 16) == MID_SUN020);
+#endif
+	return 0;
+}
+#endif /* RTLD */
+
+
+#ifdef NEED_SWAP
+/*
+ * Byte swap routines for cross-linking.
+ */
+
+void
+md_swapin_exec_hdr(h)
+struct exec *h;
+{
+	int skip = 1;
+
+	if (!N_BADMAG(*h))
+		skip = 1;
+
+	swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
+}
+
+void
+md_swapout_exec_hdr(h)
+struct exec *h;
+{
+	/* NetBSD: Always leave magic alone -- unless on little endian*/
+	int skip = 1;
+#if 0
+	if (N_GETMAGIC(*h) == OMAGIC)
+		skip = 0;
+#endif
+
+	swap_longs((long *)h + skip, sizeof(*h)/sizeof(long) - skip);
+}
+
+
+void
+md_swapin_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	struct r_relocation_info_m88k r_r;
+	int *rev_int;
+
+	if (sizeof (struct relocation_info_m88k) != sizeof (struct r_relocation_info_m88k)){
+		fprintf(stderr, "fatal: relocation entry swapin\n");
+		exit(23);
+	}
+	for (; n; n--, r++) {
+
+		memcpy(&r_r,r,sizeof (struct relocation_info_m88k));
+		r->r_address = md_swap_long(r_r.r_address);
+		r->r_addend = md_swap_long(r_r.r_addend);
+		rev_int = (((int *)(&r_r)) +1);
+		*rev_int = md_swap_long(*rev_int);
+
+
+		r->r_symbolnum = r_r.r_symbolnum;
+		r->r_extern = r_r.r_extern;
+		r->r_type = r_r.r_type;
+		switch(r->r_type){
+		case RELOC_LO16:
+		case RELOC_HI16:
+			r->r_baserel =1;
+			break;
+		case RELOC_PC16:
+		case RELOC_PC26:
+			r->r_pcrel =1;
+			r->r_baserel =1;
+			break;
+		case RELOC_32:
+			r->r_jmptable =1;
+			break;
+		case RELOC_IW16:
+			break;
+		}
+#if 0
+printf("%08x: %5x %4x %4x\n",
+	r->r_address,
+	r->r_symbolnum,
+	r->r_extern,
+	r->r_type);
+#endif
+	}
+}
+
+void
+md_swapout_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	int *rev_int;
+	struct r_relocation_info_m88k r_r;
+
+	for (; n; n--, r++) {
+		r_r.r_address = md_swap_long(r->r_address);
+		r_r.r_addend = md_swap_long(r->r_addend);
+		r_r.r_symbolnum = r->r_symbolnum;
+		r_r.r_extern = r->r_extern;
+		r_r.r_type = r->r_type;
+		rev_int = (((int *)(&r_r)) +1);
+		*rev_int = md_swap_long(*rev_int);
+		memcpy(r,&r_r,sizeof (struct relocation_info_m88k));
+	}
+}
+
+void
+md_swapout_jmpslot(j, n)
+jmpslot_t	*j;
+int		n;
+{
+	for (; n; n--, j++) {
+		j->opcode = md_swap_short(j->opcode);
+		j->addr[0] = md_swap_short(j->addr[0]);
+		j->addr[1] = md_swap_short(j->addr[1]);
+		j->reloc_index = md_swap_short(j->reloc_index);
+	}
+}
+
+#else /* ! defined(NEEDSWAP) */
+void
+md_in_reloc(r, n)
+struct relocation_info_m88k *r;
+int n;
+{
+	for (; n; n--, r++) {
+
+		switch(r->r_type){
+		case RELOC_LO16:
+		case RELOC_HI16:
+/*			r->r_baserel =1; */
+			break;
+		case RELOC_PC16:
+		case RELOC_PC26:
+			r->r_pcrel =1;
+/* 			r->r_baserel =1; */
+			break;
+		case RELOC_32:
+	/*		r->r_jmptable =1; */
+			break;
+		case RELOC_IW16:
+			break;
+		case RELOC_GLOB_DAT:
+			break;
+#if 1
+		case RELOC_JMP_SLOT:
+	/*		r->r_jmptable =1; */
+			break;
+#endif
+		case RELOC_RELATIVE: 
+			r->r_pcrel =1;
+			break;
+		default:
+			printf("error in relocation type %x\n",r->r_type);
+		print_reloc(r);
+			exit(10);
+		}
+/*
+		print_reloc(r);
+*/
+	}
+}
+#endif /* ! NEED_SWAP */
+print_reloc(struct relocation_info_m88k *r)
+{
+	printf ("%6x:\t%4d\t%d\t%d\t%d\t%d\t%x\t",
+		r->r_address,
+		r->r_symbolnum,
+		r->r_pcrel,
+		r->r_extern,
+		r->r_baserel,
+		r->r_jmptable,
+		r->r_addend
+	);
+	switch (r->r_type) {
+	case RELOC_LO16:
+		printf("lo16\n");
+		break;
+	case RELOC_HI16:
+		printf("hi16\n");
+		break;
+	case RELOC_PC16:
+		printf("pc16\n");
+		break;
+	case RELOC_PC26:
+		printf("pc26\n");
+		break;
+	case RELOC_32:
+		printf("reloc32\n");
+		break;
+	case RELOC_IW16:
+		printf("iw16\n");
+		break;
+	case NO_RELOC:
+		printf("none\n");
+		break;
+	case RELOC_GLOB_DAT:
+		printf("glob_dat\n");
+		break;
+	case RELOC_JMP_SLOT:
+		printf("jmp_slot\n");
+		break;
+	case RELOC_RELATIVE: 
+		printf("rel\n");
+		break;
+	}
+
+}
diff --git a/gnu/usr.bin/ld/mvme88k/md.h b/gnu/usr.bin/ld/mvme88k/md.h
new file mode 100644
index 00000000000..6e7fa1024df
--- /dev/null
+++ b/gnu/usr.bin/ld/mvme88k/md.h
@@ -0,0 +1,263 @@
+/*
+ * $Id: md.h,v 1.1 1997/04/23 21:24:41 rahnds Exp $
+ *	- m68k dependent definitions
+ */
+
+#if defined(CROSS_LINKER) && defined(XHOST) && XHOST==i386
+#define NEED_SWAP
+#endif
+
+#if defined(CROSS_LINKER)
+#undef MID_MACHINE
+/* XXX */
+#define MID_MACHINE 151
+#endif
+
+#define	MAX_ALIGNMENT		(sizeof (double))
+
+#define PAGSIZ			0x1000
+#undef  __LDPGSZ
+#define __LDPGSZ		0x1000
+
+#define N_SET_FLAG(ex,f)	N_SETMAGIC(ex,N_GETMAGIC(ex), MID_MACHINE, \
+						N_GETFLAG(ex)|(f))
+
+#define N_IS_DYNAMIC(ex)	((N_GETFLAG(ex) & EX_DYNAMIC))
+
+#define N_BADMID(ex) \
+	(N_GETMID(ex) != 0 && N_GETMID(ex) != MID_MACHINE && \
+						!md_midcompat(&(ex)))
+
+/*
+ * Should be handled by a.out.h ?
+ */
+#define N_ADJUST(ex)		(((ex).a_entry < PAGSIZ) ? -PAGSIZ : 0)
+/*
+#define TEXT_START(ex)		(N_TXTADDR(ex) + N_ADJUST(ex))
+*/
+#define TEXT_START(ex)		(N_TXTADDR(ex))
+#define DATA_START(ex)		(N_DATADDR(ex) + N_ADJUST(ex))
+
+#define RELOC_STATICS_THROUGH_GOT_P(r)	(1)
+#define JMPSLOT_NEEDS_RELOC		(0)
+
+#define md_got_reloc(r)			(0)
+
+#define md_get_rt_segment_addend(r,a)	md_get_addend(r,a)
+
+/* Width of a Global Offset Table entry */
+#define GOT_ENTRY_SIZE	4
+typedef long	got_t;
+
+typedef struct jmpslot {
+	u_short	opcode;
+	u_short	addr[2];
+	u_short	reloc_index;
+#define JMPSLOT_RELOC_MASK		0xffff
+} jmpslot_t;
+
+#if 1 /* NOT REALLY */
+#define NOP	0x4e71
+#define BSRL	0x61ff		/* BSR opcode with long offset */
+#define BRAL	0x60ff		/* BRA opcode with long offset */
+#define BPT	0x4e42		/* breakpoint trap: trap #2 */
+#endif
+
+/* m88k */
+enum reloc_type {
+
+        RELOC_LO16, /* lo16(sym) */
+        RELOC_HI16, /* hi16(sym) */
+        RELOC_PC16, /* bb0, bb1, bcnd */
+        RELOC_PC26, /* br, bsr */
+        RELOC_32, /* jump tables, etc */
+        RELOC_IW16, /* global access through linker regs 28 */
+        NO_RELOC,
+	RELOC_GLOB_DAT,
+	RELOC_JMP_SLOT,
+	RELOC_RELATIVE
+};
+#if  0
+struct relocation_info_m88k {
+        unsigned int r_address;         /* offset in text or data segment */
+        unsigned int r_symbolnum : 24,  /* ordinal number of add symbol */
+                        r_extern :  1,  /* 1 if need to add symbol to value */
+			r_baserel : 1,
+			r_pcrel : 1,
+			r_jmptable : 1,
+			r_type : 4;
+			
+	int r_addend;
+};
+#endif
+struct r_relocation_info_m88k {
+        unsigned int r_address;         /* offset in text or data segment */
+	unsigned int 	  r_type : 4,
+			r_jmptable : 1,
+			r_pcrel : 1,
+			r_baserel : 1,
+                        r_extern :  1,  /* 1 if need to add symbol to value */
+                     r_symbolnum : 24;  /* ordinal number of add symbol */
+			
+	int r_addend;
+};
+#undef relocation_info 
+#define relocation_info relocation_info_m88k
+
+
+
+
+/*
+ * Byte swap defs for cross linking
+ */
+
+#if !defined(NEED_SWAP)
+
+#define md_swapin_exec_hdr(h)
+#define md_swapout_exec_hdr(h)
+#define md_swapin_symbols(s,n)
+#define md_swapout_symbols(s,n)
+#define md_swapin_zsymbols(s,n)
+#define md_swapout_zsymbols(s,n)
+#define md_swapin_reloc(r,n)  			md_in_reloc(r,n)
+#define md_swapout_reloc(r,n)
+#define md_swapin__dynamic(l)
+#define md_swapout__dynamic(l)
+#define md_swapin_section_dispatch_table(l)
+#define md_swapout_section_dispatch_table(l)
+#define md_swapin_so_debug(d)
+#define md_swapout_so_debug(d)
+#define md_swapin_rrs_hash(f,n)
+#define md_swapout_rrs_hash(f,n)
+#define md_swapin_sod(l,n)
+#define md_swapout_sod(l,n)
+#define md_swapout_jmpslot(j,n)
+#define md_swapout_got(g,n)
+#define md_swapin_ranlib_hdr(h,n)
+#define md_swapout_ranlib_hdr(h,n)
+
+#endif /* NEED_SWAP */
+
+#ifdef CROSS_LINKER
+
+#define get_byte(p)	( ((unsigned char *)(p))[0] )
+
+#define get_short(p)	( ( ((unsigned char *)(p))[0] << 8) | \
+			  ( ((unsigned char *)(p))[1]     )   \
+			)
+#define get_long(p)	( ( ((unsigned char *)(p))[0] << 24) | \
+			  ( ((unsigned char *)(p))[1] << 16) | \
+			  ( ((unsigned char *)(p))[2] << 8 ) | \
+			  ( ((unsigned char *)(p))[3]      )   \
+			)
+
+#define put_byte(p, v)	{ ((unsigned char *)(p))[0] = ((unsigned long)(v)); }
+
+#define put_short(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 8) & 0xff); 	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v))     ) & 0xff); }
+
+#define put_long(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 24) & 0xff); 	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v)) >> 16) & 0xff); 	\
+			  ((unsigned char *)(p))[2] =			\
+				((((unsigned long)(v)) >>  8) & 0xff); 	\
+			  ((unsigned char *)(p))[3] =			\
+				((((unsigned long)(v))      ) & 0xff); }
+#define put_b26(p, v)	{ ((unsigned char *)(p))[0] =			\
+				((((unsigned long)(v)) >> 24) & 0x03 |  \
+				((unsigned char *)(p))[0] & 0xfc);  	\
+			  ((unsigned char *)(p))[1] =			\
+				((((unsigned long)(v)) >> 16) & 0xff); 	\
+			  ((unsigned char *)(p))[2] =			\
+				((((unsigned long)(v)) >>  8) & 0xff); 	\
+			  ((unsigned char *)(p))[3] =			\
+				((((unsigned long)(v))      ) & 0xff); }
+
+
+#ifdef NEED_SWAP
+
+/* Define IO byte swapping routines */
+
+void	md_swapin_exec_hdr __P((struct exec *));
+void	md_swapout_exec_hdr __P((struct exec *));
+void	md_swapin_reloc __P((struct relocation_info *, int));
+void	md_swapout_reloc __P((struct relocation_info *, int));
+void	md_swapout_jmpslot __P((jmpslot_t *, int));
+
+#define md_swapin_symbols(s,n)			swap_symbols(s,n)
+#define md_swapout_symbols(s,n)			swap_symbols(s,n)
+#define md_swapin_zsymbols(s,n)			swap_zsymbols(s,n)
+#define md_swapout_zsymbols(s,n)		swap_zsymbols(s,n)
+#define md_swapin__dynamic(l)			swap__dynamic(l)
+#define md_swapout__dynamic(l)			swap__dynamic(l)
+#define md_swapin_section_dispatch_table(l)	swap_section_dispatch_table(l)
+#define md_swapout_section_dispatch_table(l)	swap_section_dispatch_table(l)
+#define md_swapin_so_debug(d)			swap_so_debug(d)
+#define md_swapout_so_debug(d)			swap_so_debug(d)
+#define md_swapin_rrs_hash(f,n)			swap_rrs_hash(f,n)
+#define md_swapout_rrs_hash(f,n)		swap_rrs_hash(f,n)
+#define md_swapin_sod(l,n)			swapin_sod(l,n)
+#define md_swapout_sod(l,n)			swapout_sod(l,n)
+#define md_swapout_got(g,n)			swap_longs((long*)(g),n)
+#define md_swapin_ranlib_hdr(h,n)		swap_ranlib_hdr(h,n)
+#define md_swapout_ranlib_hdr(h,n)		swap_ranlib_hdr(h,n)
+
+#define md_swap_short(x) ( (((x) >> 8) & 0xff) | (((x) & 0xff) << 8) )
+
+#define md_swap_long(x) ( (((x) >> 24) & 0xff    ) | (((x) >> 8 ) & 0xff00   ) | \
+			(((x) << 8 ) & 0xff0000) | (((x) << 24) & 0xff000000))
+
+#else	/* We need not swap, but must pay attention to alignment: */
+
+#define md_swap_short(x)	(x)
+#define md_swap_long(x)		(x)
+
+#endif /* NEED_SWAP */
+
+#else	/* Not a cross linker: use native */
+
+#define md_swap_short(x)		(x)
+#define md_swap_long(x)			(x)
+
+#define get_byte(where)			(*(char *)(where))
+#define get_short(where)		(*(short *)(where))
+#define get_long(where)			(*(long *)(where))
+
+#define put_byte(where,what)		(*(char *)(where) = (what))
+#define put_short(where,what)		(*(short *)(where) = (what))
+#define put_long(where,what)		(*(long *)(where) = (what))
+#define put_b26(where, what)		(*(long *)(where) = ((*(long *)(where))\
+				& ~0x03ffffff) | ((what) & 0x03ffffff))
+
+#endif /* CROSS_LINKER */
+
+#if 0
+#define RELOC_ADDRESS(r)		((r)->r_address)
+#define RELOC_EXTERN_P(r)		((r)->r_extern)
+#define RELOC_TYPE(r)			((r)->r_symbolnum)
+#define RELOC_SYMBOL(r)			((r)->r_symbolnum)
+#define RELOC_MEMORY_SUB_P(r)		0
+#define RELOC_MEMORY_ADD_P(r)		1
+#undef RELOC_ADD_EXTRA
+#define RELOC_PCREL_P(r)		((r)->r_pcrel)
+#define RELOC_VALUE_RIGHTSHIFT(r)	0
+#if defined(RTLD) && defined(SUN_COMPAT)
+#define RELOC_TARGET_SIZE(r)		(2)	/* !!!!! Sun BUG compatible */
+#else
+#define RELOC_TARGET_SIZE(r)		((r)->r_length)
+#endif
+#define RELOC_TARGET_BITPOS(r)		0
+#define RELOC_TARGET_BITSIZE(r)		32
+
+#define RELOC_JMPTAB_P(r)		((r)->r_jmptable)
+#define RELOC_BASEREL_P(r)		((r)->r_baserel)
+#define RELOC_RELATIVE_P(r)		((r)->r_relative)
+#define RELOC_COPY_P(r)			((r)->r_copy)
+#define RELOC_LAZY_P(r)			((r)->r_jmptable)
+
+#define CHECK_GOT_RELOC(r)		(0)
+#endif
+