Use macros for TUI window names

[deliverable/binutils-gdb.git] / gas / config / tc-mn10200.c

diff --git a/gas/config/tc-mn10200.c b/gas/config/tc-mn10200.c
index ad7b756f0d9cb1623d12353679208a618ae8b8ff..0558a3751d9bcce7ca0f7d27f0d8107eb61adc73 100644 (file)
--- a/gas/config/tc-mn10200.c
+++ b/gas/config/tc-mn10200.c
@@ -1,12 +1,11 @@
 /* tc-mn10200.c -- Assembler code for the Matsushita 10200
 /* tc-mn10200.c -- Assembler code for the Matsushita 10200

-   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
-   Free Software Foundation, Inc.
+   Copyright (C) 1996-2020 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
 
    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)
+   the Free Software Foundation; either version 3, or (at your option)

    any later version.
 
    GAS is distributed in the hope that it will be useful,
    any later version.
 
    GAS is distributed in the hope that it will be useful,


@@ -16,10 +15,9 @@
 
    You should have received a copy of the GNU General Public License
    along with GAS; see the file COPYING.  If not, write to
 
    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.  */
+   the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 
 

-#include <stdio.h>

 #include "as.h"
 #include "safe-ctype.h"
 #include "subsegs.h"
 #include "as.h"
 #include "safe-ctype.h"
 #include "subsegs.h"


@@ -53,7 +51,8 @@ const char EXP_CHARS[] = "eE";
    as in 0d1.0.  */
 const char FLT_CHARS[] = "dD";
 \f
    as in 0d1.0.  */
 const char FLT_CHARS[] = "dD";
 \f

-const relax_typeS md_relax_table[] = {
+const relax_typeS md_relax_table[] =
+ {

   /* bCC relaxing  */
   {0x81, -0x7e, 2, 1},
   {0x8004, -0x7ffb, 5, 2},
   /* bCC relaxing  */
   {0x81, -0x7e, 2, 1},
   {0x8004, -0x7ffb, 5, 2},


@@ -72,34 +71,27 @@ const relax_typeS md_relax_table[] = {
 
 };
 
 
 };
 

-/* Local functions.  */
-static void mn10200_insert_operand PARAMS ((unsigned long *, unsigned long *,
-                                           const struct mn10200_operand *,
-                                           offsetT, char *, unsigned,
-                                           unsigned));
-static unsigned long check_operand PARAMS ((unsigned long,
-                                           const struct mn10200_operand *,
-                                           offsetT));
-static int reg_name_search PARAMS ((const struct reg_name *, int, const char *));
-static bfd_boolean data_register_name PARAMS ((expressionS *expressionP));
-static bfd_boolean address_register_name PARAMS ((expressionS *expressionP));
-static bfd_boolean other_register_name PARAMS ((expressionS *expressionP));

 
 /* Fixups.  */
 
 /* Fixups.  */

-#define MAX_INSN_FIXUPS (5)
+#define MAX_INSN_FIXUPS 5
+

 struct mn10200_fixup
 {
   expressionS exp;
   int opindex;
   bfd_reloc_code_real_type reloc;
 };
 struct mn10200_fixup
 {
   expressionS exp;
   int opindex;
   bfd_reloc_code_real_type reloc;
 };

+

 struct mn10200_fixup fixups[MAX_INSN_FIXUPS];
 static int fc;
 \f
 const char *md_shortopts = "";
 struct mn10200_fixup fixups[MAX_INSN_FIXUPS];
 static int fc;
 \f
 const char *md_shortopts = "";

-struct option md_longopts[] = {
+
+struct option md_longopts[] =
+{

   {NULL, no_argument, NULL, 0}
 };
   {NULL, no_argument, NULL, 0}
 };

+

 size_t md_longopts_size = sizeof (md_longopts);
 
 /* The target specific pseudo-ops which we support.  */
 size_t md_longopts_size = sizeof (md_longopts);
 
 /* The target specific pseudo-ops which we support.  */


@@ -141,14 +133,13 @@ static const struct reg_name other_registers[] =
   (sizeof (other_registers) / sizeof (struct reg_name))
 
 /* reg_name_search does a binary search of the given register table
   (sizeof (other_registers) / sizeof (struct reg_name))
 
 /* reg_name_search does a binary search of the given register table

-   to see if "name" is a valid regiter name.  Returns the register
+   to see if "name" is a valid register name.  Returns the register

    number from the array on success, or -1 on failure.  */
 
 static int
    number from the array on success, or -1 on failure.  */
 
 static int

-reg_name_search (regs, regcount, name)
-     const struct reg_name *regs;
-     int regcount;
-     const char *name;
+reg_name_search (const struct reg_name *regs,
+                int regcount,
+                const char *name)

 {
   int middle, low, high;
   int cmp;
 {
   int middle, low, high;
   int cmp;


@@ -172,19 +163,17 @@ reg_name_search (regs, regcount, name)
 }
 
 /* Summary of register_name().
 }
 
 /* Summary of register_name().

- *
- * in: Input_line_pointer points to 1st char of operand.
- *
- * out: An expressionS.
- *     The operand may have been a register: in this case, X_op == O_register,
- *     X_add_number is set to the register number, and truth is returned.
- *     Input_line_pointer->(next non-blank) char after operand, or is in
- *     its original state.
- */
+
+   in: Input_line_pointer points to 1st char of operand.
+
+   out: An expressionS.
+       The operand may have been a register: in this case, X_op == O_register,
+       X_add_number is set to the register number, and truth is returned.
+       Input_line_pointer->(next non-blank) char after operand, or is in
+       its original state.  */

 
 static bfd_boolean
 
 static bfd_boolean

-data_register_name (expressionP)
-     expressionS *expressionP;
+data_register_name (expressionS *expressionP)

 {
   int reg_number;
   char *name;
 {
   int reg_number;
   char *name;


@@ -192,13 +181,12 @@ data_register_name (expressionP)
   char c;
 
   /* Find the spelling of the operand.  */
   char c;
 
   /* Find the spelling of the operand.  */

-  start = name = input_line_pointer;
-
-  c = get_symbol_end ();
+  start = input_line_pointer;
+  c = get_symbol_name (&name);

   reg_number = reg_name_search (data_registers, DATA_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */
   reg_number = reg_name_search (data_registers, DATA_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */

-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);

 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)
 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)


@@ -219,19 +207,17 @@ data_register_name (expressionP)
 }
 
 /* Summary of register_name().
 }
 
 /* Summary of register_name().

- *
- * in: Input_line_pointer points to 1st char of operand.
- *
- * out: An expressionS.
- *     The operand may have been a register: in this case, X_op == O_register,
- *     X_add_number is set to the register number, and truth is returned.
- *     Input_line_pointer->(next non-blank) char after operand, or is in
- *     its original state.
- */
+
+   in: Input_line_pointer points to 1st char of operand.
+
+   out: An expressionS.
+       The operand may have been a register: in this case, X_op == O_register,
+       X_add_number is set to the register number, and truth is returned.
+       Input_line_pointer->(next non-blank) char after operand, or is in
+       its original state.  */

 
 static bfd_boolean
 
 static bfd_boolean

-address_register_name (expressionP)
-     expressionS *expressionP;
+address_register_name (expressionS *expressionP)

 {
   int reg_number;
   char *name;
 {
   int reg_number;
   char *name;


@@ -239,13 +225,12 @@ address_register_name (expressionP)
   char c;
 
   /* Find the spelling of the operand.  */
   char c;
 
   /* Find the spelling of the operand.  */

-  start = name = input_line_pointer;
-
-  c = get_symbol_end ();
+  start = input_line_pointer;
+  c = get_symbol_name (&name);

   reg_number = reg_name_search (address_registers, ADDRESS_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */
   reg_number = reg_name_search (address_registers, ADDRESS_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */

-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);

 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)
 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)


@@ -266,19 +251,17 @@ address_register_name (expressionP)
 }
 
 /* Summary of register_name().
 }
 
 /* Summary of register_name().

- *
- * in: Input_line_pointer points to 1st char of operand.
- *
- * out: An expressionS.
- *     The operand may have been a register: in this case, X_op == O_register,
- *     X_add_number is set to the register number, and truth is returned.
- *     Input_line_pointer->(next non-blank) char after operand, or is in
- *     its original state.
- */
+
+   in: Input_line_pointer points to 1st char of operand.
+
+   out: An expressionS.
+       The operand may have been a register: in this case, X_op == O_register,
+       X_add_number is set to the register number, and truth is returned.
+       Input_line_pointer->(next non-blank) char after operand, or is in
+       its original state.  */

 
 static bfd_boolean
 
 static bfd_boolean

-other_register_name (expressionP)
-     expressionS *expressionP;
+other_register_name (expressionS *expressionP)

 {
   int reg_number;
   char *name;
 {
   int reg_number;
   char *name;


@@ -286,13 +269,12 @@ other_register_name (expressionP)
   char c;
 
   /* Find the spelling of the operand.  */
   char c;
 
   /* Find the spelling of the operand.  */

-  start = name = input_line_pointer;
-
-  c = get_symbol_end ();
+  start = input_line_pointer;
+  c = get_symbol_name (&name);

   reg_number = reg_name_search (other_registers, OTHER_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */
   reg_number = reg_name_search (other_registers, OTHER_REG_NAME_CNT, name);
 
   /* Put back the delimiting char.  */

-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);

 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)
 
   /* Look to see if it's in the register table.  */
   if (reg_number >= 0)


@@ -313,74 +295,35 @@ other_register_name (expressionP)
 }
 
 void
 }
 
 void

-md_show_usage (stream)
-     FILE *stream;
+md_show_usage (FILE *stream)

 {
   fprintf (stream, _("MN10200 options:\n\
 none yet\n"));
 }
 
 int
 {
   fprintf (stream, _("MN10200 options:\n\
 none yet\n"));
 }
 
 int

-md_parse_option (c, arg)
-     int c ATTRIBUTE_UNUSED;
-     char *arg ATTRIBUTE_UNUSED;
+md_parse_option (int c ATTRIBUTE_UNUSED,
+                const char *arg ATTRIBUTE_UNUSED)

 {
   return 0;
 }
 
 symbolS *
 {
   return 0;
 }
 
 symbolS *

-md_undefined_symbol (name)
-     char *name ATTRIBUTE_UNUSED;
+md_undefined_symbol (char *name ATTRIBUTE_UNUSED)

 {
   return 0;
 }
 
 {
   return 0;
 }
 

-char *
-md_atof (type, litp, sizep)
-     int type;
-     char *litp;
-     int *sizep;
+const char *
+md_atof (int type, char *litp, int *sizep)

 {
 {

-  int prec;
-  LITTLENUM_TYPE words[4];
-  char *t;
-  int i;
-
-  switch (type)
-    {
-    case 'f':
-      prec = 2;
-      break;
-
-    case 'd':
-      prec = 4;
-      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 * 2;
-
-  for (i = prec - 1; i >= 0; i--)
-    {
-      md_number_to_chars (litp, (valueT) words[i], 2);
-      litp += 2;
-    }
-
-  return NULL;
+  return ieee_md_atof (type, litp, sizep, FALSE);

 }
 
 void
 }
 
 void

-md_convert_frag (abfd, sec, fragP)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     asection *sec;
-     fragS *fragP;
+md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
+                asection *sec,
+                fragS *fragP)

 {
   static unsigned long label_count = 0;
   char buf[40];
 {
   static unsigned long label_count = 0;
   char buf[40];


@@ -534,6 +477,7 @@ md_convert_frag (abfd, sec, fragP)
          break;
        case 0xff:
          opcode = 0xfe;
          break;
        case 0xff:
          opcode = 0xfe;

+         break;

        case 0xe8:
          opcode = 0xe9;
          break;
        case 0xe8:
          opcode = 0xe9;
          break;


@@ -614,6 +558,7 @@ md_convert_frag (abfd, sec, fragP)
          break;
        case 0xff:
          opcode = 0xfe;
          break;
        case 0xff:
          opcode = 0xfe;

+         break;

        case 0xe8:
          opcode = 0xe9;
          break;
        case 0xe8:
          opcode = 0xe9;
          break;


@@ -728,19 +673,17 @@ md_convert_frag (abfd, sec, fragP)
 }
 
 valueT
 }
 
 valueT

-md_section_align (seg, addr)
-     asection *seg;
-     valueT addr;
+md_section_align (asection *seg, valueT addr)

 {
 {

-  int align = bfd_get_section_alignment (stdoutput, seg);
-  return ((addr + (1 << align) - 1) & (-1 << align));
+  int align = bfd_section_alignment (seg);
+  return ((addr + (1 << align) - 1) & -(1 << align));

 }
 
 void
 }
 
 void

-md_begin ()
+md_begin (void)

 {
 {

-  char *prev_name = "";
-  register const struct mn10200_opcode *op;
+  const char *prev_name = "";
+  const struct mn10200_opcode *op;

 
   mn10200_hash = hash_new ();
 
 
   mn10200_hash = hash_new ();
 


@@ -760,15 +703,175 @@ md_begin ()
       op++;
     }
 
       op++;
     }
 

-  /* This is both a simplification (we don't have to write md_apply_fix3)
+  /* This is both a simplification (we don't have to write md_apply_fix)

      and support for future optimizations (branch shortening and similar
      stuff in the linker.  */
   linkrelax = 1;
 }
 
      and support for future optimizations (branch shortening and similar
      stuff in the linker.  */
   linkrelax = 1;
 }
 

+static unsigned long
+check_operand (unsigned long insn ATTRIBUTE_UNUSED,
+              const struct mn10200_operand *operand,
+              offsetT val)
+{
+  /* No need to check 24bit or 32bit operands for a bit.  */
+  if (operand->bits < 24
+      && (operand->flags & MN10200_OPERAND_NOCHECK) == 0)
+    {
+      long min, max;
+      offsetT test;
+
+      if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)
+       {
+         max = (1 << (operand->bits - 1)) - 1;
+         min = - (1 << (operand->bits - 1));
+       }
+      else
+       {
+         max = (1 << operand->bits) - 1;
+         min = 0;
+       }
+
+      test = val;
+
+      if (test < (offsetT) min || test > (offsetT) max)
+       return 0;
+      else
+       return 1;
+    }
+  return 1;
+}
+/* If while processing a fixup, a reloc really needs to be created
+   Then it is done here.  */
+
+arelent *
+tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
+{
+  arelent *reloc;
+  reloc = XNEW (arelent);
+
+  if (fixp->fx_subsy != NULL)
+    {
+      if (S_GET_SEGMENT (fixp->fx_addsy) == S_GET_SEGMENT (fixp->fx_subsy)
+         && S_IS_DEFINED (fixp->fx_subsy))
+       {
+         fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
+         fixp->fx_subsy = NULL;
+       }
+      else
+       /* FIXME: We should try more ways to resolve difference expressions
+          here.  At least this is better than silently ignoring the
+          subtrahend.  */
+       as_bad_where (fixp->fx_file, fixp->fx_line,
+                     _("can't resolve `%s' {%s section} - `%s' {%s section}"),
+                     fixp->fx_addsy ? S_GET_NAME (fixp->fx_addsy) : "0",
+                     segment_name (fixp->fx_addsy
+                                   ? S_GET_SEGMENT (fixp->fx_addsy)
+                                   : absolute_section),
+                     S_GET_NAME (fixp->fx_subsy),
+                     segment_name (S_GET_SEGMENT (fixp->fx_addsy)));
+    }
+
+  reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
+  if (reloc->howto == NULL)
+    {
+      as_bad_where (fixp->fx_file, fixp->fx_line,
+                   _("reloc %d not supported by object file format"),
+                   (int) fixp->fx_r_type);
+      return NULL;
+    }
+  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
+  reloc->sym_ptr_ptr = XNEW (asymbol *);
+  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
+  reloc->addend = fixp->fx_offset;
+  return reloc;
+}
+
+int
+md_estimate_size_before_relax (fragS *fragp, asection *seg)
+{
+  if (fragp->fr_subtype == 6
+      && (!S_IS_DEFINED (fragp->fr_symbol)
+         || seg != S_GET_SEGMENT (fragp->fr_symbol)))
+    fragp->fr_subtype = 7;
+  else if (fragp->fr_subtype == 8
+          && (!S_IS_DEFINED (fragp->fr_symbol)
+              || seg != S_GET_SEGMENT (fragp->fr_symbol)))
+    fragp->fr_subtype = 10;
+
+  if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
+    abort ();
+
+  return md_relax_table[fragp->fr_subtype].rlx_length;
+}
+
+long
+md_pcrel_from (fixS *fixp)
+{
+  return fixp->fx_frag->fr_address;
+}
+
+void
+md_apply_fix (fixS * fixP, valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
+{
+  /* We shouldn't ever get here because linkrelax is nonzero.  */
+  abort ();
+  fixP->fx_done = 1;
+}
+
+/* Insert an operand value into an instruction.  */
+
+static void
+mn10200_insert_operand (unsigned long *insnp,
+                       unsigned long *extensionp,
+                       const struct mn10200_operand *operand,
+                       offsetT val,
+                       char *file,
+                       unsigned int line,
+                       unsigned int shift)
+{
+  /* No need to check 24 or 32bit operands for a bit.  */
+  if (operand->bits < 24
+      && (operand->flags & MN10200_OPERAND_NOCHECK) == 0)
+    {
+      long min, max;
+      offsetT test;
+
+      if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)
+       {
+         max = (1 << (operand->bits - 1)) - 1;
+         min = - (1 << (operand->bits - 1));
+       }
+      else
+       {
+         max = (1 << operand->bits) - 1;
+         min = 0;
+       }
+
+      test = val;
+
+      if (test < (offsetT) min || test > (offsetT) max)
+       as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line);
+    }
+
+  if ((operand->flags & MN10200_OPERAND_EXTENDED) == 0)
+    {
+      *insnp |= (((long) val & ((1 << operand->bits) - 1))
+                << (operand->shift + shift));
+
+      if ((operand->flags & MN10200_OPERAND_REPEATED) != 0)
+       *insnp |= (((long) val & ((1 << operand->bits) - 1))
+                  << (operand->shift + shift + 2));
+    }
+  else
+    {
+      *extensionp |= (val >> 16) & 0xff;
+      *insnp |= val & 0xffff;
+    }
+}
+

 void
 void

-md_assemble (str)
-     char *str;
+md_assemble (char *str)

 {
   char *s;
   struct mn10200_opcode *opcode;
 {
   char *s;
   struct mn10200_opcode *opcode;


@@ -874,32 +977,32 @@ md_assemble (str)
            }
          else if (operand->flags & MN10200_OPERAND_PSW)
            {
            }
          else if (operand->flags & MN10200_OPERAND_PSW)
            {

-             char *start = input_line_pointer;
-             char c = get_symbol_end ();
+             char *start;
+             char c = get_symbol_name (&start);

 
              if (strcmp (start, "psw") != 0)
                {
 
              if (strcmp (start, "psw") != 0)
                {

-                 *input_line_pointer = c;
+                 (void) restore_line_pointer (c);

                  input_line_pointer = hold;
                  str = hold;
                  goto error;
                }
                  input_line_pointer = hold;
                  str = hold;
                  goto error;
                }

-             *input_line_pointer = c;
+             (void) restore_line_pointer (c);

              goto keep_going;
            }
          else if (operand->flags & MN10200_OPERAND_MDR)
            {
              goto keep_going;
            }
          else if (operand->flags & MN10200_OPERAND_MDR)
            {

-             char *start = input_line_pointer;
-             char c = get_symbol_end ();
+             char *start;
+             char c = get_symbol_name (&start);

 
              if (strcmp (start, "mdr") != 0)
                {
 
              if (strcmp (start, "mdr") != 0)
                {

-                 *input_line_pointer = c;
+                 (void) restore_line_pointer (c);

                  input_line_pointer = hold;
                  str = hold;
                  goto error;
                }
                  input_line_pointer = hold;
                  str = hold;
                  goto error;
                }

-             *input_line_pointer = c;
+             (void) restore_line_pointer (c);

              goto keep_going;
            }
          else if (data_register_name (&ex))
              goto keep_going;
            }
          else if (data_register_name (&ex))


@@ -957,7 +1060,7 @@ md_assemble (str)
                extra_shift = 0;
 
              mn10200_insert_operand (&insn, &extension, operand,
                extra_shift = 0;
 
              mn10200_insert_operand (&insn, &extension, operand,

-                                     ex.X_add_number, (char *) NULL,
+                                     ex.X_add_number, NULL,

                                      0, extra_shift);
 
              break;
                                      0, extra_shift);
 
              break;


@@ -976,7 +1079,7 @@ md_assemble (str)
                }
 
              mn10200_insert_operand (&insn, &extension, operand,
                }
 
              mn10200_insert_operand (&insn, &extension, operand,

-                                     ex.X_add_number, (char *) NULL,
+                                     ex.X_add_number, NULL,

                                      0, 0);
              break;
 
                                      0, 0);
              break;
 


@@ -1000,7 +1103,7 @@ md_assemble (str)
              break;
            }
 
              break;
            }
 

-keep_going:
+       keep_going:

          str = input_line_pointer;
          input_line_pointer = hold;
 
          str = input_line_pointer;
          input_line_pointer = hold;
 


@@ -1051,9 +1154,21 @@ keep_going:
     abort ();
 
   /* Write out the instruction.  */
     abort ();
 
   /* Write out the instruction.  */

-
+  dwarf2_emit_insn (size);

   if (relaxable && fc > 0)
     {
   if (relaxable && fc > 0)
     {

+      /* On a 64-bit host the size of an 'int' is not the same
+        as the size of a pointer, so we need a union to convert
+        the opindex field of the fr_cgen structure into a char *
+        so that it can be stored in the frag.  We do not have
+        to worry about losing accuracy as we are not going to
+        be even close to the 32bit limit of the int.  */
+      union
+      {
+       int opindex;
+       char * ptr;
+      }
+      opindex_converter;

       int type;
 
       /* bCC  */
       int type;
 
       /* bCC  */


@@ -1081,10 +1196,11 @@ keep_going:
       else
        type = 3;
 
       else
        type = 3;
 

+      opindex_converter.opindex = fixups[0].opindex;

       f = frag_var (rs_machine_dependent, 8, 8 - size, type,
                    fixups[0].exp.X_add_symbol,
                    fixups[0].exp.X_add_number,
       f = frag_var (rs_machine_dependent, 8, 8 - size, type,
                    fixups[0].exp.X_add_symbol,
                    fixups[0].exp.X_add_number,

-                   (char *)fixups[0].opindex);
+                   opindex_converter.ptr);

       number_to_chars_bigendian (f, insn, size);
       if (8 - size > 4)
        {
       number_to_chars_bigendian (f, insn, size);
       if (8 - size > 4)
        {


@@ -1094,7 +1210,6 @@ keep_going:
       else
        number_to_chars_bigendian (f + size, 0, 8 - size);
     }
       else
        number_to_chars_bigendian (f + size, 0, 8 - size);
     }

-

   else
     {
       f = frag_more (size);
   else
     {
       f = frag_more (size);


@@ -1118,20 +1233,18 @@ keep_going:
          number_to_chars_littleendian (f + 4, extension & 0xff, 1);
        }
       else
          number_to_chars_littleendian (f + 4, extension & 0xff, 1);
        }
       else

-       {
-         number_to_chars_bigendian (f, insn, size > 4 ? 4 : size);
-       }
+       number_to_chars_bigendian (f, insn, size > 4 ? 4 : size);

 
       /* Create any fixups.  */
       for (i = 0; i < fc; i++)
        {
          const struct mn10200_operand *operand;
 
       /* Create any fixups.  */
       for (i = 0; i < fc; i++)
        {
          const struct mn10200_operand *operand;

+         int reloc_size;

 
          operand = &mn10200_operands[fixups[i].opindex];
          if (fixups[i].reloc != BFD_RELOC_UNUSED)
            {
              reloc_howto_type *reloc_howto;
 
          operand = &mn10200_operands[fixups[i].opindex];
          if (fixups[i].reloc != BFD_RELOC_UNUSED)
            {
              reloc_howto_type *reloc_howto;

-             int size;

              int offset;
              fixS *fixP;
 
              int offset;
              fixS *fixP;
 


@@ -1141,14 +1254,14 @@ keep_going:
              if (!reloc_howto)
                abort ();
 
              if (!reloc_howto)
                abort ();
 

-             size = bfd_get_reloc_size (reloc_howto);
+             reloc_size = bfd_get_reloc_size (reloc_howto);

 
 

-             if (size < 1 || size > 4)
+             if (reloc_size < 1 || reloc_size > 4)

                abort ();
 
                abort ();
 

-             offset = 4 - size;
+             offset = 4 - reloc_size;

              fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,
              fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset,

-                                 size,
+                                 reloc_size,

                                  &fixups[i].exp,
                                  reloc_howto->pc_relative,
                                  fixups[i].reloc);
                                  &fixups[i].exp,
                                  reloc_howto->pc_relative,
                                  fixups[i].reloc);


@@ -1157,11 +1270,11 @@ keep_going:
                 next instruction, not from the start of the current
                 instruction.  */
              if (reloc_howto->pc_relative)
                 next instruction, not from the start of the current
                 instruction.  */
              if (reloc_howto->pc_relative)

-               fixP->fx_offset += size;
+               fixP->fx_offset += reloc_size;

            }
          else
            {
            }
          else
            {

-             int reloc, pcrel, reloc_size, offset;
+             int reloc, pcrel, offset;

              fixS *fixP;
 
              reloc = BFD_RELOC_NONE;
              fixS *fixP;
 
              reloc = BFD_RELOC_NONE;


@@ -1221,175 +1334,3 @@ keep_going:
        }
     }
 }
        }
     }
 }

-
-/* If while processing a fixup, a reloc really needs to be created
-   Then it is done here.  */
-
-arelent *
-tc_gen_reloc (seg, fixp)
-     asection *seg ATTRIBUTE_UNUSED;
-     fixS *fixp;
-{
-  arelent *reloc;
-  reloc = (arelent *) xmalloc (sizeof (arelent));
-
-  if (fixp->fx_subsy != NULL)
-    {
-      if (S_GET_SEGMENT (fixp->fx_addsy) == S_GET_SEGMENT (fixp->fx_subsy)
-         && S_IS_DEFINED (fixp->fx_subsy))
-       {
-         fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
-         fixp->fx_subsy = NULL;
-       }
-      else
-       /* FIXME: We should try more ways to resolve difference expressions
-          here.  At least this is better than silently ignoring the
-          subtrahend.  */
-       as_bad_where (fixp->fx_file, fixp->fx_line,
-                     _("can't resolve `%s' {%s section} - `%s' {%s section}"),
-                     fixp->fx_addsy ? S_GET_NAME (fixp->fx_addsy) : "0",
-                     segment_name (fixp->fx_addsy
-                                   ? S_GET_SEGMENT (fixp->fx_addsy)
-                                   : absolute_section),
-                     S_GET_NAME (fixp->fx_subsy),
-                     segment_name (S_GET_SEGMENT (fixp->fx_addsy)));
-    }
-
-  reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
-  if (reloc->howto == (reloc_howto_type *) NULL)
-    {
-      as_bad_where (fixp->fx_file, fixp->fx_line,
-                   _("reloc %d not supported by object file format"),
-                   (int) fixp->fx_r_type);
-      return NULL;
-    }
-  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
-  reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
-  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
-  reloc->addend = fixp->fx_offset;
-  return reloc;
-}
-
-int
-md_estimate_size_before_relax (fragp, seg)
-     fragS *fragp;
-     asection *seg;
-{
-  if (fragp->fr_subtype == 6
-      && (!S_IS_DEFINED (fragp->fr_symbol)
-         || seg != S_GET_SEGMENT (fragp->fr_symbol)))
-    fragp->fr_subtype = 7;
-  else if (fragp->fr_subtype == 8
-          && (!S_IS_DEFINED (fragp->fr_symbol)
-              || seg != S_GET_SEGMENT (fragp->fr_symbol)))
-    fragp->fr_subtype = 10;
-
-  if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
-    abort ();
-
-  return md_relax_table[fragp->fr_subtype].rlx_length;
-}
-
-long
-md_pcrel_from (fixp)
-     fixS *fixp;
-{
-  return fixp->fx_frag->fr_address;
-}
-
-void
-md_apply_fix3 (fixP, valP, seg)
-     fixS * fixP;
-     valueT * valP ATTRIBUTE_UNUSED;
-     segT seg ATTRIBUTE_UNUSED;
-{
-  /* We shouldn't ever get here because linkrelax is nonzero.  */
-  abort ();
-  fixP->fx_done = 1;
-}
-
-/* Insert an operand value into an instruction.  */
-
-static void
-mn10200_insert_operand (insnp, extensionp, operand, val, file, line, shift)
-     unsigned long *insnp;
-     unsigned long *extensionp;
-     const struct mn10200_operand *operand;
-     offsetT val;
-     char *file;
-     unsigned int line;
-     unsigned int shift;
-{
-  /* No need to check 24 or 32bit operands for a bit.  */
-  if (operand->bits < 24
-      && (operand->flags & MN10200_OPERAND_NOCHECK) == 0)
-    {
-      long min, max;
-      offsetT test;
-
-      if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)
-       {
-         max = (1 << (operand->bits - 1)) - 1;
-         min = - (1 << (operand->bits - 1));
-       }
-      else
-       {
-         max = (1 << operand->bits) - 1;
-         min = 0;
-       }
-
-      test = val;
-
-      if (test < (offsetT) min || test > (offsetT) max)
-       as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line);
-    }
-
-  if ((operand->flags & MN10200_OPERAND_EXTENDED) == 0)
-    {
-      *insnp |= (((long) val & ((1 << operand->bits) - 1))
-                << (operand->shift + shift));
-
-      if ((operand->flags & MN10200_OPERAND_REPEATED) != 0)
-       *insnp |= (((long) val & ((1 << operand->bits) - 1))
-                  << (operand->shift + shift + 2));
-    }
-  else
-    {
-      *extensionp |= (val >> 16) & 0xff;
-      *insnp |= val & 0xffff;
-    }
-}
-
-static unsigned long
-check_operand (insn, operand, val)
-     unsigned long insn ATTRIBUTE_UNUSED;
-     const struct mn10200_operand *operand;
-     offsetT val;
-{
-  /* No need to check 24bit or 32bit operands for a bit.  */
-  if (operand->bits < 24
-      && (operand->flags & MN10200_OPERAND_NOCHECK) == 0)
-    {
-      long min, max;
-      offsetT test;
-
-      if ((operand->flags & MN10200_OPERAND_SIGNED) != 0)
-       {
-         max = (1 << (operand->bits - 1)) - 1;
-         min = - (1 << (operand->bits - 1));
-       }
-      else
-       {
-         max = (1 << operand->bits) - 1;
-         min = 0;
-       }
-
-      test = val;
-
-      if (test < (offsetT) min || test > (offsetT) max)
-       return 0;
-      else
-       return 1;
-    }
-  return 1;
-}