include/opcode/

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

diff --git a/gas/config/tc-ns32k.c b/gas/config/tc-ns32k.c
index 1b35fb61332c79b62175d8d56fe53e650025e575..709a9bc18b9042179875f6711586e1d65eb9f307 100644 (file)
--- a/gas/config/tc-ns32k.c
+++ b/gas/config/tc-ns32k.c
@@ -1,13 +1,13 @@
 /* ns32k.c  -- Assemble on the National Semiconductor 32k series
    Copyright 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 /* ns32k.c  -- Assemble on the National Semiconductor 32k series
    Copyright 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

-   2001, 2002, 2003, 2005
+   2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009

    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
    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)
+   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,


@@ -22,8 +22,6 @@
 
 /*#define SHOW_NUM 1*//* Uncomment for debugging.  */
 
 
 /*#define SHOW_NUM 1*//* Uncomment for debugging.  */
 

-#include <stdio.h>
-

 #include "as.h"
 #include "opcode/ns32k.h"
 
 #include "as.h"
 #include "opcode/ns32k.h"
 


@@ -377,7 +375,7 @@ char disp_size[] =
 
 static int
 addr_mode (char *operand,
 
 static int
 addr_mode (char *operand,

-          addr_modeS *addr_modeP,
+          addr_modeS *addrmodeP,

           int recursive_level)
 {
   char *str;
           int recursive_level)
 {
   char *str;


@@ -387,16 +385,16 @@ addr_mode (char *operand,
   int j;
 
   mode = DEFAULT;              /* Default.  */
   int j;
 
   mode = DEFAULT;              /* Default.  */

-  addr_modeP->scaled_mode = 0; /* Why not.  */
-  addr_modeP->scaled_reg = 0;  /* If 0, not scaled index.  */
-  addr_modeP->float_flag = 0;
-  addr_modeP->am_size = 0;
-  addr_modeP->im_disp = 0;
-  addr_modeP->pcrel = 0;       /* Not set in this function.  */
-  addr_modeP->disp_suffix[0] = 0;
-  addr_modeP->disp_suffix[1] = 0;
-  addr_modeP->disp[0] = NULL;
-  addr_modeP->disp[1] = NULL;
+  addrmodeP->scaled_mode = 0;  /* Why not.  */
+  addrmodeP->scaled_reg = 0;   /* If 0, not scaled index.  */
+  addrmodeP->float_flag = 0;
+  addrmodeP->am_size = 0;
+  addrmodeP->im_disp = 0;
+  addrmodeP->pcrel = 0;        /* Not set in this function.  */
+  addrmodeP->disp_suffix[0] = 0;
+  addrmodeP->disp_suffix[1] = 0;
+  addrmodeP->disp[0] = NULL;
+  addrmodeP->disp[1] = NULL;

   str = operand;
 
   if (str[0] == 0)
   str = operand;
 
   if (str[0] == 0)


@@ -412,16 +410,16 @@ addr_mode (char *operand,
     case ABSOLUTE_PREFIX:
       if (str[strl - 1] == ']')
        break;
     case ABSOLUTE_PREFIX:
       if (str[strl - 1] == ']')
        break;

-      addr_modeP->mode = 21;   /* absolute */
-      addr_modeP->disp[0] = str + 1;
+      addrmodeP->mode = 21;    /* absolute */
+      addrmodeP->disp[0] = str + 1;

       return -1;
 #endif
 #ifdef IMMEDIATE_PREFIX
     case IMMEDIATE_PREFIX:
       if (str[strl - 1] == ']')
        break;
       return -1;
 #endif
 #ifdef IMMEDIATE_PREFIX
     case IMMEDIATE_PREFIX:
       if (str[strl - 1] == ']')
        break;

-      addr_modeP->mode = 20;   /* immediate */
-      addr_modeP->disp[0] = str + 1;
+      addrmodeP->mode = 20;    /* immediate */
+      addrmodeP->disp[0] = str + 1;

       return -1;
 #endif
     case '.':
       return -1;
 #endif
     case '.':


@@ -433,8 +431,8 @@ addr_mode (char *operand,
            case '+':
              if (str[2] != '\000')
                {
            case '+':
              if (str[2] != '\000')
                {

-                 addr_modeP->mode = 27;        /* pc-relative */
-                 addr_modeP->disp[0] = str + 2;
+                 addrmodeP->mode = 27; /* pc-relative */
+                 addrmodeP->disp[0] = str + 2;

                  return -1;
                }
            default:
                  return -1;
                }
            default:


@@ -448,7 +446,7 @@ addr_mode (char *operand,
        {
          if ((!strncmp (str, "ext(", 4)) && strl > 7)
            {                           /* external */
        {
          if ((!strncmp (str, "ext(", 4)) && strl > 7)
            {                           /* external */

-             addr_modeP->disp[0] = str + 4;
+             addrmodeP->disp[0] = str + 4;

              i = 0;
              j = 2;
              do
              i = 0;
              j = 2;
              do


@@ -466,8 +464,8 @@ addr_mode (char *operand,
                  return (0);
                }
              str[j] = '\000';          /* null terminate disp[0] */
                  return (0);
                }
              str[j] = '\000';          /* null terminate disp[0] */

-             addr_modeP->disp[1] = str + j + 2;
-             addr_modeP->mode = 22;
+             addrmodeP->disp[1] = str + j + 2;
+             addrmodeP->mode = 22;

              return -1;
            }
        }
              return -1;
            }
        }


@@ -485,12 +483,12 @@ addr_mode (char *operand,
       switch (str[0])
        {
        case 'f':
       switch (str[0])
        {
        case 'f':

-         addr_modeP->float_flag = 1;
+         addrmodeP->float_flag = 1;

          /* Drop through.  */
        case 'r':
          if (str[1] >= '0' && str[1] < '8')
            {
          /* Drop through.  */
        case 'r':
          if (str[1] >= '0' && str[1] < '8')
            {

-             addr_modeP->mode = str[1] - '0';
+             addrmodeP->mode = str[1] - '0';

              return -1;
            }
          break;
              return -1;
            }
          break;


@@ -502,7 +500,7 @@ addr_mode (char *operand,
     case 3:
       if (!strncmp (str, "tos", 3))
        {
     case 3:
       if (!strncmp (str, "tos", 3))
        {

-         addr_modeP->mode = 23;        /* TopOfStack */
+         addrmodeP->mode = 23; /* TopOfStack */

          return -1;
        }
       break;
          return -1;
        }
       break;


@@ -527,7 +525,7 @@ addr_mode (char *operand,
              if (mode != DEFAULT)
                {
                  /* Memory relative.  */
              if (mode != DEFAULT)
                {
                  /* Memory relative.  */

-                 addr_modeP->mode = mode;
+                 addrmodeP->mode = mode;

                  j = strl - 5;         /* Temp for end of disp[0].  */
                  i = 0;
 
                  j = strl - 5;         /* Temp for end of disp[0].  */
                  i = 0;
 


@@ -547,8 +545,8 @@ addr_mode (char *operand,
                      return (0);
                    }
 
                      return (0);
                    }
 

-                 addr_modeP->disp[1] = str;
-                 addr_modeP->disp[0] = str + strl + 1;
+                 addrmodeP->disp[1] = str;
+                 addrmodeP->disp[0] = str + strl + 1;

                  str[j] = '\000';      /* Null terminate disp[0] .  */
                  str[strl] = '\000';   /* Null terminate disp[1].  */
 
                  str[j] = '\000';      /* Null terminate disp[0] .  */
                  str[strl] = '\000';   /* Null terminate disp[1].  */
 


@@ -564,8 +562,8 @@ addr_mode (char *operand,
                  && str[strl - 2] < '8'
                  && str[strl - 4] == '(')
                {
                  && str[strl - 2] < '8'
                  && str[strl - 4] == '(')
                {

-                 addr_modeP->mode = str[strl - 2] - '0' + 8;
-                 addr_modeP->disp[0] = str;
+                 addrmodeP->mode = str[strl - 2] - '0' + 8;
+                 addrmodeP->disp[0] = str;

                  str[strl - 4] = 0;
                  return -1;            /* reg rel */
                }
                  str[strl - 4] = 0;
                  return -1;            /* reg rel */
                }


@@ -583,8 +581,8 @@ addr_mode (char *operand,
 
              if (mode != DEFAULT)
                {
 
              if (mode != DEFAULT)
                {

-                 addr_modeP->mode = mode;
-                 addr_modeP->disp[0] = str;
+                 addrmodeP->mode = mode;
+                 addrmodeP->disp[0] = str;

                  str[strl - 4] = '\0';
 
                  return -1;            /* Memory space.  */
                  str[strl - 4] = '\0';
 
                  return -1;            /* Memory space.  */


@@ -624,27 +622,27 @@ addr_mode (char *operand,
              return 0;
            }
 
              return 0;
            }
 

-         addr_modeP->am_size += 1;     /* scaled index byte.  */
+         addrmodeP->am_size += 1;      /* scaled index byte.  */

          j = str[strl - 4] - '0';      /* store temporary.  */
          str[strl - 6] = '\000';       /* nullterminate for recursive call.  */
          j = str[strl - 4] - '0';      /* store temporary.  */
          str[strl - 6] = '\000';       /* nullterminate for recursive call.  */

-         i = addr_mode (str, addr_modeP, 1);
+         i = addr_mode (str, addrmodeP, 1);

 
 

-         if (!i || addr_modeP->mode == 20)
+         if (!i || addrmodeP->mode == 20)

            {
              as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
              return 0;
            }
 
            {
              as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
              return 0;
            }
 

-         addr_modeP->scaled_mode = addr_modeP->mode;   /* Store the inferior mode.  */
-         addr_modeP->mode = mode;
-         addr_modeP->scaled_reg = j + 1;
+         addrmodeP->scaled_mode = addrmodeP->mode;     /* Store the inferior mode.  */
+         addrmodeP->mode = mode;
+         addrmodeP->scaled_reg = j + 1;

 
          return -1;
        }
     }
 
 
          return -1;
        }
     }
 

-  addr_modeP->mode = DEFAULT;  /* Default to whatever.  */
-  addr_modeP->disp[0] = str;
+  addrmodeP->mode = DEFAULT;   /* Default to whatever.  */
+  addrmodeP->disp[0] = str;

 
   return -1;
 }
 
   return -1;
 }


@@ -667,13 +665,13 @@ evaluate_expr (expressionS *resultP, char *ptr)
    ns32k-opcode.  Also builds index bytes if needed.  */
 
 static int
    ns32k-opcode.  Also builds index bytes if needed.  */
 
 static int

-get_addr_mode (char *ptr, addr_modeS *addr_modeP)
+get_addr_mode (char *ptr, addr_modeS *addrmodeP)

 {
   int tmp;
 
 {
   int tmp;
 

-  addr_mode (ptr, addr_modeP, 0);
+  addr_mode (ptr, addrmodeP, 0);

 
 

-  if (addr_modeP->mode == DEFAULT || addr_modeP->scaled_mode == -1)
+  if (addrmodeP->mode == DEFAULT || addrmodeP->scaled_mode == -1)

     {
       /* Resolve ambiguous operands, this shouldn't be necessary if
         one uses standard NSC operand syntax. But the sequent
     {
       /* Resolve ambiguous operands, this shouldn't be necessary if
         one uses standard NSC operand syntax. But the sequent


@@ -681,19 +679,19 @@ get_addr_mode (char *ptr, addr_modeS *addr_modeP)
         if it is implicitly stated. See ns32k-opcode.h.  */
       (void) evaluate_expr (&exprP, ptr); /* This call takes time Sigh!  */
 
         if it is implicitly stated. See ns32k-opcode.h.  */
       (void) evaluate_expr (&exprP, ptr); /* This call takes time Sigh!  */
 

-      if (addr_modeP->mode == DEFAULT)
+      if (addrmodeP->mode == DEFAULT)

        {
          if (exprP.X_add_symbol || exprP.X_op_symbol)
        {
          if (exprP.X_add_symbol || exprP.X_op_symbol)

-           addr_modeP->mode = desc->default_model; /* We have a label.  */
+           addrmodeP->mode = desc->default_model; /* We have a label.  */

          else
          else

-           addr_modeP->mode = desc->default_modec; /* We have a constant.  */
+           addrmodeP->mode = desc->default_modec; /* We have a constant.  */

        }
       else
        {
          if (exprP.X_add_symbol || exprP.X_op_symbol)
        }
       else
        {
          if (exprP.X_add_symbol || exprP.X_op_symbol)

-           addr_modeP->scaled_mode = desc->default_model;
+           addrmodeP->scaled_mode = desc->default_model;

          else
          else

-           addr_modeP->scaled_mode = desc->default_modec;
+           addrmodeP->scaled_mode = desc->default_modec;

        }
 
       /* Must put this mess down in addr_mode to handle the scaled
        }
 
       /* Must put this mess down in addr_mode to handle the scaled


@@ -705,17 +703,17 @@ get_addr_mode (char *ptr, addr_modeS *addr_modeP)
      case.  Think it does so with local labels too, not optimum, pcrel
      is better.  When I have time I will make gas check this and
      select pcrel when possible Actually that is trivial.  */
      case.  Think it does so with local labels too, not optimum, pcrel
      is better.  When I have time I will make gas check this and
      select pcrel when possible Actually that is trivial.  */

-  if ((tmp = addr_modeP->scaled_reg))
+  if ((tmp = addrmodeP->scaled_reg))

     {                          /* Build indexbyte.  */
       tmp--;                   /* Remember regnumber comes incremented for
                                   flagpurpose.  */
     {                          /* Build indexbyte.  */
       tmp--;                   /* Remember regnumber comes incremented for
                                   flagpurpose.  */

-      tmp |= addr_modeP->scaled_mode << 3;
-      addr_modeP->index_byte = (char) tmp;
-      addr_modeP->am_size += 1;
+      tmp |= addrmodeP->scaled_mode << 3;
+      addrmodeP->index_byte = (char) tmp;
+      addrmodeP->am_size += 1;

     }
 
     }
 

-  assert (addr_modeP->mode >= 0); 
-  if (disp_test[(unsigned int) addr_modeP->mode])
+  gas_assert (addrmodeP->mode >= 0); 
+  if (disp_test[(unsigned int) addrmodeP->mode])

     {
       char c;
       char suffix;
     {
       char c;
       char suffix;


@@ -725,23 +723,23 @@ get_addr_mode (char *ptr, addr_modeS *addr_modeP)
       char *fromP;
 
       /* There was a displacement, probe for length  specifying suffix.  */
       char *fromP;
 
       /* There was a displacement, probe for length  specifying suffix.  */

-      addr_modeP->pcrel = 0;
+      addrmodeP->pcrel = 0;

 
 

-      assert(addr_modeP->mode >= 0);
-      if (disp_test[(unsigned int) addr_modeP->mode])
+      gas_assert (addrmodeP->mode >= 0);
+      if (disp_test[(unsigned int) addrmodeP->mode])

        {
          /* There is a displacement.  */
        {
          /* There is a displacement.  */

-         if (addr_modeP->mode == 27 || addr_modeP->scaled_mode == 27)
+         if (addrmodeP->mode == 27 || addrmodeP->scaled_mode == 27)

            /* Do we have pcrel. mode.  */
            /* Do we have pcrel. mode.  */

-           addr_modeP->pcrel = 1;
+           addrmodeP->pcrel = 1;

 
 

-         addr_modeP->im_disp = 1;
+         addrmodeP->im_disp = 1;

 
          for (i = 0; i < 2; i++)
            {
              suffix_sub = suffix = 0;
 
 
          for (i = 0; i < 2; i++)
            {
              suffix_sub = suffix = 0;
 

-             if ((toP = addr_modeP->disp[i]))
+             if ((toP = addrmodeP->disp[i]))

                {
                  /* Suffix of expression, the largest size rules.  */
                  fromP = toP;
                {
                  /* Suffix of expression, the largest size rules.  */
                  fromP = toP;


@@ -780,23 +778,23 @@ get_addr_mode (char *ptr, addr_modeS *addr_modeP)
                    }
 
                  *toP = '\0'; /* Terminate properly.  */
                    }
 
                  *toP = '\0'; /* Terminate properly.  */

-                 addr_modeP->disp_suffix[i] = suffix;
-                 addr_modeP->am_size += suffix ? suffix : 4;
+                 addrmodeP->disp_suffix[i] = suffix;
+                 addrmodeP->am_size += suffix ? suffix : 4;

                }
            }
        }
     }
   else
     {
                }
            }
        }
     }
   else
     {

-      if (addr_modeP->mode == 20)
+      if (addrmodeP->mode == 20)

        {
          /* Look in ns32k_opcode for size.  */
        {
          /* Look in ns32k_opcode for size.  */

-         addr_modeP->disp_suffix[0] = addr_modeP->am_size = desc->im_size;
-         addr_modeP->im_disp = 0;
+         addrmodeP->disp_suffix[0] = addrmodeP->am_size = desc->im_size;
+         addrmodeP->im_disp = 0;

        }
     }
 
        }
     }
 

-  return addr_modeP->mode;
+  return addrmodeP->mode;

 }
 
 /* Read an optionlist.  */
 }
 
 /* Read an optionlist.  */


@@ -882,7 +880,7 @@ bit_fix_new (int size,              /* Length of bitfield.  */
 {
   bit_fixS *bit_fixP;
 
 {
   bit_fixS *bit_fixP;
 

-  bit_fixP = (bit_fixS *) obstack_alloc (&notes, sizeof (bit_fixS));
+  bit_fixP = obstack_alloc (&notes, sizeof (bit_fixS));

 
   bit_fixP->fx_bit_size = size;
   bit_fixP->fx_bit_offset = offset;
 
   bit_fixP->fx_bit_size = size;
   bit_fixP->fx_bit_offset = offset;


@@ -1243,13 +1241,12 @@ parse (const char *line, int recursive_level)
   return recursive_level;
 }
 \f
   return recursive_level;
 }
 \f

-#ifdef BFD_ASSEMBLER

 /* This functionality should really be in the bfd library.  */
 
 static bfd_reloc_code_real_type
 reloc (int size, int pcrel, int type)
 {
 /* This functionality should really be in the bfd library.  */
 
 static bfd_reloc_code_real_type
 reloc (int size, int pcrel, int type)
 {

-  int length, index;
+  int length, rel_index;

   bfd_reloc_code_real_type relocs[] =
   {
     BFD_RELOC_NS32K_IMM_8,
   bfd_reloc_code_real_type relocs[] =
   {
     BFD_RELOC_NS32K_IMM_8,


@@ -1292,10 +1289,10 @@ reloc (int size, int pcrel, int type)
       break;
     }
 
       break;
     }
 

-  index = length + 3 * pcrel + 6 * type;
+  rel_index = length + 3 * pcrel + 6 * type;

 
 

-  if (index >= 0 && (unsigned int) index < sizeof (relocs) / sizeof (relocs[0]))
-    return relocs[index];
+  if (rel_index >= 0 && (unsigned int) rel_index < sizeof (relocs) / sizeof (relocs[0]))
+    return relocs[rel_index];

 
   if (pcrel)
     as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),
 
   if (pcrel)
     as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),


@@ -1307,7 +1304,6 @@ reloc (int size, int pcrel, int type)
   return BFD_RELOC_NONE;
 
 }
   return BFD_RELOC_NONE;
 
 }

-#endif

 
 static void
 fix_new_ns32k (fragS *frag,            /* Which frag? */
 
 static void
 fix_new_ns32k (fragS *frag,            /* Which frag? */


@@ -1327,11 +1323,7 @@ fix_new_ns32k (fragS *frag,              /* Which frag? */
 {
   fixS *fixP = fix_new (frag, where, size, add_symbol,
                        offset, pcrel,
 {
   fixS *fixP = fix_new (frag, where, size, add_symbol,
                        offset, pcrel,

-#ifdef BFD_ASSEMBLER

                        bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
                        bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)

-#else
-                       NO_RELOC
-#endif

                        );
 
   fix_opcode_frag (fixP) = opcode_frag;
                        );
 
   fix_opcode_frag (fixP) = opcode_frag;


@@ -1359,11 +1351,7 @@ fix_new_ns32k_exp (fragS *frag,          /* Which frag? */
                   unsigned int opcode_offset)
 {
   fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel,
                   unsigned int opcode_offset)
 {
   fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel,

-#ifdef BFD_ASSEMBLER

                            bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
                            bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)

-#else
-                           NO_RELOC
-#endif

                            );
 
   fix_opcode_frag (fixP) = opcode_frag;
                            );
 
   fix_opcode_frag (fixP) = opcode_frag;


@@ -1873,7 +1861,7 @@ convert_iif (void)
                              size = 4;
                            else
                              {
                              size = 4;
                            else
                              {

-                               as_bad (_("Displacement to large for :d"));
+                               as_bad (_("Displacement too large for :d"));

                                size = 4;
                              }
                          }
                                size = 4;
                              }
                          }


@@ -1908,7 +1896,7 @@ md_begin (void)
 {
   /* Build a hashtable of the instructions.  */
   const struct ns32k_opcode *ptr;
 {
   /* Build a hashtable of the instructions.  */
   const struct ns32k_opcode *ptr;

-  const char *stat;
+  const char *status;

   const struct ns32k_opcode *endop;
 
   inst_hash_handle = hash_new ();
   const struct ns32k_opcode *endop;
 
   inst_hash_handle = hash_new ();


@@ -1916,18 +1904,15 @@ md_begin (void)
   endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]);
   for (ptr = ns32k_opcodes; ptr < endop; ptr++)
     {
   endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]);
   for (ptr = ns32k_opcodes; ptr < endop; ptr++)
     {

-      if ((stat = hash_insert (inst_hash_handle, ptr->name, (char *) ptr)))
+      if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr)))

        /* Fatal.  */
        /* Fatal.  */

-       as_fatal (_("Can't hash %s: %s"), ptr->name, stat);
+       as_fatal (_("Can't hash %s: %s"), ptr->name, status);

     }
 
   /* Some private space please!  */
   freeptr_static = (char *) malloc (PRIVATE_SIZE);
 }
 
     }
 
   /* Some private space please!  */
   freeptr_static = (char *) malloc (PRIVATE_SIZE);
 }
 

-/* Must be equal to MAX_PRECISON in atof-ieee.c.  */
-#define MAX_LITTLENUMS 6
-

 /* Turn the string pointed to by litP into a floating point constant
    of type TYPE, and emit the appropriate bytes.  The number of
    LITTLENUMS emitted is stored in *SIZEP.  An error message is
 /* Turn the string pointed to by litP into a floating point constant
    of type TYPE, and emit the appropriate bytes.  The number of
    LITTLENUMS emitted is stored in *SIZEP.  An error message is


@@ -1936,38 +1921,7 @@ md_begin (void)
 char *
 md_atof (int type, char *litP, int *sizeP)
 {
 char *
 md_atof (int type, char *litP, int *sizeP)
 {

-  int prec;
-  LITTLENUM_TYPE words[MAX_LITTLENUMS];
-  LITTLENUM_TYPE *wordP;
-  char *t;
-
-  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 * sizeof (LITTLENUM_TYPE);
-
-  for (wordP = words + prec; prec--;)
-    {
-      md_number_to_chars (litP, (long) (*--wordP), sizeof (LITTLENUM_TYPE));
-      litP += sizeof (LITTLENUM_TYPE);
-    }
-
-  return 0;
+  return ieee_md_atof (type, litP, sizeP, FALSE);

 }
 \f
 int
 }
 \f
 int


@@ -2047,17 +2001,10 @@ md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
 \f
 /* Convert a relaxed displacement to ditto in final output.  */
 
 \f
 /* Convert a relaxed displacement to ditto in final output.  */
 

-#ifndef BFD_ASSEMBLER
-void
-md_convert_frag (object_headers *headers,
-                segT sec,
-                fragS *fragP)
-#else

 void
 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
                 segT sec ATTRIBUTE_UNUSED,
                 fragS *fragP)
 void
 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
                 segT sec ATTRIBUTE_UNUSED,
                 fragS *fragP)

-#endif

 {
   long disp;
   long ext = 0;
 {
   long disp;
   long ext = 0;


@@ -2137,7 +2084,6 @@ md_estimate_size_before_relax (fragS *fragP, segT segment)
 
 int md_short_jump_size = 3;
 int md_long_jump_size = 5;
 
 int md_short_jump_size = 3;
 int md_long_jump_size = 5;

-const int md_reloc_size = 8;   /* Size of relocation record.  */

 
 void
 md_create_short_jump (char *ptr,
 
 void
 md_create_short_jump (char *ptr,


@@ -2275,8 +2221,6 @@ md_pcrel_from (fixS *fixP)
       return res;
 }
 
       return res;
 }
 

-#ifdef BFD_ASSEMBLER
-

 arelent *
 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 {
 arelent *
 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 {


@@ -2308,39 +2252,3 @@ tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 
   return rel;
 }
 
   return rel;
 }

-#else /* BFD_ASSEMBLER */
-
-#ifdef OBJ_AOUT
-void
-cons_fix_new_ns32k (char *where,
-                   struct fix *fixP,
-                   relax_addressT segment_address_in_file)
-{
-  /* In:  Length of relocation (or of address) in chars: 1, 2 or 4.
-     Out: GNU LD relocation length code: 0, 1, or 2.  */
-
-  static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
-  long r_symbolnum;
-
-  know (fixP->fx_addsy != NULL);
-
-  md_number_to_chars (where,
-       fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
-                     4);
-
-  r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
-                ? S_GET_TYPE (fixP->fx_addsy)
-                : fixP->fx_addsy->sy_number);
-
-  md_number_to_chars (where + 4,
-                     ((long) (r_symbolnum)
-                      | (long) (fixP->fx_pcrel << 24)
-                      | (long) (nbytes_r_length[fixP->fx_size] << 25)
-                      | (long) ((!S_IS_DEFINED (fixP->fx_addsy)) << 27)
-                      | (long) (fix_bsr (fixP) << 28)
-                      | (long) (fix_im_disp (fixP) << 29)),
-                     4);
-}
-
-#endif /* OBJ_AOUT */
-#endif /* BFD_ASSEMBLER */