[AArch64][SVE 20/32] Add support for tied operands

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

diff --git a/gas/config/tc-ns32k.c b/gas/config/tc-ns32k.c
index 1a8c3cb3eea8f3e0bfb54b3c163d6693fc0e46ba..a0db7690ace41741e97ed1cb25d0c4e07999f054 100644 (file)
--- a/gas/config/tc-ns32k.c
+++ b/gas/config/tc-ns32k.c
@@ -1,13 +1,11 @@
 /* ns32k.c  -- Assemble on the National Semiconductor 32k series
 /* ns32k.c  -- Assemble on the National Semiconductor 32k series

-   Copyright 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003, 2005
-   Free Software Foundation, Inc.
+   Copyright (C) 1987-2016 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,


@@ -22,8 +20,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"
 


@@ -106,7 +102,7 @@ const char FLT_CHARS[] = "fd";      /* We don't want to support lowercase,
 /* Internal structs.  */
 struct ns32k_option
 {
 /* Internal structs.  */
 struct ns32k_option
 {

-  char *pattern;
+  const char *pattern;

   unsigned long or;
   unsigned long and;
 };
   unsigned long or;
   unsigned long and;
 };


@@ -136,7 +132,6 @@ struct int_ins_form
 
 struct int_ins_form iif;
 expressionS exprP;
 
 struct int_ins_form iif;
 expressionS exprP;

-char *input_line_pointer;

 
 /* Description of the PARTs in IIF
   object[n]:
 
 /* Description of the PARTs in IIF
   object[n]:


@@ -377,7 +372,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 +382,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 +407,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 +428,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 +443,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 +461,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 +480,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 +497,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 +522,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 +542,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 +559,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 +578,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 +619,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 +662,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 +676,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 +700,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 +720,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 +775,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.  */


@@ -807,7 +802,7 @@ optlist (char *str,                 /* The string to extract options from.  */
         unsigned long *default_map)    /* Default pattern and output.  */
 {
   int i, j, k, strlen1, strlen2;
         unsigned long *default_map)    /* Default pattern and output.  */
 {
   int i, j, k, strlen1, strlen2;

-  char *patternP, *strP;
+  const char *patternP, *strP;

 
   strlen1 = strlen (str);
 
 
   strlen1 = strlen (str);
 


@@ -882,7 +877,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 = XOBNEW (&notes, 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;


@@ -1248,7 +1243,7 @@ parse (const char *line, int recursive_level)
 static bfd_reloc_code_real_type
 reloc (int size, int pcrel, int type)
 {
 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,


@@ -1291,10 +1286,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"),


@@ -1863,7 +1858,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;
                              }
                          }


@@ -1898,7 +1893,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 ();


@@ -1906,58 +1901,24 @@ 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!  */
     }
 
   /* Some private space please!  */

-  freeptr_static = (char *) malloc (PRIVATE_SIZE);
+  freeptr_static = XNEWVEC (char, 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
    returned, or NULL on OK.  */
 
 /* 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
    returned, or NULL on OK.  */
 

-char *
+const char *

 md_atof (int type, char *litP, int *sizeP)
 {
 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


@@ -2161,7 +2122,7 @@ struct option md_longopts[] =
 size_t md_longopts_size = sizeof (md_longopts);
 
 int
 size_t md_longopts_size = sizeof (md_longopts);
 
 int

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

 {
   switch (c)
     {
 {
   switch (c)
     {


@@ -2219,7 +2180,8 @@ void
 cons_fix_new_ns32k (fragS *frag,       /* Which frag? */
                    int where,          /* Where in that frag? */
                    int size,           /* 1, 2  or 4 usually.  */
 cons_fix_new_ns32k (fragS *frag,       /* Which frag? */
                    int where,          /* Where in that frag? */
                    int size,           /* 1, 2  or 4 usually.  */

-                   expressionS *exp)   /* Expression.  */
+                   expressionS *exp,   /* Expression.  */
+                   bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)

 {
   fix_new_ns32k_exp (frag, where, size, exp,
                     0, 2, 0, 0, 0, 0);
 {
   fix_new_ns32k_exp (frag, where, size, exp,
                     0, 2, 0, 0, 0, 0);


@@ -2265,8 +2227,8 @@ tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
 
   code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp));
 
 
   code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp));
 

-  rel = xmalloc (sizeof (arelent));
-  rel->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
+  rel = XNEW (arelent);
+  rel->sym_ptr_ptr = XNEW (asymbol *);

   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
   if (fixp->fx_pcrel)
   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
   if (fixp->fx_pcrel)