projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xtensa: gas: support optional immediate simcall parameter
[deliverable/binutils-gdb.git] / gas / config / tc-tic54x.c
diff --git a/gas/config/tc-tic54x.c b/gas/config/tc-tic54x.c
index 0a18756c5bbf277ab1c21d7211357cd359b8c0c7..736192a61712630d934dd4b0484fe104eb34212b 100644 (file)
--- a/gas/config/tc-tic54x.c
+++ b/gas/config/tc-tic54x.c
@@ -1,12 +1,12 @@
 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
-   Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1999-2020 Free Software Foundation, Inc.
    Contributed by Timothy Wall (twall@cygnus.com)
 
    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
    Contributed by Timothy Wall (twall@cygnus.com)
 
    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,8 +16,8 @@
 
    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
 
    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.  */
+   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 /* Texas Instruments TMS320C54X machine specific gas.
    Written by Timothy Wall (twall@alum.mit.edu).
 
 /* Texas Instruments TMS320C54X machine specific gas.
    Written by Timothy Wall (twall@alum.mit.edu).
@@ -44,15 +44,12 @@
    COFF1 limits section names to 8 characters.
    Some of the default behavior changed from COFF1 to COFF2.  */
 
    COFF1 limits section names to 8 characters.
    Some of the default behavior changed from COFF1 to COFF2.  */
 
-#include <stdlib.h>
-#include <limits.h>
-#include <errno.h>
 #include "as.h"
 #include "as.h"
+#include <limits.h>
 #include "safe-ctype.h"
 #include "sb.h"
 #include "macro.h"
 #include "subsegs.h"
 #include "safe-ctype.h"
 #include "sb.h"
 #include "macro.h"
 #include "subsegs.h"
-#include "struc-symbol.h"
 #include "opcode/tic54x.h"
 #include "obj-coff.h"
 #include <math.h>
 #include "opcode/tic54x.h"
 #include "obj-coff.h"
 #include <math.h>
@@ -82,7 +79,7 @@ static struct stag
 
 typedef struct _tic54x_insn
 {
 
 typedef struct _tic54x_insn
 {
-  const template *tm;          /* Opcode template.  */
+  const insn_template *tm;     /* Opcode template.  */
 
   char mnemonic[MAX_LINE];     /* Opcode name/mnemonic.  */
   char parmnemonic[MAX_LINE];   /* 2nd mnemonic of parallel insn.  */
 
   char mnemonic[MAX_LINE];     /* Opcode name/mnemonic.  */
   char parmnemonic[MAX_LINE];   /* 2nd mnemonic of parallel insn.  */
@@ -163,7 +160,7 @@ size_t md_longopts_size = sizeof (md_longopts);
 static int assembly_begun = 0;
 /* Addressing mode is not entirely implemented; the latest rev of the Other
    assembler doesn't seem to make any distinction whatsoever; all relocations
 static int assembly_begun = 0;
 /* Addressing mode is not entirely implemented; the latest rev of the Other
    assembler doesn't seem to make any distinction whatsoever; all relocations
-   are stored as extended relocatiosn.  Older versions used REL16 vs RELEXT16,
+   are stored as extended relocations.  Older versions used REL16 vs RELEXT16,
    but now it seems all relocations are RELEXT16.  We use all RELEXT16.
 
    The cpu version is kind of a waste of time as well.  There is one
    but now it seems all relocations are RELEXT16.  We use all RELEXT16.
 
    The cpu version is kind of a waste of time as well.  There is one
@@ -188,7 +185,8 @@ static struct hash_control *subsym_recurse_hash; /* Prevent infinite recurse.  *
 static struct hash_control *math_hash; /* Built-in math functions.  */
 /* Allow maximum levels of macro nesting; level 0 is the main substitution
    symbol table.  The other assembler only does 32 levels, so there!  */
 static struct hash_control *math_hash; /* Built-in math functions.  */
 /* Allow maximum levels of macro nesting; level 0 is the main substitution
    symbol table.  The other assembler only does 32 levels, so there!  */
-static struct hash_control *subsym_hash[100];
+#define MAX_SUBSYM_HASH 100
+static struct hash_control *subsym_hash[MAX_SUBSYM_HASH];
 
 /* Keep track of local labels so we can substitute them before GAS sees them
    since macros use their own 'namespace' for local labels, use a separate hash
 
 /* Keep track of local labels so we can substitute them before GAS sees them
    since macros use their own 'namespace' for local labels, use a separate hash
@@ -223,152 +221,38 @@ static struct hash_control *misc_symbol_hash;
       }                                                                \
   while (0)
 
       }                                                                \
   while (0)
 
-static void    tic54x_emit_char        PARAMS ((char));
-static fragS * frag_prev               PARAMS ((fragS *, segT));
-static fragS * bit_offset_frag         PARAMS ((fragS *, segT));
-static int     frag_bit_offset         PARAMS ((fragS *, segT));
-static char *  parse_expression        PARAMS ((char *, expressionS *));
-static void    tic54x_asg              PARAMS ((int));
-static void    tic54x_eval             PARAMS ((int));
-static void    tic54x_bss              PARAMS ((int));
-static void    stag_add_field_symbols  PARAMS ((struct stag *, const char *, bfd_vma, symbolS *, const char *));
-static void    stag_add_field          PARAMS ((struct stag *, const char *, bfd_vma, struct stag *));
-static void    tic54x_struct           PARAMS ((int));
-static void    tic54x_endstruct        PARAMS ((int));
-static void    tic54x_tag              PARAMS ((int));
-static void    tic54x_struct_field     PARAMS ((int));
-static void    tic54x_cons             PARAMS ((int));
-static void    tic54x_remove_local_label PARAMS ((const char *, PTR));
-static void    tic54x_clear_local_labels PARAMS ((int));
-static void    tic54x_sect             PARAMS ((int));
-static void    tic54x_space            PARAMS ((int));
-static void    tic54x_usect            PARAMS ((int));
-static enum cpu_version lookup_version PARAMS ((const char *));
-static void    set_cpu                 PARAMS ((enum cpu_version));
-static void    tic54x_version          PARAMS ((int));
-static void    tic54x_float_cons       PARAMS ((int));
-static void    tic54x_stringer         PARAMS ((int));
-static void    tic54x_p2align          PARAMS ((int));
-static void    tic54x_align_words      PARAMS ((int));
-static void    tic54x_field            PARAMS ((int));
-static int     tic54x_initialized_section PARAMS ((segT));
-static void    tic54x_clink            PARAMS ((int));
-static void    tic54x_set_default_include PARAMS ((int));
-static void    tic54x_include          PARAMS ((int));
-static void    tic54x_message          PARAMS ((int));
-static void    tic54x_label            PARAMS ((int));
-static void    tic54x_mmregs           PARAMS ((int));
-static void    tic54x_loop             PARAMS ((int));
-static void    tic54x_endloop          PARAMS ((int));
-static void    tic54x_break            PARAMS ((int));
-static void    set_address_mode        PARAMS ((int));
-static void    tic54x_address_mode     PARAMS ((int));
-static void    tic54x_sblock           PARAMS ((int));
-static void    tic54x_set              PARAMS ((int));
-static void    tic54x_fclist           PARAMS ((int));
-static void    tic54x_sslist           PARAMS ((int));
-static void    tic54x_var              PARAMS ((int));
-static void    tic54x_mlib             PARAMS ((int));
-static int     subsym_symlen           PARAMS ((char *, char *));
-static int     subsym_symcmp           PARAMS ((char *, char *));
-static int     subsym_firstch          PARAMS ((char *, char *));
-static int     subsym_lastch           PARAMS ((char *, char *));
-static int     subsym_isdefed          PARAMS ((char *, char *));
-static int     subsym_ismember         PARAMS ((char *, char *));
-static int     subsym_iscons           PARAMS ((char *, char *));
-static int     subsym_isname           PARAMS ((char *, char *));
-static int     subsym_isreg            PARAMS ((char *, char *));
-static int     subsym_structsz         PARAMS ((char *, char *));
-static int     subsym_structacc        PARAMS ((char *, char *));
-static float   math_ceil               PARAMS ((float, float));
-static float   math_cvi                PARAMS ((float, float));
-static float   math_floor              PARAMS ((float, float));
-static float   math_fmod               PARAMS ((float, float));
-static float   math_int                PARAMS ((float, float));
-static float   math_round              PARAMS ((float, float));
-static float   math_sgn                PARAMS ((float, float));
-static float   math_trunc              PARAMS ((float, float));
-static float   math_acos               PARAMS ((float, float));
-static float   math_asin               PARAMS ((float, float));
-static float   math_atan               PARAMS ((float, float));
-static float   math_atan2              PARAMS ((float, float));
-static float   math_cosh               PARAMS ((float, float));
-static float   math_cos                PARAMS ((float, float));
-static float   math_cvf                PARAMS ((float, float));
-static float   math_exp                PARAMS ((float, float));
-static float   math_fabs               PARAMS ((float, float));
-static float   math_ldexp              PARAMS ((float, float));
-static float   math_log10              PARAMS ((float, float));
-static float   math_log                PARAMS ((float, float));
-static float   math_max                PARAMS ((float, float));
-static float   math_min                PARAMS ((float, float));
-static float   math_pow                PARAMS ((float, float));
-static float   math_sin                PARAMS ((float, float));
-static float   math_sinh               PARAMS ((float, float));
-static float   math_sqrt               PARAMS ((float, float));
-static float   math_tan                PARAMS ((float, float));
-static float   math_tanh               PARAMS ((float, float));
-static int     is_accumulator          PARAMS ((struct opstruct *));
-static int     get_operands            PARAMS ((struct opstruct operands[], char *));
-static int     is_immediate            PARAMS ((struct opstruct *));
-static int     is_absolute             PARAMS ((struct opstruct *));
-static int     is_indirect             PARAMS ((struct opstruct *));
-static int     is_dual                 PARAMS ((struct opstruct *));
-static int     is_mmreg                PARAMS ((struct opstruct *));
-static int     is_type                 PARAMS ((struct opstruct *, enum optype));
-static int     operands_match          PARAMS ((tic54x_insn *, struct opstruct *, int, const enum optype *, int, int));
-static int     encode_dmad             PARAMS ((tic54x_insn *, struct opstruct *, int));
-static int     encode_address          PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_indirect         PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_integer          PARAMS ((tic54x_insn *, struct opstruct *, int, int, int, unsigned short));
-static int     encode_condition        PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_cc3              PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_arx              PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_cc2              PARAMS ((tic54x_insn *, struct opstruct *));
-static int     encode_operand          PARAMS ((tic54x_insn *, enum optype, struct opstruct *));
-static void    emit_insn               PARAMS ((tic54x_insn *));
-static int     build_insn              PARAMS ((tic54x_insn *));
-static int     optimize_insn           PARAMS ((tic54x_insn *));
-static int     tic54x_parse_insn       PARAMS ((tic54x_insn *, char *));
-static int     next_line_shows_parallel PARAMS ((char *));
-static int     tic54x_parse_parallel_insn_firstline PARAMS ((tic54x_insn *, char *));
-static int     tic54x_parse_parallel_insn_lastline PARAMS ((tic54x_insn *, char *));
-static char *  subsym_get_arg          PARAMS ((char *, char *, char **, int));
-static void    subsym_create_or_replace PARAMS ((char *, char *));
-static char *  subsym_lookup           PARAMS ((char *, int));
-static char *  subsym_substitute       PARAMS ((char *, int));
+
+static void subsym_create_or_replace (char *, char *);
+static char *subsym_lookup (char *, int);
+static char *subsym_substitute (char *, int);
 
 
 void
 
 
 void
-md_show_usage (stream)
-     FILE *stream;
+md_show_usage (FILE *stream)
 {
 {
-  fprintf (stream, _("C54x-specific command line  options:\n"));
+  fprintf (stream, _("C54x-specific command line options:\n"));
   fprintf (stream, _("-mfar-mode | -mf          Use extended addressing\n"));
   fprintf (stream, _("-mcpu=<CPU version>       Specify the CPU version\n"));
   fprintf (stream, _("-merrors-to-file <filename>\n"));
   fprintf (stream, _("-me <filename>            Redirect errors to a file\n"));
 }
 
   fprintf (stream, _("-mfar-mode | -mf          Use extended addressing\n"));
   fprintf (stream, _("-mcpu=<CPU version>       Specify the CPU version\n"));
   fprintf (stream, _("-merrors-to-file <filename>\n"));
   fprintf (stream, _("-me <filename>            Redirect errors to a file\n"));
 }
 
-/* Output a single character (upper octect is zero).  */
+/* Output a single character (upper octet is zero).  */
 
 static void
 
 static void
-tic54x_emit_char (c)
-     char c;
+tic54x_emit_char (char c)
 {
 {
-  expressionS exp;
+  expressionS expn;
 
 
-  exp.X_op = O_constant;
-  exp.X_add_number = c;
-  emit_expr (&exp, 2);
+  expn.X_op = O_constant;
+  expn.X_add_number = c;
+  emit_expr (&expn, 2);
 }
 
 /* Walk backwards in the frag chain.  */
 
 static fragS *
 }
 
 /* Walk backwards in the frag chain.  */
 
 static fragS *
-frag_prev (frag, seg)
-     fragS *frag;
-     segT seg;
+frag_prev (fragS *frag, segT seg)
 {
   segment_info_type *seginfo = seg_info (seg);
   fragS *fragp;
 {
   segment_info_type *seginfo = seg_info (seg);
   fragS *fragp;
@@ -381,9 +265,7 @@ frag_prev (frag, seg)
 }
 
 static fragS *
 }
 
 static fragS *
-bit_offset_frag (frag, seg)
-     fragS *frag;
-     segT seg;
+bit_offset_frag (fragS *frag, segT seg)
 {
   while (frag != NULL)
     {
 {
   while (frag != NULL)
     {
@@ -401,9 +283,7 @@ bit_offset_frag (frag, seg)
    none. .field/.space/.bes may leave words partially allocated.  */
 
 static int
    none. .field/.space/.bes may leave words partially allocated.  */
 
 static int
-frag_bit_offset (frag, seg)
-     fragS *frag;
-     segT seg;
+frag_bit_offset (fragS *frag, segT seg)
 {
   frag = bit_offset_frag (frag, seg);
 
 {
   frag = bit_offset_frag (frag, seg);
 
@@ -417,16 +297,14 @@ frag_bit_offset (frag, seg)
    expression.  */
 
 static char *
    expression.  */
 
 static char *
-parse_expression (str, exp)
-     char *str;
-     expressionS * exp;
+parse_expression (char *str, expressionS *expn)
 {
   char *s;
   char *tmp;
 
   tmp = input_line_pointer;    /* Save line pointer.  */
   input_line_pointer = str;
 {
   char *s;
   char *tmp;
 
   tmp = input_line_pointer;    /* Save line pointer.  */
   input_line_pointer = str;
-  expression (exp);
+  expression (expn);
   s = input_line_pointer;
   input_line_pointer = tmp;    /* Restore line pointer.  */
   return s;                    /* Return pointer to where parsing stopped.  */
   s = input_line_pointer;
   input_line_pointer = tmp;    /* Restore line pointer.  */
   return s;                    /* Return pointer to where parsing stopped.  */
@@ -439,13 +317,11 @@ parse_expression (str, exp)
    unsupported.  */
 
 static void
    unsupported.  */
 
 static void
-tic54x_asg (x)
-     int x ATTRIBUTE_UNUSED;
+tic54x_asg (int x ATTRIBUTE_UNUSED)
 {
   int c;
   char *name;
   char *str;
 {
   int c;
   char *name;
   char *str;
-  char *tmp;
   int quoted = *input_line_pointer == '"';
 
   ILLEGAL_WITHIN_STRUCT ();
   int quoted = *input_line_pointer == '"';
 
   ILLEGAL_WITHIN_STRUCT ();
@@ -461,7 +337,7 @@ tic54x_asg (x)
       str = input_line_pointer;
       while ((c = *input_line_pointer) != ',')
        {
       str = input_line_pointer;
       while ((c = *input_line_pointer) != ',')
        {
-         if (is_end_of_line[(int) *input_line_pointer])
+         if (is_end_of_line[(unsigned char) c])
            break;
          ++input_line_pointer;
        }
            break;
          ++input_line_pointer;
        }
@@ -474,23 +350,19 @@ tic54x_asg (x)
       return;
     }
 
       return;
     }
 
-  name = ++input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
+  ++input_line_pointer;
+  c = get_symbol_name (&name); /* Get terminator.  */
   if (!ISALPHA (*name))
     {
   if (!ISALPHA (*name))
     {
-      as_bad ("symbols assigned with .asg must begin with a letter");
+      as_bad (_("symbols assigned with .asg must begin with a letter"));
       ignore_rest_of_line ();
       return;
     }
 
       ignore_rest_of_line ();
       return;
     }
 
-  tmp = xmalloc (strlen (str) + 1);
-  strcpy (tmp, str);
-  str = tmp;
-  tmp = xmalloc (strlen (name) + 1);
-  strcpy (tmp, name);
-  name = tmp;
+  str = xstrdup (str);
+  name = xstrdup (name);
   subsym_create_or_replace (name, str);
   subsym_create_or_replace (name, str);
-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);
   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 
@@ -501,8 +373,7 @@ tic54x_asg (x)
    table, since that's what works best.  */
 
 static void
    table, since that's what works best.  */
 
 static void
-tic54x_eval (x)
-     int x ATTRIBUTE_UNUSED;
+tic54x_eval (int x ATTRIBUTE_UNUSED)
 {
   char c;
   int value;
 {
   char c;
   int value;
@@ -535,11 +406,9 @@ tic54x_eval (x)
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
-  name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
-  tmp = xmalloc (strlen (name) + 1);
-  name = strcpy (tmp, name);
-  *input_line_pointer = c;
+  c = get_symbol_name (&name); /* Get terminator.  */
+  name = xstrdup (name);
+  (void) restore_line_pointer (c);
 
   if (!ISALPHA (*name))
     {
 
   if (!ISALPHA (*name))
     {
@@ -556,8 +425,7 @@ tic54x_eval (x)
      But since there's not written rule as to when, don't even bother trying
      to match their behavior.  */
   sprintf (valuestr, "%d", value);
      But since there's not written rule as to when, don't even bother trying
      to match their behavior.  */
   sprintf (valuestr, "%d", value);
-  tmp = xmalloc (strlen (valuestr) + 1);
-  strcpy (tmp, valuestr);
+  tmp = xstrdup (valuestr);
   subsym_create_or_replace (name, tmp);
 
   demand_empty_rest_of_line ();
   subsym_create_or_replace (name, tmp);
 
   demand_empty_rest_of_line ();
@@ -578,8 +446,7 @@ tic54x_eval (x)
       (not yet implemented).  */
 
 static void
       (not yet implemented).  */
 
 static void
-tic54x_bss (x)
-     int x ATTRIBUTE_UNUSED;
+tic54x_bss (int x ATTRIBUTE_UNUSED)
 {
   char c;
   char *name;
 {
   char c;
   char *name;
@@ -596,11 +463,12 @@ tic54x_bss (x)
   current_seg = now_seg;       /* Save current seg.  */
   current_subseg = now_subseg; /* Save current subseg.  */
 
   current_seg = now_seg;       /* Save current seg.  */
   current_subseg = now_subseg; /* Save current subseg.  */
 
-  name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
+  c = get_symbol_name (&name); /* Get terminator.  */
+  if (c == '"')
+    c = * ++ input_line_pointer;
   if (c != ',')
     {
   if (c != ',')
     {
-      as_bad (".bss size argument missing\n");
+      as_bad (_(".bss size argument missing\n"));
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
@@ -609,7 +477,7 @@ tic54x_bss (x)
   words = get_absolute_expression ();
   if (words < 0)
     {
   words = get_absolute_expression ();
   if (words < 0)
     {
-      as_bad (".bss size %d < 0!", words);
+      as_bad (_(".bss size %d < 0!"), words);
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
@@ -638,7 +506,7 @@ tic54x_bss (x)
   symbolP = symbol_find_or_make (name);
 
   if (S_GET_SEGMENT (symbolP) == bss_section)
   symbolP = symbol_find_or_make (name);
 
   if (S_GET_SEGMENT (symbolP) == bss_section)
-    symbolP->sy_frag->fr_symbol = (symbolS *) NULL;
+    symbol_get_frag (symbolP)->fr_symbol = (symbolS *) NULL;
 
   symbol_set_frag (symbolP, frag_now);
   p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
 
   symbol_set_frag (symbolP, frag_now);
   p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
@@ -668,28 +536,22 @@ tic54x_bss (x)
 }
 
 static void
 }
 
 static void
-stag_add_field_symbols (stag, path, base_offset, rootsym, root_stag_name)
-     struct stag *stag;
-     const char *path;
-     bfd_vma base_offset;
-     symbolS *rootsym;
-     const char *root_stag_name;
-{
-  char prefix[strlen (path) + 2];
+stag_add_field_symbols (struct stag *stag,
+                       const char *path,
+                       bfd_vma base_offset,
+                       symbolS *rootsym,
+                       const char *root_stag_name)
+{
+  char * prefix;
   struct stag_field *field = stag->field;
 
   /* Construct a symbol for every field contained within this structure
      including fields within structure fields.  */
   struct stag_field *field = stag->field;
 
   /* Construct a symbol for every field contained within this structure
      including fields within structure fields.  */
-  strcpy (prefix, path);
-  if (*path)
-    strcat (prefix, ".");
+  prefix = concat (path, *path ? "." : "", NULL);
 
   while (field != NULL)
     {
 
   while (field != NULL)
     {
-      int len = strlen (prefix) + strlen (field->name) + 2;
-      char *name = xmalloc (len);
-      strcpy (name, prefix);
-      strcat (name, field->name);
+      char *name = concat (prefix, field->name, NULL);
 
       if (rootsym == NULL)
        {
 
       if (rootsym == NULL)
        {
@@ -703,12 +565,10 @@ stag_add_field_symbols (stag, path, base_offset, rootsym, root_stag_name)
        }
       else
        {
        }
       else
        {
-         char *replacement = xmalloc (strlen (name)
-                                      + strlen (stag->name) + 2);
-         strcpy (replacement, S_GET_NAME (rootsym));
-         strcat (replacement, "+");
-         strcat (replacement, root_stag_name);
-         strcat (replacement, name + strlen (S_GET_NAME (rootsym)));
+         char *replacement;
+
+         replacement = concat (S_GET_NAME (rootsym), "+", root_stag_name,
+                               name + strlen (S_GET_NAME (rootsym)), NULL);
          hash_insert (subsym_hash[0], name, replacement);
        }
 
          hash_insert (subsym_hash[0], name, replacement);
        }
 
@@ -719,23 +579,23 @@ stag_add_field_symbols (stag, path, base_offset, rootsym, root_stag_name)
                                field->offset,
                                rootsym, root_stag_name);
       field = field->next;
                                field->offset,
                                rootsym, root_stag_name);
       field = field->next;
+      free (name);
     }
     }
+  free (prefix);
 }
 
 /* Keep track of stag fields so that when structures are nested we can add the
    complete dereferencing symbols to the symbol table.  */
 
 static void
 }
 
 /* Keep track of stag fields so that when structures are nested we can add the
    complete dereferencing symbols to the symbol table.  */
 
 static void
-stag_add_field (parent, name, offset, stag)
-     struct stag *parent;
-     const char *name;
-     bfd_vma offset;
-     struct stag *stag;
+stag_add_field (struct stag *parent,
+               const char *name,
+               bfd_vma offset,
+               struct stag *stag)
 {
 {
-  struct stag_field *sfield = xmalloc (sizeof (struct stag_field));
+  struct stag_field *sfield = XCNEW (struct stag_field);
 
 
-  memset (sfield, 0, sizeof (*sfield));
-  sfield->name = strcpy (xmalloc (strlen (name) + 1), name);
+  sfield->name = xstrdup (name);
   sfield->offset = offset;
   sfield->bitfield_offset = parent->current_bitfield_offset;
   sfield->stag = stag;
   sfield->offset = offset;
   sfield->bitfield_offset = parent->current_bitfield_offset;
   sfield->stag = stag;
@@ -762,8 +622,7 @@ stag_add_field (parent, name, offset, stag)
    Start defining structure offsets (symbols in absolute section).  */
 
 static void
    Start defining structure offsets (symbols in absolute section).  */
 
 static void
-tic54x_struct (arg)
-     int arg;
+tic54x_struct (int arg)
 {
   int start_offset = 0;
   int is_union = arg;
 {
   int start_offset = 0;
   int is_union = arg;
@@ -787,7 +646,7 @@ tic54x_struct (arg)
     {
       /* Offset is ignored in inner structs.  */
       SKIP_WHITESPACE ();
     {
       /* Offset is ignored in inner structs.  */
       SKIP_WHITESPACE ();
-      if (!is_end_of_line[(int) *input_line_pointer])
+      if (!is_end_of_line[(unsigned char) *input_line_pointer])
        start_offset = get_absolute_expression ();
       else
        start_offset = 0;
        start_offset = get_absolute_expression ();
       else
        start_offset = 0;
@@ -796,8 +655,7 @@ tic54x_struct (arg)
   if (current_stag)
     {
       /* Nesting, link to outer one.  */
   if (current_stag)
     {
       /* Nesting, link to outer one.  */
-      current_stag->inner = (struct stag *) xmalloc (sizeof (struct stag));
-      memset (current_stag->inner, 0, sizeof (struct stag));
+      current_stag->inner = XCNEW (struct stag);
       current_stag->inner->outer = current_stag;
       current_stag = current_stag->inner;
       if (start_offset)
       current_stag->inner->outer = current_stag;
       current_stag = current_stag->inner;
       if (start_offset)
@@ -806,8 +664,7 @@ tic54x_struct (arg)
     }
   else
     {
     }
   else
     {
-      current_stag = (struct stag *) xmalloc (sizeof (struct stag));
-      memset (current_stag, 0, sizeof (struct stag));
+      current_stag = XCNEW (struct stag);
       abs_section_offset = start_offset;
     }
   current_stag->is_union = is_union;
       abs_section_offset = start_offset;
     }
   current_stag->is_union = is_union;
@@ -823,11 +680,12 @@ tic54x_struct (arg)
     }
   else
     {
     }
   else
     {
-      char label[strlen (S_GET_NAME (line_label)) + 1];
-      strcpy (label, S_GET_NAME (line_label));
-      current_stag->sym = symbol_new (label, absolute_section,
+      char * label = xstrdup (S_GET_NAME (line_label));
+      current_stag->sym = symbol_new (label,
+                                     absolute_section,
                                      (valueT) abs_section_offset,
                                      &zero_address_frag);
                                      (valueT) abs_section_offset,
                                      &zero_address_frag);
+      free (label);
     }
   current_stag->name = S_GET_NAME (current_stag->sym);
   SF_SET_LOCAL (current_stag->sym);
     }
   current_stag->name = S_GET_NAME (current_stag->sym);
   SF_SET_LOCAL (current_stag->sym);
@@ -843,8 +701,7 @@ tic54x_struct (arg)
    of the structure.  */
 
 static void
    of the structure.  */
 
 static void
-tic54x_endstruct (is_union)
-     int is_union;
+tic54x_endstruct (int is_union)
 {
   int size;
   const char *path =
 {
   int size;
   const char *path =
@@ -909,11 +766,10 @@ tic54x_endstruct (is_union)
    format on the existing allocated space.  */
 
 static void
    format on the existing allocated space.  */
 
 static void
-tic54x_tag (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_tag (int ignore ATTRIBUTE_UNUSED)
 {
 {
-  char *name = input_line_pointer;
-  int c = get_symbol_end ();
+  char *name;
+  int c = get_symbol_name (&name);
   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
 
   if (!stag)
   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
 
   if (!stag)
@@ -933,9 +789,9 @@ tic54x_tag (ignore)
     }
   else
     {
     }
   else
     {
-      char label[strlen (S_GET_NAME (line_label)) + 1];
+      char * label;
 
 
-      strcpy (label, S_GET_NAME (line_label));
+      label = xstrdup (S_GET_NAME (line_label));
       if (current_stag != NULL)
        stag_add_field (current_stag, label,
                        abs_section_offset - S_GET_VALUE (current_stag->sym),
       if (current_stag != NULL)
        stag_add_field (current_stag, label,
                        abs_section_offset - S_GET_VALUE (current_stag->sym),
@@ -948,18 +804,20 @@ tic54x_tag (ignore)
            {
              as_bad (_(".tag target '%s' undefined"), label);
              ignore_rest_of_line ();
            {
              as_bad (_(".tag target '%s' undefined"), label);
              ignore_rest_of_line ();
+             free (label);
              return;
            }
          stag_add_field_symbols (stag, S_GET_NAME (sym),
                                  S_GET_VALUE (stag->sym), sym, stag->name);
        }
              return;
            }
          stag_add_field_symbols (stag, S_GET_NAME (sym),
                                  S_GET_VALUE (stag->sym), sym, stag->name);
        }
+      free (label);
     }
 
   /* Bump by the struct size, but only if we're within a .struct section.  */
   if (current_stag != NULL && !current_stag->is_union)
     abs_section_offset += stag->size;
 
     }
 
   /* Bump by the struct size, but only if we're within a .struct section.  */
   if (current_stag != NULL && !current_stag->is_union)
     abs_section_offset += stag->size;
 
-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);
   demand_empty_rest_of_line ();
   line_label = NULL;
 }
   demand_empty_rest_of_line ();
   line_label = NULL;
 }
@@ -969,8 +827,7 @@ tic54x_tag (ignore)
    and .word.  */
 
 static void
    and .word.  */
 
 static void
-tic54x_struct_field (type)
-     int type;
+tic54x_struct_field (int type)
 {
   int size;
   int count = 1;
 {
   int size;
   int count = 1;
@@ -979,7 +836,7 @@ tic54x_struct_field (type)
   int longword_align = 0;
 
   SKIP_WHITESPACE ();
   int longword_align = 0;
 
   SKIP_WHITESPACE ();
-  if (!is_end_of_line[(int) *input_line_pointer])
+  if (!is_end_of_line[(unsigned char) *input_line_pointer])
     count = get_absolute_expression ();
 
   switch (type)
     count = get_absolute_expression ();
 
   switch (type)
@@ -1064,12 +921,13 @@ tic54x_struct_field (type)
     }
   else
     {
     }
   else
     {
-      char label[strlen (S_GET_NAME (line_label) + 1)];
+      char * label;
 
 
-      strcpy (label, S_GET_NAME (line_label));
+      label = xstrdup (S_GET_NAME (line_label));
       stag_add_field (current_stag, label,
                      abs_section_offset - S_GET_VALUE (current_stag->sym),
                      NULL);
       stag_add_field (current_stag, label,
                      abs_section_offset - S_GET_VALUE (current_stag->sym),
                      NULL);
+      free (label);
     }
 
   if (current_stag->is_union)
     }
 
   if (current_stag->is_union)
@@ -1089,8 +947,7 @@ tic54x_struct_field (type)
 /* Handle .byte, .word. .int, .long and all variants.  */
 
 static void
 /* Handle .byte, .word. .int, .long and all variants.  */
 
 static void
-tic54x_cons (type)
-     int type;
+tic54x_cons (int type)
 {
   unsigned int c;
   int octets;
 {
   unsigned int c;
   int octets;
@@ -1149,28 +1006,28 @@ tic54x_cons (type)
        }
       else
        {
        }
       else
        {
-         expressionS exp;
+         expressionS expn;
 
 
-         input_line_pointer = parse_expression (input_line_pointer, &exp);
-         if (exp.X_op == O_constant)
+         input_line_pointer = parse_expression (input_line_pointer, &expn);
+         if (expn.X_op == O_constant)
            {
            {
-             offsetT value = exp.X_add_number;
+             offsetT value = expn.X_add_number;
              /* Truncate overflows.  */
              switch (octets)
                {
                case 1:
                  if ((value > 0 && value > 0xFF)
                      || (value < 0 && value < - 0x100))
              /* Truncate overflows.  */
              switch (octets)
                {
                case 1:
                  if ((value > 0 && value > 0xFF)
                      || (value < 0 && value < - 0x100))
-                   as_warn ("Overflow in expression, truncated to 8 bits");
+                   as_warn (_("Overflow in expression, truncated to 8 bits"));
                  break;
                case 2:
                  if ((value > 0 && value > 0xFFFF)
                      || (value < 0 && value < - 0x10000))
                  break;
                case 2:
                  if ((value > 0 && value > 0xFFFF)
                      || (value < 0 && value < - 0x10000))
-                   as_warn ("Overflow in expression, truncated to 16 bits");
+                   as_warn (_("Overflow in expression, truncated to 16 bits"));
                  break;
                }
            }
                  break;
                }
            }
-         if (exp.X_op != O_constant && octets < 2)
+         if (expn.X_op != O_constant && octets < 2)
            {
              /* Disallow .byte with a non constant expression that will
                 require relocation.  */
            {
              /* Disallow .byte with a non constant expression that will
                 require relocation.  */
@@ -1179,7 +1036,7 @@ tic54x_cons (type)
              return;
            }
 
              return;
            }
 
-         if (exp.X_op != O_constant
+         if (expn.X_op != O_constant
              && amode == c_mode
              && octets == 4)
            {
              && amode == c_mode
              && octets == 4)
            {
@@ -1190,14 +1047,14 @@ tic54x_cons (type)
                 totally ignored in the latest tools).  */
              amode = far_mode;
              emitting_long = 1;
                 totally ignored in the latest tools).  */
              amode = far_mode;
              emitting_long = 1;
-             emit_expr (&exp, 4);
+             emit_expr (&expn, 4);
              emitting_long = 0;
              amode = c_mode;
            }
          else
            {
              emitting_long = octets == 4;
              emitting_long = 0;
              amode = c_mode;
            }
          else
            {
              emitting_long = octets == 4;
-             emit_expr (&exp, (octets == 1) ? 2 : octets);
+             emit_expr (&expn, (octets == 1) ? 2 : octets);
              emitting_long = 0;
            }
        }
              emitting_long = 0;
            }
        }
@@ -1228,8 +1085,7 @@ tic54x_cons (type)
    these, so we ignore the type here.  */
 
 void
    these, so we ignore the type here.  */
 
 void
-tic54x_global (type)
-     int type;
+tic54x_global (int type)
 {
   char *name;
   int c;
 {
   char *name;
   int c;
@@ -1242,16 +1098,15 @@ tic54x_global (type)
 
   do
     {
 
   do
     {
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       symbolP = symbol_find_or_make (name);
       symbolP = symbol_find_or_make (name);
+      c = restore_line_pointer (c);
 
 
-      *input_line_pointer = c;
       S_SET_STORAGE_CLASS (symbolP, C_EXT);
       if (c == ',')
        {
          input_line_pointer++;
       S_SET_STORAGE_CLASS (symbolP, C_EXT);
       if (c == ',')
        {
          input_line_pointer++;
-         if (is_end_of_line[(int) *input_line_pointer])
+         if (is_end_of_line[(unsigned char) *input_line_pointer])
            c = *input_line_pointer;
        }
     }
            c = *input_line_pointer;
        }
     }
@@ -1263,19 +1118,16 @@ tic54x_global (type)
 /* Remove the symbol from the local label hash lookup.  */
 
 static void
 /* Remove the symbol from the local label hash lookup.  */
 
 static void
-tic54x_remove_local_label (key, value)
-     const char *key;
-     PTR value ATTRIBUTE_UNUSED;
+tic54x_remove_local_label (const char *key, void *value ATTRIBUTE_UNUSED)
 {
 {
-  PTR *elem = hash_delete (local_label_hash[macro_level], key);
+  void *elem = hash_delete (local_label_hash[macro_level], key, FALSE);
   free (elem);
 }
 
 /* Reset all local labels.  */
 
 static void
   free (elem);
 }
 
 /* Reset all local labels.  */
 
 static void
-tic54x_clear_local_labels (ignored)
-     int ignored ATTRIBUTE_UNUSED;
+tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED)
 {
   hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
 }
 {
   hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
 }
@@ -1294,8 +1146,7 @@ tic54x_clear_local_labels (ignored)
 */
 
 static void
 */
 
 static void
-tic54x_sect (arg)
-     int arg;
+tic54x_sect (int arg)
 {
   ILLEGAL_WITHIN_STRUCT ();
 
 {
   ILLEGAL_WITHIN_STRUCT ();
 
@@ -1310,27 +1161,27 @@ tic54x_sect (arg)
     {
       char *name = NULL;
       int len;
     {
       char *name = NULL;
       int len;
+      /* Make sure all named initialized sections flagged properly.  If we
+         encounter instructions, we'll flag it with SEC_CODE as well.  */
+      const char *flags = ",\"w\"\n";
 
       /* If there are quotes, remove them.  */
       if (*input_line_pointer == '"')
        {
          name = demand_copy_C_string (&len);
          demand_empty_rest_of_line ();
 
       /* If there are quotes, remove them.  */
       if (*input_line_pointer == '"')
        {
          name = demand_copy_C_string (&len);
          demand_empty_rest_of_line ();
-         name = strcpy (xmalloc (len + 10), name);
+         name = concat (name, flags, (char *) NULL);
        }
       else
        {
          int c;
        }
       else
        {
          int c;
-         name = input_line_pointer;
-         c = get_symbol_end ();
-          len = strlen(name);
-         name = strcpy (xmalloc (len + 10), name);
-         *input_line_pointer = c;
+
+         c = get_symbol_name (&name);
+         name = concat (name, flags, (char *) NULL);
+         (void) restore_line_pointer (c);
          demand_empty_rest_of_line ();
        }
          demand_empty_rest_of_line ();
        }
-      /* Make sure all named initialized sections flagged properly.  If we
-         encounter instructions, we'll flag it with SEC_CODE as well.  */
-      strcat (name, ",\"w\"\n");
+
       input_scrub_insert_line (name);
       obj_coff_section (0);
 
       input_scrub_insert_line (name);
       obj_coff_section (0);
 
@@ -1356,10 +1207,9 @@ tic54x_sect (arg)
    cribbed from s_space.  */
 
 static void
    cribbed from s_space.  */
 
 static void
-tic54x_space (arg)
-     int arg;
+tic54x_space (int arg)
 {
 {
-  expressionS exp;
+  expressionS expn;
   char *p = 0;
   int octets = 0;
   long words;
   char *p = 0;
   int octets = 0;
   long words;
@@ -1375,22 +1225,21 @@ tic54x_space (arg)
 #endif
 
   /* Read the bit count.  */
 #endif
 
   /* Read the bit count.  */
-  expression (&exp);
+  expression (&expn);
 
   /* Some expressions are unresolvable until later in the assembly pass;
      postpone until relaxation/fixup.  we also have to postpone if a previous
      partial allocation has not been completed yet.  */
 
   /* Some expressions are unresolvable until later in the assembly pass;
      postpone until relaxation/fixup.  we also have to postpone if a previous
      partial allocation has not been completed yet.  */
-  if (exp.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1)
+  if (expn.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1)
     {
     {
-      struct bit_info *bi = xmalloc (sizeof (struct bit_info));
-      char *p;
+      struct bit_info *bi = XNEW (struct bit_info);
 
       bi->seg = now_seg;
       bi->type = bes;
       bi->sym = label;
       p = frag_var (rs_machine_dependent,
                    65536 * 2, 1, (relax_substateT) 0,
 
       bi->seg = now_seg;
       bi->type = bes;
       bi->sym = label;
       p = frag_var (rs_machine_dependent,
                    65536 * 2, 1, (relax_substateT) 0,
-                   make_expr_symbol (&exp), (offsetT) 0,
+                   make_expr_symbol (&expn), (offsetT) 0,
                    (char *) bi);
       if (p)
        *p = 0;
                    (char *) bi);
       if (p)
        *p = 0;
@@ -1405,7 +1254,7 @@ tic54x_space (arg)
     {
       int spare_bits = bits_per_byte - bit_offset;
 
     {
       int spare_bits = bits_per_byte - bit_offset;
 
-      if (spare_bits >= exp.X_add_number)
+      if (spare_bits >= expn.X_add_number)
        {
          /* Don't have to do anything; sufficient bits have already been
             allocated; just point the label to the right place.  */
        {
          /* Don't have to do anything; sufficient bits have already been
             allocated; just point the label to the right place.  */
@@ -1415,10 +1264,10 @@ tic54x_space (arg)
              S_SET_VALUE (label, frag_now_fix () - 1);
              label = NULL;
            }
              S_SET_VALUE (label, frag_now_fix () - 1);
              label = NULL;
            }
-         frag_now->tc_frag_data += exp.X_add_number;
+         frag_now->tc_frag_data += expn.X_add_number;
          goto getout;
        }
          goto getout;
        }
-      exp.X_add_number -= spare_bits;
+      expn.X_add_number -= spare_bits;
       /* Set the label to point to the first word allocated, which in this
         case is the previous word, which was only partially filled.  */
       if (!bes && label != NULL)
       /* Set the label to point to the first word allocated, which in this
         case is the previous word, which was only partially filled.  */
       if (!bes && label != NULL)
@@ -1429,9 +1278,9 @@ tic54x_space (arg)
        }
     }
   /* Convert bits to bytes/words and octets, rounding up.  */
        }
     }
   /* Convert bits to bytes/words and octets, rounding up.  */
-  words = ((exp.X_add_number + bits_per_byte - 1) / bits_per_byte);
+  words = ((expn.X_add_number + bits_per_byte - 1) / bits_per_byte);
   /* How many do we have left over?  */
   /* How many do we have left over?  */
-  bit_offset = exp.X_add_number % bits_per_byte;
+  bit_offset = expn.X_add_number % bits_per_byte;
   octets = words * OCTETS_PER_BYTE;
   if (octets < 0)
     {
   octets = words * OCTETS_PER_BYTE;
   if (octets < 0)
     {
@@ -1488,8 +1337,7 @@ tic54x_space (arg)
    Has no effect on the current section.  */
 
 static void
    Has no effect on the current section.  */
 
 static void
-tic54x_usect (x)
-     int x ATTRIBUTE_UNUSED;
+tic54x_usect (int x ATTRIBUTE_UNUSED)
 {
   char c;
   char *name;
 {
   char c;
   char *name;
@@ -1506,17 +1354,13 @@ tic54x_usect (x)
   current_seg = now_seg;       /* Save current seg.  */
   current_subseg = now_subseg; /* Save current subseg.  */
 
   current_seg = now_seg;       /* Save current seg.  */
   current_subseg = now_subseg; /* Save current subseg.  */
 
-  if (*input_line_pointer == '"')
-    input_line_pointer++;
-  section_name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
-  input_line_pointer++;                /* Skip null symbol terminator.  */
-  name = xmalloc (input_line_pointer - section_name + 1);
-  strcpy (name, section_name);
-
-  if (*input_line_pointer == ',')
+  c = get_symbol_name (&section_name); /* Get terminator.  */
+  name = xstrdup (section_name);
+  c = restore_line_pointer (c);
+  
+  if (c == ',')
     ++input_line_pointer;
     ++input_line_pointer;
-  else if (c != ',')
+  else
     {
       as_bad (_("Missing size argument"));
       ignore_rest_of_line ();
     {
       as_bad (_("Missing size argument"));
       ignore_rest_of_line ();
@@ -1547,7 +1391,7 @@ tic54x_usect (x)
     blocking_flag = alignment_flag = 0;
 
   seg = subseg_new (name, 0);
     blocking_flag = alignment_flag = 0;
 
   seg = subseg_new (name, 0);
-  flags = bfd_get_section_flags (stdoutput, seg) | SEC_ALLOC;
+  flags = bfd_section_flags (seg) | SEC_ALLOC;
 
   if (alignment_flag)
     {
 
   if (alignment_flag)
     {
@@ -1576,8 +1420,8 @@ tic54x_usect (x)
   if (blocking_flag)
     flags |= SEC_TIC54X_BLOCK;
 
   if (blocking_flag)
     flags |= SEC_TIC54X_BLOCK;
 
-  if (!bfd_set_section_flags (stdoutput, seg, flags))
-    as_warn ("Error setting flags for \"%s\": %s", name,
+  if (!bfd_set_section_flags (seg, flags))
+    as_warn (_("Error setting flags for \"%s\": %s"), name,
             bfd_errmsg (bfd_get_error ()));
 
   subseg_set (current_seg, current_subseg);    /* Restore current seg.  */
             bfd_errmsg (bfd_get_error ()));
 
   subseg_set (current_seg, current_subseg);    /* Restore current seg.  */
@@ -1585,8 +1429,7 @@ tic54x_usect (x)
 }
 
 static enum cpu_version
 }
 
 static enum cpu_version
-lookup_version (ver)
-     const char *ver;
+lookup_version (const char *ver)
 {
   enum cpu_version version = VNONE;
 
 {
   enum cpu_version version = VNONE;
 
@@ -1607,8 +1450,7 @@ lookup_version (ver)
 }
 
 static void
 }
 
 static void
-set_cpu (version)
-     enum cpu_version version;
+set_cpu (enum cpu_version version)
 {
   cpu = version;
   if (version == V545LP || version == V546LP)
 {
   cpu = version;
   if (version == V545LP || version == V546LP)
@@ -1635,8 +1477,7 @@ set_cpu (version)
 static int cpu_needs_set = 1;
 
 static void
 static int cpu_needs_set = 1;
 
 static void
-tic54x_version (x)
-     int x ATTRIBUTE_UNUSED;
+tic54x_version (int x ATTRIBUTE_UNUSED)
 {
   enum cpu_version version = VNONE;
   enum cpu_version old_version = cpu;
 {
   enum cpu_version version = VNONE;
   enum cpu_version old_version = cpu;
@@ -1647,7 +1488,7 @@ tic54x_version (x)
 
   SKIP_WHITESPACE ();
   ver = input_line_pointer;
 
   SKIP_WHITESPACE ();
   ver = input_line_pointer;
-  while (!is_end_of_line[(int) *input_line_pointer])
+  while (!is_end_of_line[(unsigned char) *input_line_pointer])
     ++input_line_pointer;
   c = *input_line_pointer;
   *input_line_pointer = 0;
     ++input_line_pointer;
   c = *input_line_pointer;
   *input_line_pointer = 0;
@@ -1679,8 +1520,7 @@ tic54x_version (x)
 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble.  */
 
 static void
 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble.  */
 
 static void
-tic54x_float_cons (type)
-     int type;
+tic54x_float_cons (int type)
 {
   if (current_stag != 0)
     tic54x_struct_field ('f');
 {
   if (current_stag != 0)
     tic54x_struct_field ('f');
@@ -1710,11 +1550,9 @@ tic54x_float_cons (type)
    and encoded into the correct octets.  */
 
 static void
    and encoded into the correct octets.  */
 
 static void
-tic54x_stringer (type)
-     int type;
+tic54x_stringer (int type)
 {
   unsigned int c;
 {
   unsigned int c;
-  char *start;
   int append_zero = type == 'S' || type == 'P';
   int packed = type == 'p' || type == 'P';
   int last_char = -1; /* Packed strings need two bytes at a time to encode.  */
   int append_zero = type == 'S' || type == 'P';
   int packed = type == 'p' || type == 'P';
   int last_char = -1; /* Packed strings need two bytes at a time to encode.  */
@@ -1744,7 +1582,6 @@ tic54x_stringer (type)
          }
        case '\"':
          ++input_line_pointer; /* -> 1st char of string.  */
          }
        case '\"':
          ++input_line_pointer; /* -> 1st char of string.  */
-         start = input_line_pointer;
          while (is_a_char (c = next_char_of_string ()))
            {
              if (!packed)
          while (is_a_char (c = next_char_of_string ()))
            {
              if (!packed)
@@ -1798,20 +1635,18 @@ tic54x_stringer (type)
 }
 
 static void
 }
 
 static void
-tic54x_p2align (arg)
-     int arg ATTRIBUTE_UNUSED;
+tic54x_p2align (int arg ATTRIBUTE_UNUSED)
 {
   as_bad (_("p2align not supported on this target"));
 }
 
 static void
 {
   as_bad (_("p2align not supported on this target"));
 }
 
 static void
-tic54x_align_words (arg)
-     int arg;
+tic54x_align_words (int arg)
 {
   /* Only ".align" with no argument is allowed within .struct/.union.  */
   int count = arg;
 
 {
   /* Only ".align" with no argument is allowed within .struct/.union.  */
   int count = arg;
 
-  if (!is_end_of_line[(int) *input_line_pointer])
+  if (!is_end_of_line[(unsigned char) *input_line_pointer])
     {
       if (arg == 2)
        as_warn (_("Argument to .even ignored"));
     {
       if (arg == 2)
        as_warn (_("Argument to .even ignored"));
@@ -1835,13 +1670,12 @@ tic54x_align_words (arg)
   s_align_bytes (count << 1);
 }
 
   s_align_bytes (count << 1);
 }
 
-/* Initialize multiple-bit fields withing a single word of memory.  */
+/* Initialize multiple-bit fields within a single word of memory.  */
 
 static void
 
 static void
-tic54x_field (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_field (int ignore ATTRIBUTE_UNUSED)
 {
 {
-  expressionS exp;
+  expressionS expn;
   int size = 16;
   char *p;
   valueT value;
   int size = 16;
   char *p;
   valueT value;
@@ -1853,7 +1687,7 @@ tic54x_field (ignore)
       return;
     }
 
       return;
     }
 
-  input_line_pointer = parse_expression (input_line_pointer, &exp);
+  input_line_pointer = parse_expression (input_line_pointer, &expn);
 
   if (*input_line_pointer == ',')
     {
 
   if (*input_line_pointer == ',')
     {
@@ -1868,7 +1702,7 @@ tic54x_field (ignore)
     }
 
   /* Truncate values to the field width.  */
     }
 
   /* Truncate values to the field width.  */
-  if (exp.X_op != O_constant)
+  if (expn.X_op != O_constant)
     {
       /* If the expression value is relocatable, the field size *must*
          be 16.  */
     {
       /* If the expression value is relocatable, the field size *must*
          be 16.  */
@@ -1880,17 +1714,17 @@ tic54x_field (ignore)
        }
 
       frag_now->tc_frag_data = 0;
        }
 
       frag_now->tc_frag_data = 0;
-      emit_expr (&exp, 2);
+      emit_expr (&expn, 2);
     }
   else
     {
       unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
 
     }
   else
     {
       unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
 
-      value = exp.X_add_number;
-      exp.X_add_number &= fmask;
-      if (value != (valueT) exp.X_add_number)
+      value = expn.X_add_number;
+      expn.X_add_number &= fmask;
+      if (value != (valueT) expn.X_add_number)
        as_warn (_("field value truncated"));
        as_warn (_("field value truncated"));
-      value = exp.X_add_number;
+      value = expn.X_add_number;
       /* Bits are stored MS first.  */
       while (size >= 16)
        {
       /* Bits are stored MS first.  */
       while (size >= 16)
        {
@@ -1906,7 +1740,7 @@ tic54x_field (ignore)
          fragS *alloc_frag = bit_offset_frag (frag_now, now_seg);
          if (bit_offset == -1)
            {
          fragS *alloc_frag = bit_offset_frag (frag_now, now_seg);
          if (bit_offset == -1)
            {
-             struct bit_info *bi = xmalloc (sizeof (struct bit_info));
+             struct bit_info *bi = XNEW (struct bit_info);
              /* We don't know the previous offset at this time, so store the
                 info we need and figure it out later.  */
              expressionS size_exp;
              /* We don't know the previous offset at this time, so store the
                 info we need and figure it out later.  */
              expressionS size_exp;
@@ -1962,8 +1796,7 @@ tic54x_field (ignore)
    available yet.  seg_info ()->bss is the next best thing.  */
 
 static int
    available yet.  seg_info ()->bss is the next best thing.  */
 
 static int
-tic54x_initialized_section (seg)
-     segT seg;
+tic54x_initialized_section (segT seg)
 {
   return !seg_info (seg)->bss;
 }
 {
   return !seg_info (seg)->bss;
 }
@@ -1976,8 +1809,7 @@ tic54x_initialized_section (seg)
    Name is required for uninitialized sections.  */
 
 static void
    Name is required for uninitialized sections.  */
 
 static void
-tic54x_clink (ignored)
-     int ignored ATTRIBUTE_UNUSED;
+tic54x_clink (int ignored ATTRIBUTE_UNUSED)
 {
   segT seg = now_seg;
 
 {
   segT seg = now_seg;
 
@@ -1992,8 +1824,7 @@ tic54x_clink (ignored)
        ;
       know (input_line_pointer[-1] == '\"');
       input_line_pointer[-1] = 0;
        ;
       know (input_line_pointer[-1] == '\"');
       input_line_pointer[-1] = 0;
-      name = xmalloc (input_line_pointer - section_name + 1);
-      strcpy (name, section_name);
+      name = xstrdup (section_name);
 
       seg = bfd_get_section_by_name (stdoutput, name);
       if (seg == NULL)
 
       seg = bfd_get_section_by_name (stdoutput, name);
       if (seg == NULL)
@@ -2007,7 +1838,7 @@ tic54x_clink (ignored)
     {
       if (!tic54x_initialized_section (seg))
        {
     {
       if (!tic54x_initialized_section (seg))
        {
-         as_bad (_("Current section is unitialized, "
+         as_bad (_("Current section is uninitialized, "
                    "section name required for .clink"));
          ignore_rest_of_line ();
          return;
                    "section name required for .clink"));
          ignore_rest_of_line ();
          return;
@@ -2024,21 +1855,15 @@ tic54x_clink (ignored)
    set to "." instead.  */
 
 static void
    set to "." instead.  */
 
 static void
-tic54x_set_default_include (dot)
-     int dot;
+tic54x_set_default_include (void)
 {
 {
-  char *dir = ".";
-  char *tmp = NULL;
+  char *dir, *tmp = NULL;
+  const char *curfile;
+  unsigned lineno;
 
 
-  if (!dot)
-    {
-      char *curfile;
-      unsigned lineno;
-
-      as_where (&curfile, &lineno);
-      dir = strcpy (xmalloc (strlen (curfile) + 1), curfile);
-      tmp = strrchr (dir, '/');
-    }
+  curfile = as_where (&lineno);
+  dir = xstrdup (curfile);
+  tmp = strrchr (dir, '/');
   if (tmp != NULL)
     {
       int len;
   if (tmp != NULL)
     {
       int len;
@@ -2047,7 +1872,7 @@ tic54x_set_default_include (dot)
       len = strlen (dir);
       if (include_dir_count == 0)
        {
       len = strlen (dir);
       if (include_dir_count == 0)
        {
-         include_dirs = (char **) xmalloc (sizeof (*include_dirs));
+         include_dirs = XNEWVEC (const char *, 1);
          include_dir_count = 1;
        }
       include_dirs[0] = dir;
          include_dir_count = 1;
        }
       include_dirs[0] = dir;
@@ -2070,8 +1895,7 @@ tic54x_set_default_include (dot)
    Entering/exiting included/copied file clears all local labels.  */
 
 static void
    Entering/exiting included/copied file clears all local labels.  */
 
 static void
-tic54x_include (ignored)
-     int ignored ATTRIBUTE_UNUSED;
+tic54x_include (int ignored ATTRIBUTE_UNUSED)
 {
   char newblock[] = " .newblock\n";
   char *filename;
 {
   char newblock[] = " .newblock\n";
   char *filename;
@@ -2090,11 +1914,11 @@ tic54x_include (ignored)
   else
     {
       filename = input_line_pointer;
   else
     {
       filename = input_line_pointer;
-      while (!is_end_of_line[(int) *input_line_pointer])
+      while (!is_end_of_line[(unsigned char) *input_line_pointer])
        ++input_line_pointer;
       c = *input_line_pointer;
       *input_line_pointer = '\0';
        ++input_line_pointer;
       c = *input_line_pointer;
       *input_line_pointer = '\0';
-      filename = strcpy (xmalloc (strlen (filename) + 1), filename);
+      filename = xstrdup (filename);
       *input_line_pointer = c;
       demand_empty_rest_of_line ();
     }
       *input_line_pointer = c;
       demand_empty_rest_of_line ();
     }
@@ -2102,20 +1926,18 @@ tic54x_include (ignored)
      and a .newblock.
      The included file will be inserted before the newblock, so that the
      newblock is executed after the included file is processed.  */
      and a .newblock.
      The included file will be inserted before the newblock, so that the
      newblock is executed after the included file is processed.  */
-  input = xmalloc (sizeof (newblock) + strlen (filename) + 4);
-  sprintf (input, "\"%s\"\n%s", filename, newblock);
+  input = concat ("\"", filename, "\"\n", newblock, (char *) NULL);
   input_scrub_insert_line (input);
 
   tic54x_clear_local_labels (0);
 
   input_scrub_insert_line (input);
 
   tic54x_clear_local_labels (0);
 
-  tic54x_set_default_include (0);
+  tic54x_set_default_include ();
 
   s_include (0);
 }
 
 static void
 
   s_include (0);
 }
 
 static void
-tic54x_message (type)
-     int type;
+tic54x_message (int type)
 {
   char *msg;
   char c;
 {
   char *msg;
   char c;
@@ -2128,11 +1950,11 @@ tic54x_message (type)
   else
     {
       msg = input_line_pointer;
   else
     {
       msg = input_line_pointer;
-      while (!is_end_of_line[(int) *input_line_pointer])
+      while (!is_end_of_line[(unsigned char) *input_line_pointer])
        ++input_line_pointer;
       c = *input_line_pointer;
       *input_line_pointer = 0;
        ++input_line_pointer;
       c = *input_line_pointer;
       *input_line_pointer = 0;
-      msg = strcpy (xmalloc (strlen (msg) + 1), msg);
+      msg = xstrdup (msg);
       *input_line_pointer = c;
     }
 
       *input_line_pointer = c;
     }
 
@@ -2161,20 +1983,19 @@ tic54x_message (type)
    run address (vma).  */
 
 static void
    run address (vma).  */
 
 static void
-tic54x_label (ignored)
-     int ignored ATTRIBUTE_UNUSED;
+tic54x_label (int ignored ATTRIBUTE_UNUSED)
 {
 {
-  char *name = input_line_pointer;
+  char *name;
   symbolS *symbolP;
   int c;
 
   ILLEGAL_WITHIN_STRUCT ();
 
   symbolS *symbolP;
   int c;
 
   ILLEGAL_WITHIN_STRUCT ();
 
-  c = get_symbol_end ();
+  c = get_symbol_name (&name);
   symbolP = colon (name);
   S_SET_STORAGE_CLASS (symbolP, C_STATLAB);
 
   symbolP = colon (name);
   S_SET_STORAGE_CLASS (symbolP, C_STATLAB);
 
-  *input_line_pointer = c;
+  (void) restore_line_pointer (c);
   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 
@@ -2183,14 +2004,13 @@ tic54x_label (ignored)
    absolute local symbols.  */
 
 static void
    absolute local symbols.  */
 
 static void
-tic54x_mmregs (ignored)
-     int ignored ATTRIBUTE_UNUSED;
+tic54x_mmregs (int ignored ATTRIBUTE_UNUSED)
 {
 {
-  symbol *sym;
+  tic54x_symbol *sym;
 
   ILLEGAL_WITHIN_STRUCT ();
 
 
   ILLEGAL_WITHIN_STRUCT ();
 
-  for (sym = (symbol *) mmregs; sym->name; sym++)
+  for (sym = (tic54x_symbol *) mmregs; sym->name; sym++)
     {
       symbolS *symbolP = symbol_new (sym->name, absolute_section,
                                     (valueT) sym->value, &zero_address_frag);
     {
       symbolS *symbolP = symbol_new (sym->name, absolute_section,
                                     (valueT) sym->value, &zero_address_frag);
@@ -2203,23 +2023,21 @@ tic54x_mmregs (ignored)
    Count defaults to 1024.  */
 
 static void
    Count defaults to 1024.  */
 
 static void
-tic54x_loop (count)
-     int count;
+tic54x_loop (int count)
 {
   ILLEGAL_WITHIN_STRUCT ();
 
   SKIP_WHITESPACE ();
 {
   ILLEGAL_WITHIN_STRUCT ();
 
   SKIP_WHITESPACE ();
-  if (!is_end_of_line[(int) *input_line_pointer])
+  if (!is_end_of_line[(unsigned char) *input_line_pointer])
     count = get_absolute_expression ();
 
     count = get_absolute_expression ();
 
-  do_repeat (count, "LOOP", "ENDLOOP");
+  do_repeat ((size_t) count, "LOOP", "ENDLOOP");
 }
 
 /* Normally, endloop gets eaten by the preceding loop.  */
 
 static void
 }
 
 /* Normally, endloop gets eaten by the preceding loop.  */
 
 static void
-tic54x_endloop (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_endloop (int ignore ATTRIBUTE_UNUSED)
 {
   as_bad (_("ENDLOOP without corresponding LOOP"));
   ignore_rest_of_line ();
 {
   as_bad (_("ENDLOOP without corresponding LOOP"));
   ignore_rest_of_line ();
@@ -2228,15 +2046,14 @@ tic54x_endloop (ignore)
 /* .break [condition].  */
 
 static void
 /* .break [condition].  */
 
 static void
-tic54x_break (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_break (int ignore ATTRIBUTE_UNUSED)
 {
   int cond = 1;
 
   ILLEGAL_WITHIN_STRUCT ();
 
   SKIP_WHITESPACE ();
 {
   int cond = 1;
 
   ILLEGAL_WITHIN_STRUCT ();
 
   SKIP_WHITESPACE ();
-  if (!is_end_of_line[(int) *input_line_pointer])
+  if (!is_end_of_line[(unsigned char) *input_line_pointer])
     cond = get_absolute_expression ();
 
   if (cond)
     cond = get_absolute_expression ();
 
   if (cond)
@@ -2244,8 +2061,7 @@ tic54x_break (ignore)
 }
 
 static void
 }
 
 static void
-set_address_mode (mode)
-     int mode;
+set_address_mode (int mode)
 {
   amode = mode;
   if (mode == far_mode)
 {
   amode = mode;
   if (mode == far_mode)
@@ -2260,8 +2076,7 @@ set_address_mode (mode)
 static int address_mode_needs_set = 1;
 
 static void
 static int address_mode_needs_set = 1;
 
 static void
-tic54x_address_mode (mode)
-     int mode;
+tic54x_address_mode (int mode)
 {
   if (assembly_begun && amode != (unsigned) mode)
     {
 {
   if (assembly_begun && amode != (unsigned) mode)
     {
@@ -2284,8 +2099,7 @@ tic54x_address_mode (mode)
    Designate initialized sections for blocking.  */
 
 static void
    Designate initialized sections for blocking.  */
 
 static void
-tic54x_sblock (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_sblock (int ignore ATTRIBUTE_UNUSED)
 {
   int c = ',';
 
 {
   int c = ',';
 
@@ -2304,12 +2118,11 @@ tic54x_sblock (ignore)
        }
       else
        {
        }
       else
        {
-         char *section_name = input_line_pointer;
+         char *section_name;
 
 
-         c = get_symbol_end ();
-         name = xmalloc (strlen (section_name) + 1);
-         strcpy (name, section_name);
-         *input_line_pointer = c;
+         c = get_symbol_name (&section_name);
+         name = xstrdup (section_name);
+         (void) restore_line_pointer (c);
        }
 
       seg = bfd_get_section_by_name (stdoutput, name);
        }
 
       seg = bfd_get_section_by_name (stdoutput, name);
@@ -2328,7 +2141,7 @@ tic54x_sblock (ignore)
       seg->flags |= SEC_TIC54X_BLOCK;
 
       c = *input_line_pointer;
       seg->flags |= SEC_TIC54X_BLOCK;
 
       c = *input_line_pointer;
-      if (!is_end_of_line[(int) c])
+      if (!is_end_of_line[(unsigned char) c])
        ++input_line_pointer;
     }
 
        ++input_line_pointer;
     }
 
@@ -2342,8 +2155,7 @@ tic54x_sblock (ignore)
    symbols assigned with .set/.equ may not be redefined.  */
 
 static void
    symbols assigned with .set/.equ may not be redefined.  */
 
 static void
-tic54x_set (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_set (int ignore ATTRIBUTE_UNUSED)
 {
   symbolS *symbolP;
   char *name;
 {
   symbolS *symbolP;
   char *name;
@@ -2377,8 +2189,7 @@ tic54x_set (ignore)
    List false conditional blocks.  */
 
 static void
    List false conditional blocks.  */
 
 static void
-tic54x_fclist (show)
-     int show;
+tic54x_fclist (int show)
 {
   if (show)
     listing &= ~LISTING_NOCOND;
 {
   if (show)
     listing &= ~LISTING_NOCOND;
@@ -2388,8 +2199,7 @@ tic54x_fclist (show)
 }
 
 static void
 }
 
 static void
-tic54x_sslist (show)
-     int show;
+tic54x_sslist (int show)
 {
   ILLEGAL_WITHIN_STRUCT ();
 
 {
   ILLEGAL_WITHIN_STRUCT ();
 
@@ -2400,8 +2210,7 @@ tic54x_sslist (show)
    Define a substitution string to be local to a macro.  */
 
 static void
    Define a substitution string to be local to a macro.  */
 
 static void
-tic54x_var (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_var (int ignore ATTRIBUTE_UNUSED)
 {
   static char empty[] = "";
   char *name;
 {
   static char empty[] = "";
   char *name;
@@ -2423,16 +2232,15 @@ tic54x_var (ignore)
          ignore_rest_of_line ();
          return;
        }
          ignore_rest_of_line ();
          return;
        }
-      name = input_line_pointer;
-      c = get_symbol_end ();
+      c = get_symbol_name (&name);
       /* .var symbols start out with a null string.  */
       /* .var symbols start out with a null string.  */
-      name = strcpy (xmalloc (strlen (name) + 1), name);
+      name = xstrdup (name);
       hash_insert (subsym_hash[macro_level], name, empty);
       hash_insert (subsym_hash[macro_level], name, empty);
-      *input_line_pointer = c;
+      c = restore_line_pointer (c);
       if (c == ',')
        {
          ++input_line_pointer;
       if (c == ',')
        {
          ++input_line_pointer;
-         if (is_end_of_line[(int) *input_line_pointer])
+         if (is_end_of_line[(unsigned char) *input_line_pointer])
            c = *input_line_pointer;
        }
     }
            c = *input_line_pointer;
        }
     }
@@ -2449,8 +2257,7 @@ tic54x_var (ignore)
    FIXME need to try the source file directory as well.  */
 
 static void
    FIXME need to try the source file directory as well.  */
 
 static void
-tic54x_mlib (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic54x_mlib (int ignore ATTRIBUTE_UNUSED)
 {
   char *filename;
   char *path;
 {
   char *filename;
   char *path;
@@ -2469,7 +2276,7 @@ tic54x_mlib (ignore)
     {
       SKIP_WHITESPACE ();
       len = 0;
     {
       SKIP_WHITESPACE ();
       len = 0;
-      while (!is_end_of_line[(int) *input_line_pointer]
+      while (!is_end_of_line[(unsigned char) *input_line_pointer]
             && !ISSPACE (*input_line_pointer))
        {
          obstack_1grow (&notes, *input_line_pointer);
             && !ISSPACE (*input_line_pointer))
        {
          obstack_1grow (&notes, *input_line_pointer);
@@ -2481,8 +2288,8 @@ tic54x_mlib (ignore)
     }
   demand_empty_rest_of_line ();
 
     }
   demand_empty_rest_of_line ();
 
-  tic54x_set_default_include (0);
-  path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
+  tic54x_set_default_include ();
+  path = XNEWVEC (char, (unsigned long) len + include_dir_maxlen + 5);
 
   for (i = 0; i < include_dir_count; i++)
     {
 
   for (i = 0; i < include_dir_count; i++)
     {
@@ -2513,8 +2320,8 @@ tic54x_mlib (ignore)
   abfd = bfd_openr (path, NULL);
   if (!abfd)
     {
   abfd = bfd_openr (path, NULL);
   if (!abfd)
     {
-      as_bad (_("Can't open macro library file '%s' for reading."), path);
-      as_perror ("%s", path);
+      as_bad (_("can't open macro library file '%s' for reading: %s"),
+             path, bfd_errmsg (bfd_get_error ()));
       ignore_rest_of_line ();
       return;
     }
       ignore_rest_of_line ();
       return;
     }
@@ -2531,18 +2338,18 @@ tic54x_mlib (ignore)
     {
       /* Get a size at least as big as the archive member.  */
       bfd_size_type size = bfd_get_size (mbfd);
     {
       /* Get a size at least as big as the archive member.  */
       bfd_size_type size = bfd_get_size (mbfd);
-      char *buf = xmalloc (size);
+      char *buf = XNEWVEC (char, size);
       char *fname = tmpnam (NULL);
       FILE *ftmp;
 
       /* We're not sure how big it is, but it will be smaller than "size".  */
       char *fname = tmpnam (NULL);
       FILE *ftmp;
 
       /* We're not sure how big it is, but it will be smaller than "size".  */
-      bfd_bread (buf, size, mbfd);
+      size = bfd_bread (buf, size, mbfd);
 
       /* Write to a temporary file, then use s_include to include it
         a bit of a hack.  */
       ftmp = fopen (fname, "w+b");
       fwrite ((void *) buf, size, 1, ftmp);
 
       /* Write to a temporary file, then use s_include to include it
         a bit of a hack.  */
       ftmp = fopen (fname, "w+b");
       fwrite ((void *) buf, size, 1, ftmp);
-      if (buf[size - 1] != '\n')
+      if (size == 0 || buf[size - 1] != '\n')
        fwrite ("\n", 1, 1, ftmp);
       fclose (ftmp);
       free (buf);
        fwrite ("\n", 1, 1, ftmp);
       fclose (ftmp);
       free (buf);
@@ -2639,9 +2446,7 @@ const pseudo_typeS md_pseudo_table[] =
 };
 
 int
 };
 
 int
-md_parse_option (c, arg)
-     int c;
-     char *arg;
+md_parse_option (int c, const char *arg)
 {
   switch (c)
     {
 {
   switch (c)
     {
@@ -2670,7 +2475,7 @@ md_parse_option (c, arg)
       break;
     case OPTION_STDERR_TO_FILE:
       {
       break;
     case OPTION_STDERR_TO_FILE:
       {
-       char *filename = arg;
+       const char *filename = arg;
        FILE *fp = fopen (filename, "w+");
 
        if (fp == NULL)
        FILE *fp = fopen (filename, "w+");
 
        if (fp == NULL)
@@ -2691,45 +2496,27 @@ md_parse_option (c, arg)
    deleting the local label hash between macro invocations.  */
 
 void
    deleting the local label hash between macro invocations.  */
 
 void
-tic54x_macro_start ()
+tic54x_macro_start (void)
 {
 {
-  ++macro_level;
+  if (++macro_level >= MAX_SUBSYM_HASH)
+    {
+      as_fatal (_("Macro nesting is too deep"));
+      return;
+    }
   subsym_hash[macro_level] = hash_new ();
   local_label_hash[macro_level] = hash_new ();
 }
 
 void
   subsym_hash[macro_level] = hash_new ();
   local_label_hash[macro_level] = hash_new ();
 }
 
 void
-tic54x_macro_info (info)
-     void *info;
+tic54x_macro_info (const macro_entry *macro)
 {
 {
-  struct formal_struct
-  {
-    struct formal_struct *next;        /* Next formal in list  */
-    sb name;                   /* Name of the formal  */
-    sb def;                    /* The default value  */
-    sb actual;                 /* The actual argument (changed on
-                                   each expansion) */
-    int index;                 /* The index of the formal
-                                   0 .. formal_count - 1 */
-  } *entry;
-  struct macro_struct
-  {
-    sb sub;                    /* Substitution text.  */
-    int formal_count;          /* Number of formal args.  */
-    struct formal_struct *formals;     /* Pointer to list of
-                                           formal_structs.  */
-    struct hash_control *formal_hash; /* Hash table of formals.  */
-  } *macro;
-
-  macro = (struct macro_struct *) info;
+  const formal_entry *entry;
 
   /* Put the formal args into the substitution symbol table.  */
   for (entry = macro->formals; entry; entry = entry->next)
     {
 
   /* Put the formal args into the substitution symbol table.  */
   for (entry = macro->formals; entry; entry = entry->next)
     {
-      char *name = strncpy (xmalloc (entry->name.len + 1),
-                           entry->name.ptr, entry->name.len);
-      char *value = strncpy (xmalloc (entry->actual.len + 1),
-                            entry->actual.ptr, entry->actual.len);
+      char *name = xstrndup (entry->name.ptr, entry->name.len);
+      char *value = xstrndup (entry->actual.ptr, entry->actual.len);
 
       name[entry->name.len] = '\0';
       value[entry->actual.len] = '\0';
 
       name[entry->name.len] = '\0';
       value[entry->actual.len] = '\0';
@@ -2740,7 +2527,7 @@ tic54x_macro_info (info)
 /* Get rid of this macro's .var's, arguments, and local labels.  */
 
 void
 /* Get rid of this macro's .var's, arguments, and local labels.  */
 
 void
-tic54x_macro_end ()
+tic54x_macro_end (void)
 {
   hash_die (subsym_hash[macro_level]);
   subsym_hash[macro_level] = NULL;
 {
   hash_die (subsym_hash[macro_level]);
   subsym_hash[macro_level] = NULL;
@@ -2750,9 +2537,7 @@ tic54x_macro_end ()
 }
 
 static int
 }
 
 static int
-subsym_symlen (a, ignore)
-     char *a;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_symlen (char *a, char *ignore ATTRIBUTE_UNUSED)
 {
   return strlen (a);
 }
 {
   return strlen (a);
 }
@@ -2760,9 +2545,7 @@ subsym_symlen (a, ignore)
 /* Compare symbol A to string B.  */
 
 static int
 /* Compare symbol A to string B.  */
 
 static int
-subsym_symcmp (a, b)
-     char *a;
-     char *b;
+subsym_symcmp (char *a, char *b)
 {
   return strcmp (a, b);
 }
 {
   return strcmp (a, b);
 }
@@ -2771,9 +2554,7 @@ subsym_symcmp (a, b)
    assumes b is an integer char value as a string.  Index is one-based.  */
 
 static int
    assumes b is an integer char value as a string.  Index is one-based.  */
 
 static int
-subsym_firstch (a, b)
-     char *a;
-     char *b;
+subsym_firstch (char *a, char *b)
 {
   int val = atoi (b);
   char *tmp = strchr (a, val);
 {
   int val = atoi (b);
   char *tmp = strchr (a, val);
@@ -2784,9 +2565,7 @@ subsym_firstch (a, b)
 /* Similar to firstch, but returns index of last occurrence of B in A.  */
 
 static int
 /* Similar to firstch, but returns index of last occurrence of B in A.  */
 
 static int
-subsym_lastch (a, b)
-     char *a;
-     char *b;
+subsym_lastch (char *a, char *b)
 {
   int val = atoi (b);
   char *tmp = strrchr (a, val);
 {
   int val = atoi (b);
   char *tmp = strrchr (a, val);
@@ -2798,9 +2577,7 @@ subsym_lastch (a, b)
    symbol table).  */
 
 static int
    symbol table).  */
 
 static int
-subsym_isdefed (a, ignore)
-     char *a;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_isdefed (char *a, char *ignore ATTRIBUTE_UNUSED)
 {
   symbolS *symbolP = symbol_find (a);
 
 {
   symbolS *symbolP = symbol_find (a);
 
@@ -2812,9 +2589,7 @@ subsym_isdefed (a, ignore)
    symbols, unsubstituted.  */
 
 static int
    symbols, unsubstituted.  */
 
 static int
-subsym_ismember (sym, list)
-     char *sym;
-     char *list;
+subsym_ismember (char *sym, char *list)
 {
   char *elem, *ptr, *listv;
 
 {
   char *elem, *ptr, *listv;
 
@@ -2829,8 +2604,7 @@ subsym_ismember (sym, list)
       return 0;
     }
 
       return 0;
     }
 
-  ptr = elem = xmalloc (strlen (listv) + 1);
-  strcpy (elem, listv);
+  ptr = elem = xstrdup (listv);
   while (*ptr && *ptr != ',')
     ++ptr;
   *ptr++ = 0;
   while (*ptr && *ptr != ',')
     ++ptr;
   *ptr++ = 0;
@@ -2852,15 +2626,13 @@ subsym_ismember (sym, list)
    5 if decimal.  */
 
 static int
    5 if decimal.  */
 
 static int
-subsym_iscons (a, ignore)
-     char *a;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_iscons (char *a, char *ignore ATTRIBUTE_UNUSED)
 {
 {
-  expressionS exp;
+  expressionS expn;
 
 
-  parse_expression (a, &exp);
+  parse_expression (a, &expn);
 
 
-  if (exp.X_op == O_constant)
+  if (expn.X_op == O_constant)
     {
       int len = strlen (a);
 
     {
       int len = strlen (a);
 
@@ -2893,9 +2665,7 @@ subsym_iscons (a, ignore)
 /* Return 1 if A is a valid symbol name.  Expects string input.   */
 
 static int
 /* Return 1 if A is a valid symbol name.  Expects string input.   */
 
 static int
-subsym_isname (a, ignore)
-     char *a;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_isname (char *a, char *ignore ATTRIBUTE_UNUSED)
 {
   if (!is_name_beginner (*a))
     return 0;
 {
   if (!is_name_beginner (*a))
     return 0;
@@ -2913,9 +2683,7 @@ subsym_isname (a, ignore)
    Note this does not recognize "A" or "B" accumulators.  */
 
 static int
    Note this does not recognize "A" or "B" accumulators.  */
 
 static int
-subsym_isreg (a, ignore)
-     char *a;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_isreg (char *a, char *ignore ATTRIBUTE_UNUSED)
 {
   if (hash_find (reg_hash, a))
     return 1;
 {
   if (hash_find (reg_hash, a))
     return 1;
@@ -2927,9 +2695,7 @@ subsym_isreg (a, ignore)
 /* Return the structure size, given the stag.  */
 
 static int
 /* Return the structure size, given the stag.  */
 
 static int
-subsym_structsz (name, ignore)
-     char *name;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_structsz (char *name, char *ignore ATTRIBUTE_UNUSED)
 {
   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
 
 {
   struct stag *stag = (struct stag *) hash_find (stag_hash, name);
 
@@ -2947,145 +2713,110 @@ subsym_structsz (name, ignore)
    return zero, we punt and return zero.  */
 
 static int
    return zero, we punt and return zero.  */
 
 static int
-subsym_structacc (stag_name, ignore)
-     char *stag_name ATTRIBUTE_UNUSED;
-     char *ignore ATTRIBUTE_UNUSED;
+subsym_structacc (char *stag_name ATTRIBUTE_UNUSED,
+                 char *ignore ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 
 static float
 {
   return 0;
 }
 
 static float
-math_ceil (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_ceil (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) ceil (arg1);
 }
 
 static float
 {
   return (float) ceil (arg1);
 }
 
 static float
-math_cvi (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_cvi (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (int) arg1;
 }
 
 static float
 {
   return (int) arg1;
 }
 
 static float
-math_floor (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_floor (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) floor (arg1);
 }
 
 static float
 {
   return (float) floor (arg1);
 }
 
 static float
-math_fmod (arg1, arg2)
-     float arg1;
-     float arg2;
+math_fmod (float arg1, float arg2)
 {
   return (int) arg1 % (int) arg2;
 }
 
 static float
 {
   return (int) arg1 % (int) arg2;
 }
 
 static float
-math_int (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_int (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return ((float) ((int) arg1)) == arg1;
 }
 
 static float
 {
   return ((float) ((int) arg1)) == arg1;
 }
 
 static float
-math_round (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_round (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5);
 }
 
 static float
 {
   return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5);
 }
 
 static float
-math_sgn (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_sgn (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
 }
 
 static float
 {
   return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
 }
 
 static float
-math_trunc (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_trunc (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (int) arg1;
 }
 
 static float
 {
   return (int) arg1;
 }
 
 static float
-math_acos (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_acos (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) acos (arg1);
 }
 
 static float
 {
   return (float) acos (arg1);
 }
 
 static float
-math_asin (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_asin (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) asin (arg1);
 }
 
 static float
 {
   return (float) asin (arg1);
 }
 
 static float
-math_atan (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_atan (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) atan (arg1);
 }
 
 static float
 {
   return (float) atan (arg1);
 }
 
 static float
-math_atan2 (arg1, arg2)
-     float arg1;
-     float arg2;
+math_atan2 (float arg1, float arg2)
 {
   return (float) atan2 (arg1, arg2);
 }
 
 static float
 {
   return (float) atan2 (arg1, arg2);
 }
 
 static float
-math_cosh (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_cosh (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) cosh (arg1);
 }
 
 static float
 {
   return (float) cosh (arg1);
 }
 
 static float
-math_cos (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_cos (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) cos (arg1);
 }
 
 static float
 {
   return (float) cos (arg1);
 }
 
 static float
-math_cvf (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_cvf (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) arg1;
 }
 
 static float
 {
   return (float) arg1;
 }
 
 static float
-math_exp (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_exp (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) exp (arg1);
 }
 
 static float
 {
   return (float) exp (arg1);
 }
 
 static float
-math_fabs (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_fabs (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) fabs (arg1);
 }
 {
   return (float) fabs (arg1);
 }
@@ -3093,89 +2824,67 @@ math_fabs (arg1, ignore)
 /* expr1 * 2^expr2.  */
 
 static float
 /* expr1 * 2^expr2.  */
 
 static float
-math_ldexp (arg1, arg2)
-     float arg1;
-     float arg2;
+math_ldexp (float arg1, float arg2)
 {
   return arg1 * (float) pow (2.0, arg2);
 }
 
 static float
 {
   return arg1 * (float) pow (2.0, arg2);
 }
 
 static float
-math_log10 (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_log10 (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) log10 (arg1);
 }
 
 static float
 {
   return (float) log10 (arg1);
 }
 
 static float
-math_log (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_log (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) log (arg1);
 }
 
 static float
 {
   return (float) log (arg1);
 }
 
 static float
-math_max (arg1, arg2)
-     float arg1;
-     float arg2;
+math_max (float arg1, float arg2)
 {
   return (arg1 > arg2) ? arg1 : arg2;
 }
 
 static float
 {
   return (arg1 > arg2) ? arg1 : arg2;
 }
 
 static float
-math_min (arg1, arg2)
-     float arg1;
-     float arg2;
+math_min (float arg1, float arg2)
 {
   return (arg1 < arg2) ? arg1 : arg2;
 }
 
 static float
 {
   return (arg1 < arg2) ? arg1 : arg2;
 }
 
 static float
-math_pow (arg1, arg2)
-     float arg1;
-     float arg2;
+math_pow (float arg1, float arg2)
 {
   return (float) pow (arg1, arg2);
 }
 
 static float
 {
   return (float) pow (arg1, arg2);
 }
 
 static float
-math_sin (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_sin (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) sin (arg1);
 }
 
 static float
 {
   return (float) sin (arg1);
 }
 
 static float
-math_sinh (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_sinh (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) sinh (arg1);
 }
 
 static float
 {
   return (float) sinh (arg1);
 }
 
 static float
-math_sqrt (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_sqrt (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) sqrt (arg1);
 }
 
 static float
 {
   return (float) sqrt (arg1);
 }
 
 static float
-math_tan (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_tan (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) tan (arg1);
 }
 
 static float
 {
   return (float) tan (arg1);
 }
 
 static float
-math_tanh (arg1, ignore)
-     float arg1;
-     float ignore ATTRIBUTE_UNUSED;
+math_tanh (float arg1, float ignore ATTRIBUTE_UNUSED)
 {
   return (float) tanh (arg1);
 }
 {
   return (float) tanh (arg1);
 }
@@ -3183,8 +2892,8 @@ math_tanh (arg1, ignore)
 /* Built-in substitution symbol functions and math functions.  */
 typedef struct
 {
 /* Built-in substitution symbol functions and math functions.  */
 typedef struct
 {
-  char *name;
-  int (*proc) PARAMS ((char *, char *));
+  const char *name;
+  int (*proc) (char *, char *);
   int nargs;
 } subsym_proc_entry;
 
   int nargs;
 } subsym_proc_entry;
 
@@ -3207,8 +2916,8 @@ static const subsym_proc_entry subsym_procs[] =
 
 typedef struct
 {
 
 typedef struct
 {
-  char *name;
-  float (*proc) PARAMS ((float, float));
+  const char *name;
+  float (*proc) (float, float);
   int nargs;
   int int_return;
 } math_proc_entry;
   int nargs;
   int int_return;
 } math_proc_entry;
@@ -3250,10 +2959,10 @@ static const math_proc_entry math_procs[] =
 };
 
 void
 };
 
 void
-md_begin ()
+md_begin (void)
 {
 {
-  template *tm;
-  symbol *sym;
+  insn_template *tm;
+  tic54x_symbol *sym;
   const subsym_proc_entry *subsym_proc;
   const math_proc_entry *math_proc;
   const char *hash_err;
   const subsym_proc_entry *subsym_proc;
   const math_proc_entry *math_proc;
   const char *hash_err;
@@ -3281,7 +2990,7 @@ md_begin ()
     }
 
   op_hash = hash_new ();
     }
 
   op_hash = hash_new ();
-  for (tm = (template *) tic54x_optab; tm->name; tm++)
+  for (tm = (insn_template *) tic54x_optab; tm->name; tm++)
     {
       if (hash_find (op_hash, tm->name))
        continue;
     {
       if (hash_find (op_hash, tm->name))
        continue;
@@ -3291,7 +3000,7 @@ md_begin ()
                  tm->name, hash_err);
     }
   parop_hash = hash_new ();
                  tm->name, hash_err);
     }
   parop_hash = hash_new ();
-  for (tm = (template *) tic54x_paroptab; tm->name; tm++)
+  for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++)
     {
       if (hash_find (parop_hash, tm->name))
        continue;
     {
       if (hash_find (parop_hash, tm->name))
        continue;
@@ -3301,7 +3010,7 @@ md_begin ()
                  tm->name, hash_err);
     }
   reg_hash = hash_new ();
                  tm->name, hash_err);
     }
   reg_hash = hash_new ();
-  for (sym = (symbol *) regs; sym->name; sym++)
+  for (sym = (tic54x_symbol *) regs; sym->name; sym++)
     {
       /* Add basic registers to the symbol table.  */
       symbolS *symbolP = symbol_new (sym->name, absolute_section,
     {
       /* Add basic registers to the symbol table.  */
       symbolS *symbolP = symbol_new (sym->name, absolute_section,
@@ -3310,26 +3019,26 @@ md_begin ()
       symbol_table_insert (symbolP);
       hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
     }
       symbol_table_insert (symbolP);
       hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
     }
-  for (sym = (symbol *) mmregs; sym->name; sym++)
+  for (sym = (tic54x_symbol *) mmregs; sym->name; sym++)
     hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
   mmreg_hash = hash_new ();
     hash_err = hash_insert (reg_hash, sym->name, (char *) sym);
   mmreg_hash = hash_new ();
-  for (sym = (symbol *) mmregs; sym->name; sym++)
+  for (sym = (tic54x_symbol *) mmregs; sym->name; sym++)
     hash_err = hash_insert (mmreg_hash, sym->name, (char *) sym);
 
   cc_hash = hash_new ();
     hash_err = hash_insert (mmreg_hash, sym->name, (char *) sym);
 
   cc_hash = hash_new ();
-  for (sym = (symbol *) condition_codes; sym->name; sym++)
+  for (sym = (tic54x_symbol *) condition_codes; sym->name; sym++)
     hash_err = hash_insert (cc_hash, sym->name, (char *) sym);
 
   cc2_hash = hash_new ();
     hash_err = hash_insert (cc_hash, sym->name, (char *) sym);
 
   cc2_hash = hash_new ();
-  for (sym = (symbol *) cc2_codes; sym->name; sym++)
+  for (sym = (tic54x_symbol *) cc2_codes; sym->name; sym++)
     hash_err = hash_insert (cc2_hash, sym->name, (char *) sym);
 
   cc3_hash = hash_new ();
     hash_err = hash_insert (cc2_hash, sym->name, (char *) sym);
 
   cc3_hash = hash_new ();
-  for (sym = (symbol *) cc3_codes; sym->name; sym++)
+  for (sym = (tic54x_symbol *) cc3_codes; sym->name; sym++)
     hash_err = hash_insert (cc3_hash, sym->name, (char *) sym);
 
   sbit_hash = hash_new ();
     hash_err = hash_insert (cc3_hash, sym->name, (char *) sym);
 
   sbit_hash = hash_new ();
-  for (sym = (symbol *) status_bits; sym->name; sym++)
+  for (sym = (tic54x_symbol *) status_bits; sym->name; sym++)
     hash_err = hash_insert (sbit_hash, sym->name, (char *) sym);
 
   misc_symbol_hash = hash_new ();
     hash_err = hash_insert (sbit_hash, sym->name, (char *) sym);
 
   misc_symbol_hash = hash_new ();
@@ -3359,8 +3068,7 @@ md_begin ()
 }
 
 static int
 }
 
 static int
-is_accumulator (operand)
-     struct opstruct *operand;
+is_accumulator (struct opstruct *operand)
 {
   return strcasecmp (operand->buf, "a") == 0
     || strcasecmp (operand->buf, "b") == 0;
 {
   return strcasecmp (operand->buf, "a") == 0
     || strcasecmp (operand->buf, "b") == 0;
@@ -3371,16 +3079,14 @@ is_accumulator (operand)
    the next array.  */
 
 static int
    the next array.  */
 
 static int
-get_operands (operands, line)
-     struct opstruct operands[];
-     char *line;
+get_operands (struct opstruct operands[], char *line)
 {
   char *lptr = line;
   int numexp = 0;
   int expecting_operand = 0;
   int i;
 
 {
   char *lptr = line;
   int numexp = 0;
   int expecting_operand = 0;
   int i;
 
-  while (numexp < MAX_OPERANDS && !is_end_of_line[(int) *lptr])
+  while (numexp < MAX_OPERANDS && !is_end_of_line[(unsigned char) *lptr])
     {
       int paren_not_balanced = 0;
       char *op_start, *op_end;
     {
       int paren_not_balanced = 0;
       char *op_start, *op_end;
@@ -3394,7 +3100,7 @@ get_operands (operands, line)
            {
              if (paren_not_balanced)
                {
            {
              if (paren_not_balanced)
                {
-                 as_bad ("Unbalanced parenthesis in operand %d", numexp);
+                 as_bad (_("Unbalanced parenthesis in operand %d"), numexp);
                  return -1;
                }
              else
                  return -1;
                }
              else
@@ -3425,7 +3131,7 @@ get_operands (operands, line)
        {
          if (expecting_operand || *lptr == ',')
            {
        {
          if (expecting_operand || *lptr == ',')
            {
-             as_bad ("Expecting operand after ','");
+             as_bad (_("Expecting operand after ','"));
              return -1;
            }
        }
              return -1;
            }
        }
@@ -3433,7 +3139,7 @@ get_operands (operands, line)
        {
          if (*++lptr == '\0')
            {
        {
          if (*++lptr == '\0')
            {
-             as_bad ("Expecting operand after ','");
+             as_bad (_("Expecting operand after ','"));
              return -1;
            }
          expecting_operand = 1;
              return -1;
            }
          expecting_operand = 1;
@@ -3442,9 +3148,9 @@ get_operands (operands, line)
 
   while (*lptr && ISSPACE (*lptr++))
     ;
 
   while (*lptr && ISSPACE (*lptr++))
     ;
-  if (!is_end_of_line[(int) *lptr])
+  if (!is_end_of_line[(unsigned char) *lptr])
     {
     {
-      as_bad ("Extra junk on line");
+      as_bad (_("Extra junk on line"));
       return -1;
     }
 
       return -1;
     }
 
@@ -3502,8 +3208,7 @@ get_operands (operands, line)
 /* Predicates for different operand types.  */
 
 static int
 /* Predicates for different operand types.  */
 
 static int
-is_immediate (operand)
-     struct opstruct *operand;
+is_immediate (struct opstruct *operand)
 {
   return *operand->buf == '#';
 }
 {
   return *operand->buf == '#';
 }
@@ -3512,8 +3217,7 @@ is_immediate (operand)
    and must *not* have the '#' prefix.  */
 
 static int
    and must *not* have the '#' prefix.  */
 
 static int
-is_absolute (operand)
-     struct opstruct *operand;
+is_absolute (struct opstruct *operand)
 {
   return operand->exp.X_op == O_constant && !is_immediate (operand);
 }
 {
   return operand->exp.X_op == O_constant && !is_immediate (operand);
 }
@@ -3521,8 +3225,7 @@ is_absolute (operand)
 /* Is this an indirect operand?  */
 
 static int
 /* Is this an indirect operand?  */
 
 static int
-is_indirect (operand)
-     struct opstruct *operand;
+is_indirect (struct opstruct *operand)
 {
   return operand->buf[0] == '*';
 }
 {
   return operand->buf[0] == '*';
 }
@@ -3530,8 +3233,7 @@ is_indirect (operand)
 /* Is this a valid dual-memory operand?  */
 
 static int
 /* Is this a valid dual-memory operand?  */
 
 static int
-is_dual (operand)
-     struct opstruct *operand;
+is_dual (struct opstruct *operand)
 {
   if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
     {
 {
   if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
     {
@@ -3551,8 +3253,7 @@ is_dual (operand)
 }
 
 static int
 }
 
 static int
-is_mmreg (operand)
-     struct opstruct *operand;
+is_mmreg (struct opstruct *operand)
 {
   return (is_absolute (operand)
          || is_immediate (operand)
 {
   return (is_absolute (operand)
          || is_immediate (operand)
@@ -3560,9 +3261,7 @@ is_mmreg (operand)
 }
 
 static int
 }
 
 static int
-is_type (operand, type)
-     struct opstruct *operand;
-     enum optype type;
+is_type (struct opstruct *operand, enum optype type)
 {
   switch (type)
     {
 {
   switch (type)
     {
@@ -3666,13 +3365,12 @@ is_type (operand, type)
 }
 
 static int
 }
 
 static int
-operands_match (insn, operands, opcount, refoptype, minops, maxops)
-     tic54x_insn *insn;
-     struct opstruct *operands;
-     int opcount;
-     const enum optype *refoptype;
-     int minops;
-     int maxops;
+operands_match (tic54x_insn *insn,
+               struct opstruct *operands,
+               int opcount,
+               const enum optype *refoptype,
+               int minops,
+               int maxops)
 {
   int op = 0, refop = 0;
 
 {
   int op = 0, refop = 0;
 
@@ -3735,10 +3433,7 @@ operands_match (insn, operands, opcount, refoptype, minops, maxops)
    2 for the upper 7 bits of a 23-bit address (LDX).  */
 
 static int
    2 for the upper 7 bits of a 23-bit address (LDX).  */
 
 static int
-encode_dmad (insn, operand, xpc_code)
-     tic54x_insn *insn;
-     struct opstruct *operand;
-     int xpc_code;
+encode_dmad (tic54x_insn *insn, struct opstruct *operand, int xpc_code)
 {
   int op = 1 + insn->is_lkaddr;
 
 {
   int op = 1 + insn->is_lkaddr;
 
@@ -3799,9 +3494,7 @@ encode_dmad (insn, operand, xpc_code)
 /* 7-bit direct address encoding.  */
 
 static int
 /* 7-bit direct address encoding.  */
 
 static int
-encode_address (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_address (tic54x_insn *insn, struct opstruct *operand)
 {
   /* Assumes that dma addresses are *always* in word 0 of the opcode.  */
   insn->opcode[0].addr_expr = operand->exp;
 {
   /* Assumes that dma addresses are *always* in word 0 of the opcode.  */
   insn->opcode[0].addr_expr = operand->exp;
@@ -3822,9 +3515,7 @@ encode_address (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_indirect (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_indirect (tic54x_insn *insn, struct opstruct *operand)
 {
   int arf;
   int mod;
 {
   int arf;
   int mod;
@@ -3896,13 +3587,12 @@ encode_indirect (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_integer (insn, operand, which, min, max, mask)
-     tic54x_insn *insn;
-     struct opstruct *operand;
-     int which;
-     int min;
-     int max;
-     unsigned short mask;
+encode_integer (tic54x_insn *insn,
+               struct opstruct *operand,
+               int which,
+               int min,
+               int max,
+               unsigned short mask)
 {
   long parse, integer;
 
 {
   long parse, integer;
 
@@ -3957,11 +3647,9 @@ encode_integer (insn, operand, which, min, max, mask)
 }
 
 static int
 }
 
 static int
-encode_condition (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_condition (tic54x_insn *insn, struct opstruct *operand)
 {
 {
-  symbol *cc = (symbol *) hash_find (cc_hash, operand->buf);
+  tic54x_symbol *cc = (tic54x_symbol *) hash_find (cc_hash, operand->buf);
   if (!cc)
     {
       as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
   if (!cc)
     {
       as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
@@ -4019,11 +3707,9 @@ encode_condition (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_cc3 (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_cc3 (tic54x_insn *insn, struct opstruct *operand)
 {
 {
-  symbol *cc3 = (symbol *) hash_find (cc3_hash, operand->buf);
+  tic54x_symbol *cc3 = (tic54x_symbol *) hash_find (cc3_hash, operand->buf);
   int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;
 
   if ((value & 0x0300) != value)
   int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;
 
   if ((value & 0x0300) != value)
@@ -4036,9 +3722,7 @@ encode_cc3 (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_arx (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_arx (tic54x_insn *insn, struct opstruct *operand)
 {
   int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
 
 {
   int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
 
@@ -4052,11 +3736,9 @@ encode_arx (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_cc2 (insn, operand)
-     tic54x_insn *insn;
-     struct opstruct *operand;
+encode_cc2 (tic54x_insn *insn, struct opstruct *operand)
 {
 {
-  symbol *cc2 = (symbol *) hash_find (cc2_hash, operand->buf);
+  tic54x_symbol *cc2 = (tic54x_symbol *) hash_find (cc2_hash, operand->buf);
 
   if (!cc2)
     {
 
   if (!cc2)
     {
@@ -4068,10 +3750,7 @@ encode_cc2 (insn, operand)
 }
 
 static int
 }
 
 static int
-encode_operand (insn, type, operand)
-     tic54x_insn *insn;
-     enum optype type;
-     struct opstruct *operand;
+encode_operand (tic54x_insn *insn, enum optype type, struct opstruct *operand)
 {
   int ext = (insn->tm->flags & FL_EXT) != 0;
 
 {
   int ext = (insn->tm->flags & FL_EXT) != 0;
 
@@ -4218,7 +3897,8 @@ encode_operand (insn, type, operand)
                             0, 65535, 0xFFFF);
     case OP_SBIT:
       {
                             0, 65535, 0xFFFF);
     case OP_SBIT:
       {
-       symbol *sbit = (symbol *) hash_find (sbit_hash, operand->buf);
+       tic54x_symbol *sbit = (tic54x_symbol *)
+         hash_find (sbit_hash, operand->buf);
        int value = is_absolute (operand) ?
          operand->exp.X_add_number : (sbit ? sbit->value : -1);
        int reg = 0;
        int value = is_absolute (operand) ?
          operand->exp.X_add_number : (sbit ? sbit->value : -1);
        int reg = 0;
@@ -4232,7 +3912,7 @@ encode_operand (insn, type, operand)
              }
            /* Guess the register based on the status bit; "ovb" is the last
               status bit defined for st0.  */
              }
            /* Guess the register based on the status bit; "ovb" is the last
               status bit defined for st0.  */
-           if (sbit > (symbol *) hash_find (sbit_hash, "ovb"))
+           if (sbit > (tic54x_symbol *) hash_find (sbit_hash, "ovb"))
              reg = 1;
          }
        if (value == -1)
              reg = 1;
          }
        if (value == -1)
@@ -4294,16 +3974,15 @@ encode_operand (insn, type, operand)
 }
 
 static void
 }
 
 static void
-emit_insn (insn)
-     tic54x_insn *insn;
+emit_insn (tic54x_insn *insn)
 {
   int i;
 {
   int i;
-  flagword oldflags = bfd_get_section_flags (stdoutput, now_seg);
+  flagword oldflags = bfd_section_flags (now_seg);
   flagword flags = oldflags | SEC_CODE;
 
   flagword flags = oldflags | SEC_CODE;
 
-  if (! bfd_set_section_flags (stdoutput, now_seg, flags))
+  if (!bfd_set_section_flags (now_seg, flags))
         as_warn (_("error setting flags for \"%s\": %s"),
         as_warn (_("error setting flags for \"%s\": %s"),
-                 bfd_section_name (stdoutput, now_seg),
+                 bfd_section_name (now_seg),
                  bfd_errmsg (bfd_get_error ()));
 
   for (i = 0; i < insn->words; i++)
                  bfd_errmsg (bfd_get_error ()));
 
   for (i = 0; i < insn->words; i++)
@@ -4328,8 +4007,7 @@ emit_insn (insn)
    return the total number of words used by the instruction.  */
 
 static int
    return the total number of words used by the instruction.  */
 
 static int
-build_insn (insn)
-     tic54x_insn *insn;
+build_insn (tic54x_insn *insn)
 {
   int i;
 
 {
   int i;
 
@@ -4379,8 +4057,7 @@ build_insn (insn)
 }
 
 static int
 }
 
 static int
-optimize_insn (insn)
-     tic54x_insn *insn;
+optimize_insn (tic54x_insn *insn)
 {
   /* Optimize some instructions, helping out the brain-dead programmer.  */
 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
 {
   /* Optimize some instructions, helping out the brain-dead programmer.  */
 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
@@ -4473,11 +4150,9 @@ optimize_insn (insn)
 /* Find a matching template if possible, and get the operand strings.  */
 
 static int
 /* Find a matching template if possible, and get the operand strings.  */
 
 static int
-tic54x_parse_insn (insn, line)
-     tic54x_insn *insn;
-     char *line;
+tic54x_parse_insn (tic54x_insn *insn, char *line)
 {
 {
-  insn->tm = (template *) hash_find (op_hash, insn->mnemonic);
+  insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic);
   if (!insn->tm)
     {
       as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
   if (!insn->tm)
     {
       as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
@@ -4500,8 +4175,8 @@ tic54x_parse_insn (insn, line)
          /* SUCCESS! now try some optimizations.  */
          if (optimize_insn (insn))
            {
          /* SUCCESS! now try some optimizations.  */
          if (optimize_insn (insn))
            {
-             insn->tm = (template *) hash_find (op_hash,
-                                                insn->mnemonic);
+             insn->tm = (insn_template *) hash_find (op_hash,
+                                                      insn->mnemonic);
              continue;
            }
 
              continue;
            }
 
@@ -4522,11 +4197,10 @@ static int parallel_on_next_line_hint = 0;
    Look for a subsequent line starting with "||".  */
 
 static int
    Look for a subsequent line starting with "||".  */
 
 static int
-next_line_shows_parallel (next_line)
-     char *next_line;
+next_line_shows_parallel (char *next_line)
 {
   /* Look for the second half.  */
 {
   /* Look for the second half.  */
-  while (ISSPACE (*next_line))
+  while (*next_line != 0 && ISSPACE (*next_line))
     ++next_line;
 
   return (next_line[0] == PARALLEL_SEPARATOR
     ++next_line;
 
   return (next_line[0] == PARALLEL_SEPARATOR
@@ -4534,11 +4208,9 @@ next_line_shows_parallel (next_line)
 }
 
 static int
 }
 
 static int
-tic54x_parse_parallel_insn_firstline (insn, line)
-     tic54x_insn *insn;
-     char *line;
+tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line)
 {
 {
-  insn->tm = (template *) hash_find (parop_hash, insn->mnemonic);
+  insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic);
   if (!insn->tm)
     {
       as_bad (_("Unrecognized parallel instruction \"%s\""),
   if (!insn->tm)
     {
       as_bad (_("Unrecognized parallel instruction \"%s\""),
@@ -4567,9 +4239,7 @@ tic54x_parse_parallel_insn_firstline (insn, line)
 /* Parse the second line of a two-line parallel instruction.  */
 
 static int
 /* Parse the second line of a two-line parallel instruction.  */
 
 static int
-tic54x_parse_parallel_insn_lastline (insn, line)
-     tic54x_insn *insn;
-     char *line;
+tic54x_parse_parallel_insn_lastline (tic54x_insn *insn, char *line)
 {
   int valid_mnemonic = 0;
 
 {
   int valid_mnemonic = 0;
 
@@ -4607,11 +4277,7 @@ tic54x_parse_parallel_insn_lastline (insn, line)
    replacement on the value.  */
 
 static char *
    replacement on the value.  */
 
 static char *
-subsym_get_arg (line, terminators, str, nosub)
-     char *line;
-     char *terminators;
-     char **str;
-     int nosub;
+subsym_get_arg (char *line, const char *terminators, char **str, int nosub)
 {
   char *ptr = line;
   char *endp;
 {
   char *ptr = line;
   char *endp;
@@ -4623,9 +4289,7 @@ subsym_get_arg (line, terminators, str, nosub)
       while (ISDIGIT (*ptr))
        ++ptr;
       endp = ptr;
       while (ISDIGIT (*ptr))
        ++ptr;
       endp = ptr;
-      *str = xmalloc (ptr - line + 1);
-      strncpy (*str, line, ptr - line);
-      (*str)[ptr - line] = 0;
+      *str = xmemdup0 (line, ptr - line);
     }
   else if (is_string)
     {
     }
   else if (is_string)
     {
@@ -4643,7 +4307,7 @@ subsym_get_arg (line, terminators, str, nosub)
     }
   else
     {
     }
   else
     {
-      char *term = terminators;
+      const char *term = terminators;
       char *value = NULL;
 
       while (*ptr && *ptr != *term)
       char *value = NULL;
 
       while (*ptr && *ptr != *term)
@@ -4657,9 +4321,7 @@ subsym_get_arg (line, terminators, str, nosub)
            ++term;
        }
       endp = ptr;
            ++term;
        }
       endp = ptr;
-      *str = xmalloc (ptr - line + 1);
-      strncpy (*str, line, ptr - line);
-      (*str)[ptr - line] = 0;
+      *str = xmemdup0 (line, ptr - line);
       /* Do simple substitution, if available.  */
       if (!nosub && (value = subsym_lookup (*str, macro_level)) != NULL)
        *str = value;
       /* Do simple substitution, if available.  */
       if (!nosub && (value = subsym_lookup (*str, macro_level)) != NULL)
        *str = value;
@@ -4674,9 +4336,7 @@ subsym_get_arg (line, terminators, str, nosub)
    that's compatible w/TI's assembler.  */
 
 static void
    that's compatible w/TI's assembler.  */
 
 static void
-subsym_create_or_replace (name, value)
-     char *name;
-     char *value;
+subsym_create_or_replace (char *name, char *value)
 {
   int i;
 
 {
   int i;
 
@@ -4699,9 +4359,7 @@ subsym_create_or_replace (name, value)
    outwards.  */
 
 static char *
    outwards.  */
 
 static char *
-subsym_lookup (name, nest_level)
-     char *name;
-     int nest_level;
+subsym_lookup (char *name, int nest_level)
 {
   char *value = hash_find (subsym_hash[nest_level], name);
 
 {
   char *value = hash_find (subsym_hash[nest_level], name);
 
@@ -4719,9 +4377,7 @@ subsym_lookup (name, nest_level)
    If FORCED is set, look for forced substitutions of the form ':SYMBOL:'.  */
 
 static char *
    If FORCED is set, look for forced substitutions of the form ':SYMBOL:'.  */
 
 static char *
-subsym_substitute (line, forced)
-     char * line;
-     int forced;
+subsym_substitute (char *line, int forced)
 {
   /* For each apparent symbol, see if it's a substitution symbol, and if so,
      replace it in the input.  */
 {
   /* For each apparent symbol, see if it's a substitution symbol, and if so,
      replace it in the input.  */
@@ -4738,8 +4394,7 @@ subsym_substitute (line, forced)
   char *tmp;
 
   /* Work with a copy of the input line.  */
   char *tmp;
 
   /* Work with a copy of the input line.  */
-  replacement = xmalloc (strlen (line) + 1);
-  strcpy (replacement, line);
+  replacement = xstrdup (line);
 
   ptr = head = replacement;
 
 
   ptr = head = replacement;
 
@@ -4761,10 +4416,9 @@ subsym_substitute (line, forced)
   if (strstr (line, ".macro"))
     return line;
 
   if (strstr (line, ".macro"))
     return line;
 
-  while (!is_end_of_line[(int) *ptr])
+  unsigned char current_char;
+  while (!is_end_of_line[(current_char = * (unsigned char *) ptr)])
     {
     {
-      int current_char = *ptr;
-
       /* Need to update this since LINE may have been modified.  */
       if (eval_line)
        eval_end = strrchr (ptr, ',');
       /* Need to update this since LINE may have been modified.  */
       if (eval_line)
        eval_end = strrchr (ptr, ',');
@@ -4789,8 +4443,7 @@ subsym_substitute (line, forced)
              continue;
            }
          *ptr++ = '\0';
              continue;
            }
          *ptr++ = '\0';
-         tmp = xmalloc (strlen (head) + 2 + strlen (ptr) + 1);
-         sprintf (tmp, "%s==%s", head, ptr);
+         tmp = concat (head, "==", ptr, (char *) NULL);
          /* Continue examining after the '=='.  */
          ptr = tmp + strlen (head) + 2;
          free (replacement);
          /* Continue examining after the '=='.  */
          ptr = tmp + strlen (head) + 2;
          free (replacement);
@@ -4817,8 +4470,8 @@ subsym_substitute (line, forced)
          if (forced)
            ++ptr;
 
          if (forced)
            ++ptr;
 
-         name = input_line_pointer = ptr;
-         c = get_symbol_end ();
+         input_line_pointer = ptr;
+         c = get_symbol_name (&name);
          /* '?' is not normally part of a symbol, but it IS part of a local
             label.  */
          if (c == '?')
          /* '?' is not normally part of a symbol, but it IS part of a local
             label.  */
          if (c == '?')
@@ -4849,7 +4502,7 @@ subsym_substitute (line, forced)
              if (value == NULL)
                {
                  char digit[11];
              if (value == NULL)
                {
                  char digit[11];
-                 char *namecopy = strcpy (xmalloc (strlen (name) + 1), name);
+                 char *namecopy = xstrdup (name);
 
                  value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1),
                                  name);
 
                  value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1),
                                  name);
@@ -4883,10 +4536,10 @@ subsym_substitute (line, forced)
              ++ptr;
              if (math_entry != NULL)
                {
              ++ptr;
              if (math_entry != NULL)
                {
-                 float arg1, arg2 = 0;
+                 float farg1, farg2 = 0;
                  volatile float fresult;
 
                  volatile float fresult;
 
-                 arg1 = (float) strtod (ptr, &ptr);
+                 farg1 = (float) strtod (ptr, &ptr);
                  if (math_entry->nargs == 2)
                    {
                      if (*ptr++ != ',')
                  if (math_entry->nargs == 2)
                    {
                      if (*ptr++ != ',')
@@ -4894,10 +4547,10 @@ subsym_substitute (line, forced)
                          as_bad (_("Expecting second argument"));
                          break;
                        }
                          as_bad (_("Expecting second argument"));
                          break;
                        }
-                     arg2 = (float) strtod (ptr, &ptr);
+                     farg2 = (float) strtod (ptr, &ptr);
                    }
                    }
-                 fresult = (*math_entry->proc) (arg1, arg2);
-                 value = xmalloc (128);
+                 fresult = (*math_entry->proc) (farg1, farg2);
+                 value = XNEWVEC (char, 128);
                  if (math_entry->int_return)
                    sprintf (value, "%d", (int) fresult);
                  else
                  if (math_entry->int_return)
                    sprintf (value, "%d", (int) fresult);
                  else
@@ -4958,7 +4611,7 @@ subsym_substitute (line, forced)
                      break;
                    }
                  val = (*entry->proc) (arg1, arg2);
                      break;
                    }
                  val = (*entry->proc) (arg1, arg2);
-                 value = xmalloc (64);
+                 value = XNEWVEC (char, 64);
                  sprintf (value, "%d", val);
                }
              /* Fix things up to replace the entire expression, not just the
                  sprintf (value, "%d", val);
                }
              /* Fix things up to replace the entire expression, not just the
@@ -4974,13 +4627,13 @@ subsym_substitute (line, forced)
                 substitutions are performed, or a substitution that has been
                 previously made is encountered again.
 
                 substitutions are performed, or a substitution that has been
                 previously made is encountered again.
 
-                put the symbol into the recursion hash table so we only
+                Put the symbol into the recursion hash table so we only
                 try to replace a symbol once.  */
              if (recurse)
                {
                  hash_insert (subsym_recurse_hash, name, name);
                  value = subsym_substitute (value, macro_level > 0);
                 try to replace a symbol once.  */
              if (recurse)
                {
                  hash_insert (subsym_recurse_hash, name, name);
                  value = subsym_substitute (value, macro_level > 0);
-                 hash_delete (subsym_recurse_hash, name);
+                 hash_delete (subsym_recurse_hash, name, FALSE);
                }
 
              /* Temporarily zero-terminate where the symbol started.  */
                }
 
              /* Temporarily zero-terminate where the symbol started.  */
@@ -4994,8 +4647,7 @@ subsym_substitute (line, forced)
                         kinda indicates that forced substitution is not
                         supposed to be recursive, but I'm not sure.  */
                      unsigned beg, len = 1; /* default to a single char */
                         kinda indicates that forced substitution is not
                         supposed to be recursive, but I'm not sure.  */
                      unsigned beg, len = 1; /* default to a single char */
-                     char *newval = strcpy (xmalloc (strlen (value) + 1),
-                                            value);
+                     char *newval = xstrdup (value);
 
                      savedp = input_line_pointer;
                      input_line_pointer = tail + 1;
 
                      savedp = input_line_pointer;
                      input_line_pointer = tail + 1;
@@ -5003,7 +4655,7 @@ subsym_substitute (line, forced)
                      if (beg < 1)
                        {
                          as_bad (_("Invalid subscript (use 1 to %d)"),
                      if (beg < 1)
                        {
                          as_bad (_("Invalid subscript (use 1 to %d)"),
-                                 strlen (value));
+                                 (int) strlen (value));
                          break;
                        }
                      if (*input_line_pointer == ',')
                          break;
                        }
                      if (*input_line_pointer == ',')
@@ -5012,8 +4664,8 @@ subsym_substitute (line, forced)
                          len = get_absolute_expression ();
                          if (beg + len > strlen (value))
                            {
                          len = get_absolute_expression ();
                          if (beg + len > strlen (value))
                            {
-                             as_bad (_("Invalid length (use 0 to %d"),
-                                     strlen (value) - beg);
+                             as_bad (_("Invalid length (use 0 to %d)"),
+                                     (int) strlen (value) - beg);
                              break;
                            }
                        }
                              break;
                            }
                        }
@@ -5080,21 +4732,20 @@ subsym_substitute (line, forced)
    returns the new buffer limit.  */
 
 void
    returns the new buffer limit.  */
 
 void
-tic54x_start_line_hook ()
+tic54x_start_line_hook (void)
 {
   char *line, *endp;
   char *replacement = NULL;
 
   /* Work with a copy of the input line, including EOL char.  */
 {
   char *line, *endp;
   char *replacement = NULL;
 
   /* Work with a copy of the input line, including EOL char.  */
-  endp = input_line_pointer;
-  while (!is_end_of_line[(int) *endp++])
-    ;
-  line = xmalloc (endp - input_line_pointer + 1);
-  strncpy (line, input_line_pointer, endp - input_line_pointer + 1);
-  line[endp - input_line_pointer] = 0;
+  for (endp = input_line_pointer; *endp != 0; )
+    if (is_end_of_line[(unsigned char) *endp++])
+      break;
+
+  line = xmemdup0 (input_line_pointer, endp - input_line_pointer);
 
   /* Scan ahead for parallel insns.  */
 
   /* Scan ahead for parallel insns.  */
-  parallel_on_next_line_hint = next_line_shows_parallel (endp + 1);
+  parallel_on_next_line_hint = next_line_shows_parallel (endp);
 
   /* If within a macro, first process forced replacements.  */
   if (macro_level > 0)
 
   /* If within a macro, first process forced replacements.  */
   if (macro_level > 0)
@@ -5152,8 +4803,7 @@ tic54x_start_line_hook ()
    machine dependent instruction.  This function is supposed to emit
    the frags/bytes it assembles to.  */
 void
    machine dependent instruction.  This function is supposed to emit
    the frags/bytes it assembles to.  */
 void
-md_assemble (line)
-     char *line;
+md_assemble (char *line)
 {
   static int repeat_slot = 0;
   static int delay_slots = 0; /* How many delay slots left to fill?  */
 {
   static int repeat_slot = 0;
   static int delay_slots = 0; /* How many delay slots left to fill?  */
@@ -5164,7 +4814,7 @@ md_assemble (line)
   int c;
 
   input_line_pointer = line;
   int c;
 
   input_line_pointer = line;
-  c = get_symbol_end ();
+  c = get_symbol_name (&line);
 
   if (cpu == VNONE)
     cpu = V542;
 
   if (cpu == VNONE)
     cpu = V542;
@@ -5197,8 +4847,11 @@ md_assemble (line)
            {
              if (words > delay_slots)
                {
            {
              if (words > delay_slots)
                {
-                 as_bad (_("Instruction does not fit in available delay "
-                           "slots (%d-word insn, %d slots left)"),
+                 as_bad (ngettext ("Instruction does not fit in available "
+                                   "delay slots (%d-word insn, %d slot left)",
+                                   "Instruction does not fit in available "
+                                   "delay slots (%d-word insn, %d slots left)",
+                                   delay_slots),
                          words, delay_slots);
                  delay_slots = 0;
                  return;
                          words, delay_slots);
                  delay_slots = 0;
                  return;
@@ -5269,9 +4922,13 @@ md_assemble (line)
        {
          if (words > delay_slots)
            {
        {
          if (words > delay_slots)
            {
-             as_warn (_("Instruction does not fit in available delay "
-                        "slots (%d-word insn, %d slots left). "
-                        "Resulting behavior is undefined."),
+             as_warn (ngettext ("Instruction does not fit in available "
+                                "delay slots (%d-word insn, %d slot left). "
+                                "Resulting behavior is undefined.",
+                                "Instruction does not fit in available "
+                                "delay slots (%d-word insn, %d slots left). "
+                                "Resulting behavior is undefined.",
+                                delay_slots),
                       words, delay_slots);
              delay_slots = 0;
              return;
                       words, delay_slots);
              delay_slots = 0;
              return;
@@ -5319,14 +4976,13 @@ md_assemble (line)
    a ".file" symbol.  */
 
 void
    a ".file" symbol.  */
 
 void
-tic54x_adjust_symtab ()
+tic54x_adjust_symtab (void)
 {
   if (symbol_rootP == NULL
       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
     {
 {
   if (symbol_rootP == NULL
       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
     {
-      char *filename;
       unsigned lineno;
       unsigned lineno;
-      as_where (&filename, &lineno);
+      const char * filename = as_where (&lineno);
       c_dot_file_symbol (filename, 0);
     }
 }
       c_dot_file_symbol (filename, 0);
     }
 }
@@ -5347,8 +5003,7 @@ tic54x_unrecognized_line (int c)
    FIXME -- obviously this isn't done yet.  These locals still show up in the
    symbol table.  */
 void
    FIXME -- obviously this isn't done yet.  These locals still show up in the
    symbol table.  */
 void
-tic54x_define_label (sym)
-     symbolS *sym;
+tic54x_define_label (symbolS *sym)
 {
   /* Just in case we need this later; note that this is not necessarily the
      same thing as line_label...
 {
   /* Just in case we need this later; note that this is not necessarily the
      same thing as line_label...
@@ -5362,25 +5017,24 @@ tic54x_define_label (sym)
 /* Try to parse something that normal parsing failed at.  */
 
 symbolS *
 /* Try to parse something that normal parsing failed at.  */
 
 symbolS *
-tic54x_undefined_symbol (name)
-     char *name;
+tic54x_undefined_symbol (char *name)
 {
 {
-  symbol *sym;
+  tic54x_symbol *sym;
 
   /* Not sure how to handle predefined symbols.  */
 
   /* Not sure how to handle predefined symbols.  */
-  if ((sym = (symbol *) hash_find (cc_hash, name)) != NULL ||
-      (sym = (symbol *) hash_find (cc2_hash, name)) != NULL ||
-      (sym = (symbol *) hash_find (cc3_hash, name)) != NULL ||
-      (sym = (symbol *) hash_find (misc_symbol_hash, name)) != NULL ||
-      (sym = (symbol *) hash_find (sbit_hash, name)) != NULL)
+  if ((sym = (tic54x_symbol *) hash_find (cc_hash, name)) != NULL ||
+      (sym = (tic54x_symbol *) hash_find (cc2_hash, name)) != NULL ||
+      (sym = (tic54x_symbol *) hash_find (cc3_hash, name)) != NULL ||
+      (sym = (tic54x_symbol *) hash_find (misc_symbol_hash, name)) != NULL ||
+      (sym = (tic54x_symbol *) hash_find (sbit_hash, name)) != NULL)
     {
       return symbol_new (name, reg_section,
                         (valueT) sym->value,
                         &zero_address_frag);
     }
 
     {
       return symbol_new (name, reg_section,
                         (valueT) sym->value,
                         &zero_address_frag);
     }
 
-  if ((sym = (symbol *) hash_find (reg_hash, name)) != NULL ||
-      (sym = (symbol *) hash_find (mmreg_hash, name)) != NULL ||
+  if ((sym = (tic54x_symbol *) hash_find (reg_hash, name)) != NULL ||
+      (sym = (tic54x_symbol *) hash_find (mmreg_hash, name)) != NULL ||
       !strcasecmp (name, "a") || !strcasecmp (name, "b"))
     {
       return symbol_new (name, reg_section,
       !strcasecmp (name, "a") || !strcasecmp (name, "b"))
     {
       return symbol_new (name, reg_section,
@@ -5395,51 +5049,29 @@ tic54x_undefined_symbol (name)
    it.  */
 
 int
    it.  */
 
 int
-tic54x_parse_name (name, exp)
-     char *name ATTRIBUTE_UNUSED;
-     expressionS *exp ATTRIBUTE_UNUSED;
+tic54x_parse_name (char *name ATTRIBUTE_UNUSED,
+                  expressionS *expn ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 
 {
   return 0;
 }
 
-char *
-md_atof (type, literalP, sizeP)
-     int type;
-     char *literalP;
-     int *sizeP;
+const char *
+md_atof (int type, char *literalP, int *sizeP)
 {
 {
-#define MAX_LITTLENUMS 2
-  LITTLENUM_TYPE words[MAX_LITTLENUMS];
-  LITTLENUM_TYPE *word;
-  /* Only one precision on the c54x.  */
-  int prec = 2;
-  char *t = atof_ieee (input_line_pointer, type, words);
-  if (t)
-    input_line_pointer = t;
-  *sizeP = 4;
-
   /* Target data is little-endian, but floats are stored
      big-"word"ian.  ugh.  */
   /* Target data is little-endian, but floats are stored
      big-"word"ian.  ugh.  */
-  for (word = words; prec--;)
-    {
-      md_number_to_chars (literalP, (long) (*word++), sizeof (LITTLENUM_TYPE));
-      literalP += sizeof (LITTLENUM_TYPE);
-    }
-
-  return 0;
+  return ieee_md_atof (type, literalP, sizeP, TRUE);
 }
 
 arelent *
 }
 
 arelent *
-tc_gen_reloc (section, fixP)
-     asection *section;
-     fixS *fixP;
+tc_gen_reloc (asection *section, fixS *fixP)
 {
   arelent *rel;
   bfd_reloc_code_real_type code = fixP->fx_r_type;
   asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy);
 
 {
   arelent *rel;
   bfd_reloc_code_real_type code = fixP->fx_r_type;
   asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy);
 
-  rel = (arelent *) xmalloc (sizeof (arelent));
-  rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
+  rel = XNEW (arelent);
+  rel->sym_ptr_ptr = XNEW (asymbol *);
   *rel->sym_ptr_ptr = sym;
   /* We assume that all rel->address are host byte offsets.  */
   rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
   *rel->sym_ptr_ptr = sym;
   /* We assume that all rel->address are host byte offsets.  */
   rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
@@ -5463,14 +5095,9 @@ tc_gen_reloc (section, fixP)
 /* Handle cons expressions.  */
 
 void
 /* Handle cons expressions.  */
 
 void
-tic54x_cons_fix_new (frag, where, octets, exp)
-     fragS *frag;
-     int where;
-     int octets;
-     expressionS *exp;
+tic54x_cons_fix_new (fragS *frag, int where, int octets, expressionS *expn,
+                    bfd_reloc_code_real_type r)
 {
 {
-  bfd_reloc_code_real_type r;
-
   switch (octets)
     {
     default:
   switch (octets)
     {
     default:
@@ -5490,7 +5117,7 @@ tic54x_cons_fix_new (frag, where, octets, exp)
        r = BFD_RELOC_32;
       break;
     }
        r = BFD_RELOC_32;
       break;
     }
-  fix_new_exp (frag, where, octets, exp, 0, r);
+  fix_new_exp (frag, where, octets, expn, 0, r);
 }
 
 /* Attempt to simplify or even eliminate a fixup.
 }
 
 /* Attempt to simplify or even eliminate a fixup.
@@ -5499,10 +5126,7 @@ tic54x_cons_fix_new (frag, where, octets, exp)
    If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry.   */
 
 void
    If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry.   */
 
 void
-md_apply_fix3 (fixP, valP, seg)
-     fixS *fixP;
-     valueT * valP;
-     segT seg ATTRIBUTE_UNUSED;
+md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
 {
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   valueT val = * valP;
 {
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   valueT val = * valP;
@@ -5553,39 +5177,22 @@ md_apply_fix3 (fixP, valP, seg)
    don't need to do anything here, since BFD does the proper encoding.  */
 
 valueT
    don't need to do anything here, since BFD does the proper encoding.  */
 
 valueT
-md_section_align (segment, section_size)
-     segT segment ATTRIBUTE_UNUSED;
-     valueT section_size;
+md_section_align (segT segment ATTRIBUTE_UNUSED, valueT section_size)
 {
   return section_size;
 }
 
 long
 {
   return section_size;
 }
 
 long
-md_pcrel_from (fixP)
-     fixS *fixP ATTRIBUTE_UNUSED;
+md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 
 {
   return 0;
 }
 
-#if defined OBJ_COFF
-
-short
-tc_coff_fix2rtype (fixP)
-     fixS *fixP;
-{
-  return (fixP->fx_r_type);
-}
-
-#endif /* OBJ_COFF */
-
 /* Mostly little-endian, but longwords (4 octets) get MS word stored
    first.  */
 
 void
 /* Mostly little-endian, but longwords (4 octets) get MS word stored
    first.  */
 
 void
-tic54x_number_to_chars (buf, val, n)
-     char *buf;
-     valueT val;
-     int n;
+tic54x_number_to_chars (char *buf, valueT val, int n)
 {
   if (n != 4)
     number_to_chars_littleendian (buf, val, n);
 {
   if (n != 4)
     number_to_chars_littleendian (buf, val, n);
@@ -5597,9 +5204,8 @@ tic54x_number_to_chars (buf, val, n)
 }
 
 int
 }
 
 int
-tic54x_estimate_size_before_relax (frag, seg)
-     fragS *frag ATTRIBUTE_UNUSED;
-     segT seg ATTRIBUTE_UNUSED;
+tic54x_estimate_size_before_relax (fragS *frag ATTRIBUTE_UNUSED,
+                                  segT seg ATTRIBUTE_UNUSED)
 {
   return 0;
 }
 {
   return 0;
 }
@@ -5608,9 +5214,7 @@ tic54x_estimate_size_before_relax (frag, seg)
    to symbols being in different frags.  return number of octets added.  */
 
 int
    to symbols being in different frags.  return number of octets added.  */
 
 int
-tic54x_relax_frag (frag, stretch)
-     fragS *frag;
-     long stretch ATTRIBUTE_UNUSED;
+tic54x_relax_frag (fragS *frag, long stretch ATTRIBUTE_UNUSED)
 {
   symbolS *sym = frag->fr_symbol;
   int growth = 0;
 {
   symbolS *sym = frag->fr_symbol;
   int growth = 0;
@@ -5709,10 +5313,9 @@ tic54x_relax_frag (frag, stretch)
 }
 
 void
 }
 
 void
-tic54x_convert_frag (abfd, seg, frag)
-     bfd *abfd ATTRIBUTE_UNUSED;
-     segT seg ATTRIBUTE_UNUSED;
-     fragS *frag;
+tic54x_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
+                    segT seg ATTRIBUTE_UNUSED,
+                    fragS *frag)
 {
   /* Offset is in bytes.  */
   frag->fr_offset = (frag->fr_next->fr_address
 {
   /* Offset is in bytes.  */
   frag->fr_offset = (frag->fr_next->fr_address
@@ -5732,50 +5335,43 @@ tic54x_convert_frag (abfd, seg, frag)
    syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
    I guess, except I've never seen a definition of MRI syntax).
 
    syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
    I guess, except I've never seen a definition of MRI syntax).
 
-   C is the character that used to be at *REST, which points to the end of the
-   label.
-
    Don't allow labels to start with '.'  */
 
 int
    Don't allow labels to start with '.'  */
 
 int
-tic54x_start_label (c, rest)
-     int c;
-     char *rest;
+tic54x_start_label (char * label_start, int nul_char, int next_char)
 {
 {
+  char *rest;
+
   /* If within .struct/.union, no auto line labels, please.  */
   if (current_stag != NULL)
     return 0;
 
   /* Disallow labels starting with "."  */
   /* If within .struct/.union, no auto line labels, please.  */
   if (current_stag != NULL)
     return 0;
 
   /* Disallow labels starting with "."  */
-  if (c != ':')
+  if (next_char != ':')
     {
     {
-      char *label = rest;
-
-      while (!is_end_of_line[(int) label[-1]])
-       --label;
-      if (*label == '.')
+      if (*label_start == '.')
        {
        {
-         as_bad (_("Invalid label '%s'"), label);
+         as_bad (_("Invalid label '%s'"), label_start);
          return 0;
        }
     }
 
          return 0;
        }
     }
 
-  if (is_end_of_line[(int) c])
+  if (is_end_of_line[(unsigned char) next_char])
     return 1;
 
     return 1;
 
-  if (ISSPACE (c))
-    while (ISSPACE (c = *++rest))
-      ;
-  if (c == '.')
-    {
-      /* Don't let colon () define a label for any of these...  */
-      return (strncasecmp (rest, ".tag", 4) != 0 || !ISSPACE (rest[4]))
-       && (strncasecmp (rest, ".struct", 7) != 0 || !ISSPACE (rest[7]))
-       && (strncasecmp (rest, ".union", 6) != 0 || !ISSPACE (rest[6]))
-       && (strncasecmp (rest, ".macro", 6) != 0 || !ISSPACE (rest[6]))
-       && (strncasecmp (rest, ".set", 4) != 0 || !ISSPACE (rest[4]))
-       && (strncasecmp (rest, ".equ", 4) != 0 || !ISSPACE (rest[4]));
-    }
+  rest = input_line_pointer;
+  if (nul_char == '"')
+    ++rest;
+  while (ISSPACE (next_char))
+    next_char = *++rest;
+  if (next_char != '.')
+    return 1;
 
 
-  return 1;
+  /* Don't let colon () define a label for any of these...  */
+  return ((strncasecmp (rest, ".tag", 4) != 0 || !ISSPACE (rest[4]))
+         && (strncasecmp (rest, ".struct", 7) != 0 || !ISSPACE (rest[7]))
+         && (strncasecmp (rest, ".union", 6) != 0 || !ISSPACE (rest[6]))
+         && (strncasecmp (rest, ".macro", 6) != 0 || !ISSPACE (rest[6]))
+         && (strncasecmp (rest, ".set", 4) != 0 || !ISSPACE (rest[4]))
+         && (strncasecmp (rest, ".equ", 4) != 0 || !ISSPACE (rest[4])));
 }
 }
GDB Binutils - Deliverables
This page took 0.06403 seconds and 4 git commands to generate.