1 files changed, 493 insertions, 562 deletions

diff --git a/gas/config/tc-m88k.c b/gas/config/tc-m88k.c
index 6a721e7..d2a12ad 100644
--- a/gas/config/tc-m88k.c
+++ b/gas/config/tc-m88k.c
@@ -2,25 +2,25 @@
    Contributed by Devon Bowen of Buffalo University
    and Torbjorn Granlund of the Swedish Institute of Computer Science.
    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
-   2000, 2001, 2002, 2003
+   2000, 2001, 2002, 2003, 2005
    Free Software Foundation, Inc.
 
-This file is part of GAS, the GNU Assembler.
+   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 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.
+   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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+   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, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 #include "as.h"
 #include "safe-ctype.h"
@@ -80,7 +80,7 @@ struct field_val_assoc fcr_regs[] =
 
 struct field_val_assoc cmpslot[] =
 {
-/* Integer	Floating point */
+/* Integer	Floating point.  */
   {"nc", 0},
   {"cp", 1},
   {"eq", 2},
@@ -122,30 +122,10 @@ struct m88k_insn
   enum reloc_type reloc;
 };
 
-static char *get_bf PARAMS ((char *param, unsigned *valp));
-static char *get_cmp PARAMS ((char *param, unsigned *valp));
-static char *get_cnd PARAMS ((char *param, unsigned *valp));
-static char *get_bf2 PARAMS ((char *param, int bc));
-static char *get_bf_offset_expression PARAMS ((char *param, unsigned *offsetp));
-static char *get_cr PARAMS ((char *param, unsigned *regnop));
-static char *get_fcr PARAMS ((char *param, unsigned *regnop));
-static char *get_imm16 PARAMS ((char *param, struct m88k_insn *insn));
-static char *get_o6 PARAMS ((char *param, unsigned *valp));
-static char *match_name PARAMS ((char *, struct field_val_assoc *, unsigned *));
-static char *get_reg PARAMS ((char *param, unsigned *regnop, unsigned int reg_prefix));
-static char *get_vec9 PARAMS ((char *param, unsigned *valp));
-static char *getval PARAMS ((char *param, unsigned int *valp));
-
-static char *get_pcr PARAMS ((char *param, struct m88k_insn *insn,
-		      enum reloc_type reloc));
-
-static int calcop PARAMS ((struct m88k_opcode *format,
-			   char *param, struct m88k_insn *insn));
-
 extern char *myname;
 static struct hash_control *op_hash = NULL;
 
-/* These bits should be turned off in the first address of every segment */
+/* These bits should be turned off in the first address of every segment.  */
 int md_seg_align = 7;
 
 /* These chars start a comment anywhere in a source file (except inside
@@ -157,32 +137,16 @@ const char line_comment_chars[] = "#";
 
 const char line_separator_chars[] = "";
 
-/* Chars that can be used to separate mant from exp in floating point nums */
+/* Chars that can be used to separate mant from exp in floating point nums.  */
 const 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) */
+/* Chars that mean this number is a floating point constant.
+   as in 0f123.456
+   or    0H1.234E-12 (see exp chars above).  */
 const char FLT_CHARS[] = "dDfF";
 
-const pseudo_typeS md_pseudo_table[] =
-{
-  {"align", s_align_bytes, 4},
-  {"def", s_set, 0},
-  {"dfloat", float_cons, 'd'},
-  {"ffloat", float_cons, 'f'},
-  {"half", cons, 2},
-  {"bss", s_lcomm, 1},
-  {"string", stringer, 0},
-  {"word", cons, 4},
-  /* Force set to be treated as an instruction.  */
-  {"set", NULL, 0},
-  {".set", s_set, 0},
-  {NULL, NULL, 0}
-};
-
 void
-md_begin ()
+md_begin (void)
 {
   const char *retval = NULL;
   unsigned int i = 0;
@@ -208,264 +172,341 @@ md_begin ()
 }
 
 const char *md_shortopts = "";
-struct option md_longopts[] = {
+struct option md_longopts[] =
+{
   {NULL, no_argument, NULL, 0}
 };
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
-md_parse_option (c, arg)
-     int c ATTRIBUTE_UNUSED;
-     char *arg ATTRIBUTE_UNUSED;
+md_parse_option (int c ATTRIBUTE_UNUSED, char *arg ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 
 void
-md_show_usage (stream)
-     FILE *stream ATTRIBUTE_UNUSED;
+md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
 {
 }
 
-void
-md_assemble (op)
-     char *op;
+static char *
+get_o6 (char *param, unsigned *valp)
 {
-  char *param, *thisfrag;
-  char c;
-  struct m88k_opcode *format;
-  struct m88k_insn insn;
+  unsigned val;
+  char *save_ptr;
 
-  assert (op);
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  val = get_absolute_expression ();
+  param = input_line_pointer;
+  input_line_pointer = save_ptr;
 
-  /* Skip over instruction to find parameters.  */
-  for (param = op; *param != 0 && !ISSPACE (*param); param++)
-    ;
-  c = *param;
-  *param++ = '\0';
+  if (val & 0x3)
+    as_warn (_("Removed lower 2 bits of expression"));
 
-  /* Try to find the instruction in the hash table.  */
-  if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL)
+  *valp = val;
+
+  return (param);
+}
+
+static char *
+get_vec9 (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;
+}
+
+static char *
+get_bf2 (char *param, int bc)
+{
+  int depth = 0;
+  int c;
+
+  for (;;)
     {
-      as_bad (_("Invalid mnemonic '%s'"), op);
-      return;
+      c = *param;
+      if (c == 0)
+	return param;
+      else if (c == '(')
+	depth++;
+      else if (c == ')')
+	depth--;
+      else if (c == bc && depth <= 0)
+	return param;
+      param++;
     }
+}
 
-  /* Try parsing this instruction into insn.  */
-  insn.exp.X_add_symbol = 0;
-  insn.exp.X_op_symbol = 0;
-  insn.exp.X_add_number = 0;
-  insn.exp.X_op = O_illegal;
-  insn.reloc = NO_RELOC;
+static char *
+match_name (char *param,
+	    struct field_val_assoc *assoc_tab,
+	    unsigned *valp)
+{
+  int i;
+  char *name;
+  int name_len;
 
-  while (!calcop (format, param, &insn))
+  for (i = 0;; i++)
     {
-      /* If it doesn't parse try the next instruction.  */
-      if (!strcmp (format[0].name, format[1].name))
-	format++;
-      else
+      name = assoc_tab[i].name;
+      if (name == NULL)
+	return NULL;
+      name_len = strlen (name);
+      if (!strncmp (param, name, name_len))
 	{
-	  as_fatal (_("Parameter syntax error"));
-	  return;
+	  *valp = assoc_tab[i].val;
+	  return param + name_len;
 	}
     }
+}
 
-  /* Grow the current frag and plop in the opcode.  */
-  thisfrag = frag_more (4);
-  md_number_to_chars (thisfrag, insn.opcode, 4);
+static char *
+get_bf_offset_expression (char *param, unsigned *offsetp)
+{
+  unsigned offset;
 
-  /* If this instruction requires labels mark it for later.  */
-  switch (insn.reloc)
+  if (ISALPHA (param[0]))
     {
-    case NO_RELOC:
-      break;
-
-    case RELOC_LO16:
-    case RELOC_HI16:
-      fix_new_exp (frag_now,
-		   thisfrag - frag_now->fr_literal + 2,
-		   2,
-		   &insn.exp,
-		   0,
-		   insn.reloc);
-      break;
-
-    case RELOC_IW16:
-      fix_new_exp (frag_now,
-		   thisfrag - frag_now->fr_literal,
-		   4,
-		   &insn.exp,
-		   0,
-		   insn.reloc);
-      break;
-
-    case RELOC_PC16:
-      fix_new_exp (frag_now,
-		   thisfrag - frag_now->fr_literal + 2,
-		   2,
-		   &insn.exp,
-		   1,
-		   insn.reloc);
-      break;
+      param[0] = TOLOWER (param[0]);
+      param[1] = TOLOWER (param[1]);
 
-    case RELOC_PC26:
-      fix_new_exp (frag_now,
-		   thisfrag - frag_now->fr_literal,
-		   4,
-		   &insn.exp,
-		   1,
-		   insn.reloc);
-      break;
+      param = match_name (param, cmpslot, offsetp);
 
-    default:
-      as_fatal (_("Unknown relocation type"));
-      break;
+      return param;
+    }
+  else
+    {
+      input_line_pointer = param;
+      offset = get_absolute_expression ();
+      param = input_line_pointer;
     }
+
+  *offsetp = offset;
+  return param;
 }
 
-static int
-calcop (format, param, insn)
-     struct m88k_opcode *format;
-     char *param;
-     struct m88k_insn *insn;
+static char *
+get_bf (char *param, unsigned *valp)
 {
-  char *fmt = format->op_spec;
-  int f;
-  unsigned val;
-  unsigned opcode;
-  unsigned int reg_prefix = 'r';
+  unsigned offset = 0;
+  unsigned width = 0;
+  char *xp;
+  char *save_ptr;
 
-  insn->opcode = format->opcode;
-  opcode = 0;
+  xp = get_bf2 (param, '<');
 
-  for (;;)
+  save_ptr = input_line_pointer;
+  input_line_pointer = param;
+  if (*xp == 0)
     {
-      if (param == 0)
-	return 0;
-      f = *fmt++;
-      switch (f)
-	{
-	case 0:
-	  insn->opcode |= opcode;
-	  return (*param == 0 || *param == '\n');
+      /* We did not find '<'.  We have an offset (width implicitly 32).  */
+      param = get_bf_offset_expression (param, &offset);
+      input_line_pointer = save_ptr;
+      if (param == NULL)
+	return NULL;
+    }
+  else
+    {
+      *xp++ = 0;		/* Overwrite the '<'.  */
+      param = get_bf2 (xp, '>');
+      if (*param == 0)
+	return NULL;
+      *param++ = 0;		/* Overwrite the '>'.  */
 
-	default:
-	  if (f != *param++)
-	    return 0;
-	  break;
+      width = get_absolute_expression ();
+      xp = get_bf_offset_expression (xp, &offset);
+      input_line_pointer = save_ptr;
 
-	case 'd':
-	  param = get_reg (param, &val, reg_prefix);
-	  reg_prefix = 'r';
-	  opcode |= val << 21;
-	  break;
+      if (xp + 1 != param)
+	return NULL;
+    }
 
-	case 'o':
-	  param = get_o6 (param, &val);
-	  opcode |= ((val >> 2) << 7);
-	  break;
+  *valp = ((width % 32) << 5) | (offset % 32);
 
-	case 'x':
-	  reg_prefix = 'x';
-	  break;
+  return param;
+}
 
-	case '1':
-	  param = get_reg (param, &val, reg_prefix);
-	  reg_prefix = 'r';
-	  opcode |= val << 16;
-	  break;
+static char *
+get_cr (char *param, unsigned *regnop)
+{
+  unsigned regno;
+  unsigned c;
 
-	case '2':
-	  param = get_reg (param, &val, reg_prefix);
-	  reg_prefix = 'r';
-	  opcode |= val;
-	  break;
+  if (!strncmp (param, "cr", 2))
+    {
+      param += 2;
 
-	case '3':
-	  param = get_reg (param, &val, 'r');
-	  opcode |= (val << 16) | val;
-	  break;
+      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;
+    }
 
-	case 'I':
-	  param = get_imm16 (param, insn);
-	  break;
+  param = match_name (param, cr_regs, regnop);
 
-	case 'b':
-	  param = get_bf (param, &val);
-	  opcode |= val;
-	  break;
+  return param;
+}
 
-	case 'p':
-	  param = get_pcr (param, insn, RELOC_PC16);
-	  break;
+static char *
+get_fcr (char *param, unsigned *regnop)
+{
+  unsigned regno;
+  unsigned c;
 
-	case 'P':
-	  param = get_pcr (param, insn, RELOC_PC26);
-	  break;
+  if (!strncmp (param, "fcr", 3))
+    {
+      param += 3;
 
-	case 'B':
-	  param = get_cmp (param, &val);
-	  opcode |= val;
-	  break;
+      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;
+    }
 
-	case 'M':
-	  param = get_cnd (param, &val);
-	  opcode |= val;
-	  break;
+  param = match_name (param, fcr_regs, regnop);
 
-	case 'c':
-	  param = get_cr (param, &val);
-	  opcode |= val << 5;
-	  break;
+  return param;
+}
 
-	case 'f':
-	  param = get_fcr (param, &val);
-	  opcode |= val << 5;
-	  break;
+#define hexval(z) \
+  (ISDIGIT (z) ? (z) - '0' :						\
+   ISLOWER (z) ? (z) - 'a' + 10 : 					\
+   ISUPPER (z) ? (z) - 'A' + 10 : (unsigned) -1)
 
-	case 'V':
-	  param = get_vec9 (param, &val);
-	  opcode |= val;
-	  break;
+static char *
+getval (char *param, unsigned int *valp)
+{
+  unsigned int val = 0;
+  unsigned int c;
 
-	case '?':
-	  /* Having this here repeats the warning somtimes.
-	   But can't we stand that?  */
-	  as_warn (_("Use of obsolete instruction"));
-	  break;
+  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;
 }
 
 static char *
-match_name (param, assoc_tab, valp)
-     char *param;
-     struct field_val_assoc *assoc_tab;
-     unsigned *valp;
+get_cnd (char *param, unsigned *valp)
 {
-  int i;
-  char *name;
-  int name_len;
+  unsigned int val;
 
-  for (i = 0;; i++)
+  if (ISDIGIT (*param))
     {
-      name = assoc_tab[i].name;
-      if (name == NULL)
-	return NULL;
-      name_len = strlen (name);
-      if (!strncmp (param, name, name_len))
+      param = getval (param, &val);
+
+      if (val >= 32)
 	{
-	  *valp = assoc_tab[i].val;
-	  return param + name_len;
+	  as_warn (_("Expression truncated to 5 bits"));
+	  val %= 32;
 	}
     }
+  else
+    {
+      param[0] = TOLOWER (param[0]);
+      param[1] = TOLOWER (param[1]);
+
+      param = match_name (param, cndmsk, valp);
+
+      if (param == NULL)
+	return NULL;
+
+      val = *valp;
+    }
+
+  *valp = val << 21;
+  return param;
 }
 
 static char *
-get_reg (param, regnop, reg_prefix)
-     char *param;
-     unsigned *regnop;
-     unsigned int reg_prefix;
+get_reg (char *param, unsigned *regnop, unsigned int reg_prefix)
 {
   unsigned c;
   unsigned regno;
@@ -509,9 +550,7 @@ get_reg (param, regnop, reg_prefix)
 }
 
 static char *
-get_imm16 (param, insn)
-     char *param;
-     struct m88k_insn *insn;
+get_imm16 (char *param, struct m88k_insn *insn)
 {
   enum reloc_type reloc = NO_RELOC;
   unsigned int val;
@@ -568,10 +607,7 @@ get_imm16 (param, insn)
 }
 
 static char *
-get_pcr (param, insn, reloc)
-     char *param;
-     struct m88k_insn *insn;
-     enum reloc_type reloc;
+get_pcr (char *param, struct m88k_insn *insn, enum reloc_type reloc)
 {
   char *saveptr, *saveparam;
 
@@ -590,9 +626,7 @@ get_pcr (param, insn, reloc)
 }
 
 static char *
-get_cmp (param, valp)
-     char *param;
-     unsigned *valp;
+get_cmp (char *param, unsigned *valp)
 {
   unsigned int val;
   char *save_ptr;
@@ -623,322 +657,216 @@ get_cmp (param, valp)
   return param;
 }
 
-static char *
-get_cnd (param, valp)
-     char *param;
-     unsigned *valp;
+static int
+calcop (struct m88k_opcode *format,
+	char *param,
+	struct m88k_insn *insn)
 {
-  unsigned int val;
+  char *fmt = format->op_spec;
+  int f;
+  unsigned val;
+  unsigned opcode;
+  unsigned int reg_prefix = 'r';
 
-  if (ISDIGIT (*param))
-    {
-      param = getval (param, &val);
+  insn->opcode = format->opcode;
+  opcode = 0;
 
-      if (val >= 32)
-	{
-	  as_warn (_("Expression truncated to 5 bits"));
-	  val %= 32;
-	}
-    }
-  else
+  for (;;)
     {
-      param[0] = TOLOWER (param[0]);
-      param[1] = TOLOWER (param[1]);
-
-      param = match_name (param, cndmsk, valp);
+      if (param == 0)
+	return 0;
+      f = *fmt++;
+      switch (f)
+	{
+	case 0:
+	  insn->opcode |= opcode;
+	  return (*param == 0 || *param == '\n');
 
-      if (param == NULL)
-	return NULL;
+	default:
+	  if (f != *param++)
+	    return 0;
+	  break;
 
-      val = *valp;
-    }
+	case 'd':
+	  param = get_reg (param, &val, reg_prefix);
+	  reg_prefix = 'r';
+	  opcode |= val << 21;
+	  break;
 
-  *valp = val << 21;
-  return param;
-}
+	case 'o':
+	  param = get_o6 (param, &val);
+	  opcode |= ((val >> 2) << 7);
+	  break;
 
-static char *
-get_bf2 (param, bc)
-     char *param;
-     int bc;
-{
-  int depth = 0;
-  int c;
+	case 'x':
+	  reg_prefix = 'x';
+	  break;
 
-  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++;
-    }
-}
+	case '1':
+	  param = get_reg (param, &val, reg_prefix);
+	  reg_prefix = 'r';
+	  opcode |= val << 16;
+	  break;
 
-static char *
-get_bf_offset_expression (param, offsetp)
-     char *param;
-     unsigned *offsetp;
-{
-  unsigned offset;
+	case '2':
+	  param = get_reg (param, &val, reg_prefix);
+	  reg_prefix = 'r';
+	  opcode |= val;
+	  break;
 
-  if (ISALPHA (param[0]))
-    {
-      param[0] = TOLOWER (param[0]);
-      param[1] = TOLOWER (param[1]);
+	case '3':
+	  param = get_reg (param, &val, 'r');
+	  opcode |= (val << 16) | val;
+	  break;
 
-      param = match_name (param, cmpslot, offsetp);
+	case 'I':
+	  param = get_imm16 (param, insn);
+	  break;
 
-      return param;
-    }
-  else
-    {
-      input_line_pointer = param;
-      offset = get_absolute_expression ();
-      param = input_line_pointer;
-    }
+	case 'b':
+	  param = get_bf (param, &val);
+	  opcode |= val;
+	  break;
 
-  *offsetp = offset;
-  return param;
-}
+	case 'p':
+	  param = get_pcr (param, insn, RELOC_PC16);
+	  break;
 
-static char *
-get_bf (param, valp)
-     char *param;
-     unsigned *valp;
-{
-  unsigned offset = 0;
-  unsigned width = 0;
-  char *xp;
-  char *save_ptr;
+	case 'P':
+	  param = get_pcr (param, insn, RELOC_PC26);
+	  break;
 
-  xp = get_bf2 (param, '<');
+	case 'B':
+	  param = get_cmp (param, &val);
+	  opcode |= val;
+	  break;
 
-  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);
-      input_line_pointer = save_ptr;
-      if (param == NULL)
-	return NULL;
-    }
-  else
-    {
-      *xp++ = 0;		/* Overwrite the '<' */
-      param = get_bf2 (xp, '>');
-      if (*param == 0)
-	return NULL;
-      *param++ = 0;		/* Overwrite the '>' */
+	case 'M':
+	  param = get_cnd (param, &val);
+	  opcode |= val;
+	  break;
 
-      width = get_absolute_expression ();
-      xp = get_bf_offset_expression (xp, &offset);
-      input_line_pointer = save_ptr;
+	case 'c':
+	  param = get_cr (param, &val);
+	  opcode |= val << 5;
+	  break;
 
-      if (xp + 1 != param)
-	return NULL;
-    }
+	case 'f':
+	  param = get_fcr (param, &val);
+	  opcode |= val << 5;
+	  break;
 
-  *valp = ((width % 32) << 5) | (offset % 32);
+	case 'V':
+	  param = get_vec9 (param, &val);
+	  opcode |= val;
+	  break;
 
-  return param;
+	case '?':
+	  /* Having this here repeats the warning somtimes.
+	   But can't we stand that?  */
+	  as_warn (_("Use of obsolete instruction"));
+	  break;
+	}
+    }
 }
 
-static char *
-get_cr (param, regnop)
-     char *param;
-     unsigned *regnop;
+void
+md_assemble (char *op)
 {
-  unsigned regno;
-  unsigned c;
-
-  if (!strncmp (param, "cr", 2))
-    {
-      param += 2;
+  char *param, *thisfrag;
+  char c;
+  struct m88k_opcode *format;
+  struct m88k_insn insn;
 
-      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;
-    }
+  assert (op);
 
-  param = match_name (param, cr_regs, regnop);
+  /* Skip over instruction to find parameters.  */
+  for (param = op; *param != 0 && !ISSPACE (*param); param++)
+    ;
+  c = *param;
+  *param++ = '\0';
 
-  return param;
-}
+  /* Try to find the instruction in the hash table.  */
+  if ((format = (struct m88k_opcode *) hash_find (op_hash, op)) == NULL)
+    {
+      as_bad (_("Invalid mnemonic '%s'"), op);
+      return;
+    }
 
-static char *
-get_fcr (param, regnop)
-     char *param;
-     unsigned *regnop;
-{
-  unsigned regno;
-  unsigned c;
+  /* Try parsing this instruction into insn.  */
+  insn.exp.X_add_symbol = 0;
+  insn.exp.X_op_symbol = 0;
+  insn.exp.X_add_number = 0;
+  insn.exp.X_op = O_illegal;
+  insn.reloc = NO_RELOC;
 
-  if (!strncmp (param, "fcr", 3))
+  while (!calcop (format, param, &insn))
     {
-      param += 3;
-
-      regno = *param++ - '0';
-      if (regno < 10)
+      /* If it doesn't parse try the next instruction.  */
+      if (!strcmp (format[0].name, format[1].name))
+	format++;
+      else
 	{
-	  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;
-	    }
+	  as_fatal (_("Parameter syntax error"));
+	  return;
 	}
-      return NULL;
     }
 
-  param = match_name (param, fcr_regs, regnop);
-
-  return param;
-}
-
-static 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;
-}
-
-static char *
-get_o6 (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;
+  /* Grow the current frag and plop in the opcode.  */
+  thisfrag = frag_more (4);
+  md_number_to_chars (thisfrag, insn.opcode, 4);
 
-  if (val & 0x3)
-    as_warn (_("Removed lower 2 bits of expression"));
+  /* If this instruction requires labels mark it for later.  */
+  switch (insn.reloc)
+    {
+    case NO_RELOC:
+      break;
 
-  *valp = val;
+    case RELOC_LO16:
+    case RELOC_HI16:
+      fix_new_exp (frag_now,
+		   thisfrag - frag_now->fr_literal + 2,
+		   2,
+		   &insn.exp,
+		   0,
+		   insn.reloc);
+      break;
 
-  return (param);
-}
+    case RELOC_IW16:
+      fix_new_exp (frag_now,
+		   thisfrag - frag_now->fr_literal,
+		   4,
+		   &insn.exp,
+		   0,
+		   insn.reloc);
+      break;
 
-#define hexval(z) \
-  (ISDIGIT (z) ? (z) - '0' :						\
-   ISLOWER (z) ? (z) - 'a' + 10 : 					\
-   ISUPPER (z) ? (z) - 'A' + 10 : (unsigned) -1)
+    case RELOC_PC16:
+      fix_new_exp (frag_now,
+		   thisfrag - frag_now->fr_literal + 2,
+		   2,
+		   &insn.exp,
+		   1,
+		   insn.reloc);
+      break;
 
-static char *
-getval (param, valp)
-     char *param;
-     unsigned int *valp;
-{
-  unsigned int val = 0;
-  unsigned int c;
+    case RELOC_PC26:
+      fix_new_exp (frag_now,
+		   thisfrag - frag_now->fr_literal,
+		   4,
+		   &insn.exp,
+		   1,
+		   insn.reloc);
+      break;
 
-  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';
-	}
+    default:
+      as_fatal (_("Unknown relocation type"));
+      break;
     }
-
-  *valp = val;
-  return param - 1;
 }
 
 void
-md_number_to_chars (buf, val, nbytes)
-     char *buf;
-     valueT val;
-     int nbytes;
+md_number_to_chars (char *buf, valueT val, int nbytes)
 {
   number_to_chars_bigendian (buf, val, nbytes);
 }
@@ -947,13 +875,10 @@ md_number_to_chars (buf, val, nbytes)
 
 /* 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.
- */
+   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;
+md_atof (int type, char *litP, int *sizeP)
 {
   int prec;
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
@@ -1006,12 +931,11 @@ md_atof (type, litP, sizeP)
 int md_short_jump_size = 4;
 
 void
-md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr;
-     addressT from_addr ATTRIBUTE_UNUSED;
-     addressT to_addr ATTRIBUTE_UNUSED;
-     fragS *frag;
-     symbolS *to_symbol;
+md_create_short_jump (char *ptr,
+		      addressT from_addr ATTRIBUTE_UNUSED,
+		      addressT to_addr ATTRIBUTE_UNUSED,
+		      fragS *frag,
+		      symbolS *to_symbol)
 {
   ptr[0] = (char) 0xc0;
   ptr[1] = 0x00;
@@ -1029,12 +953,11 @@ md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
 int md_long_jump_size = 4;
 
 void
-md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr;
-     addressT from_addr ATTRIBUTE_UNUSED;
-     addressT to_addr ATTRIBUTE_UNUSED;
-     fragS *frag;
-     symbolS *to_symbol;
+md_create_long_jump (char *ptr,
+		     addressT from_addr ATTRIBUTE_UNUSED,
+		     addressT to_addr ATTRIBUTE_UNUSED,
+		     fragS *frag,
+		     symbolS *to_symbol)
 {
   ptr[0] = (char) 0xc0;
   ptr[1] = 0x00;
@@ -1050,12 +973,11 @@ md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
 }
 
 int
-md_estimate_size_before_relax (fragP, segment_type)
-     fragS *fragP ATTRIBUTE_UNUSED;
-     segT segment_type ATTRIBUTE_UNUSED;
+md_estimate_size_before_relax (fragS *fragP ATTRIBUTE_UNUSED,
+			       segT segment_type ATTRIBUTE_UNUSED)
 {
   as_fatal (_("Relaxation should never occur"));
-  return (-1);
+  return -1;
 }
 
 #ifdef M88KCOFF
@@ -1070,8 +992,7 @@ md_estimate_size_before_relax (fragP, segment_type)
    return the BFD relocation type to use for it.  */
 
 short
-tc_coff_fix2rtype (fixp)
-     fixS *fixp;
+tc_coff_fix2rtype (fixS *fixp)
 {
   switch (fixp->fx_r_type)
     {
@@ -1097,10 +1018,7 @@ tc_coff_fix2rtype (fixp)
    file itself.  */
 
 void
-md_apply_fix3 (fixP, valP, seg)
-     fixS *fixP;
-     valueT * valP;
-     segT seg ATTRIBUTE_UNUSED;
+md_apply_fix3 (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
 {
   long val = * (long *) valP;
   char *buf;
@@ -1159,8 +1077,7 @@ md_apply_fix3 (fixP, valP, seg)
    are calculated from just after the instruction.  */
 
 long
-md_pcrel_from (fixp)
-     fixS *fixp;
+md_pcrel_from (fixS *fixp)
 {
   switch (fixp->fx_r_type)
     {
@@ -1171,14 +1088,12 @@ md_pcrel_from (fixp)
     default:
       abort ();
     }
-  /*NOTREACHED*/
 }
 
 /* Fill in rs_align_code fragments.  */
 
 void
-m88k_handle_align (fragp)
-     fragS *fragp;
+m88k_handle_align (fragS *fragp)
 {
   static const unsigned char nop_pattern[] = { 0xf4, 0x00, 0x58, 0x00 };
 
@@ -1205,3 +1120,19 @@ m88k_handle_align (fragp)
 }
 
 #endif /* M88KCOFF */
+
+const pseudo_typeS md_pseudo_table[] =
+{
+  {"align", s_align_bytes, 4},
+  {"def", s_set, 0},
+  {"dfloat", float_cons, 'd'},
+  {"ffloat", float_cons, 'f'},
+  {"half", cons, 2},
+  {"bss", s_lcomm, 1},
+  {"string", stringer, 0},
+  {"word", cons, 4},
+  /* Force set to be treated as an instruction.  */
+  {"set", NULL, 0},
+  {".set", s_set, 0},
+  {NULL, NULL, 0}
+};