Fix PR gas/26001 (pdp11-*-*)

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

diff --git a/gas/config/tc-tic4x.c b/gas/config/tc-tic4x.c
index 61361050b76291ba87959037c4f899b9850326bf..cc477b62bbca1d626e05d94e3e4d7ba46a91accf 100644 (file)
--- a/gas/config/tc-tic4x.c
+++ b/gas/config/tc-tic4x.c
@@ -1,5 +1,5 @@
-/* tc-c4x.c -- Assemble for the Texas Instruments TMS320C[34]x.
-   Copyright (C) 1997,1998, 2002 Free Software Foundation.
+/* tc-tic4x.c -- Assemble for the Texas Instruments TMS320C[34]x.
+   Copyright (C) 1997-2020 Free Software Foundation, Inc.

 
    Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
 
 
    Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
 


@@ -7,7 +7,7 @@
 
    GAS is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    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,


@@ -17,21 +17,16 @@
 
    You should have received a copy of the GNU General Public License
    along with GAS; see the file COPYING.  If not, write to
 
    You should have received a copy of the GNU General Public License
    along with GAS; see the file COPYING.  If not, write to

-   the Free Software Foundation, 59 Temple Place - Suite 330, 
-   Boston, MA 02111-1307, USA.  */
+   the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 /*
   TODOs:
   ------
 /*
   TODOs:
   ------

-  
+

   o .align cannot handle fill-data-width larger than 0xFF/8-bits. It
     should be possible to define a 32-bits pattern.
 
   o .align cannot handle fill-data-width larger than 0xFF/8-bits. It
     should be possible to define a 32-bits pattern.
 

-  o .align fills all section with NOP's when used regardless if has
-    been used in .text or .data. (However the .align is primarely
-    intended used in .text sections. If you require something else,
-    use .align <size>,0x00)
-
-  o .align: Implement a 'bu' insn if the number of nop's exeeds 4
+  o .align: Implement a 'bu' insn if the number of nop's exceeds 4

     within the align frag. if(fragsize>4words) insert bu fragend+1
     first.
 
     within the align frag. if(fragsize>4words) insert bu fragend+1
     first.
 


@@ -42,44 +37,35 @@
   o Evaluation of constant floating point expressions (expr.c needs
     work!)
 
   o Evaluation of constant floating point expressions (expr.c needs
     work!)
 

-  o Support 'abc' constants (that is 0x616263)
-*/
-
-#include <stdio.h>
-#include <ctype.h>
+  o Support 'abc' constants (that is 0x616263).  */

 
 #include "as.h"
 
 #include "as.h"

+#include "safe-ctype.h"

 #include "opcode/tic4x.h"
 #include "subsegs.h"
 #include "opcode/tic4x.h"
 #include "subsegs.h"

-#include "obstack.h"
-#include "symbols.h"
-#include "listing.h"

 
 /* OK, we accept a syntax similar to the other well known C30
 
 /* OK, we accept a syntax similar to the other well known C30

-   assembly tools.  With C4X_ALT_SYNTAX defined we are more
+   assembly tools.  With TIC4X_ALT_SYNTAX defined we are more

    flexible, allowing a more Unix-like syntax:  `%' in front of
    register names, `#' in front of immediate constants, and
    not requiring `@' in front of direct addresses.  */
 
    flexible, allowing a more Unix-like syntax:  `%' in front of
    register names, `#' in front of immediate constants, and
    not requiring `@' in front of direct addresses.  */
 

-#define C4X_ALT_SYNTAX
-
-/* Equal to MAX_PRECISION in atof-ieee.c.  */
-#define MAX_LITTLENUMS 6       /* (12 bytes) */
+#define TIC4X_ALT_SYNTAX

 
 /* Handle of the inst mnemonic hash table.  */
 
 /* Handle of the inst mnemonic hash table.  */

-static struct hash_control *c4x_op_hash = NULL;
+static struct hash_control *tic4x_op_hash = NULL;

 
 /* Handle asg pseudo.  */
 
 /* Handle asg pseudo.  */

-static struct hash_control *c4x_asg_hash = NULL;
+static struct hash_control *tic4x_asg_hash = NULL;

 
 

-static unsigned int c4x_cpu = 0;       /* Default to TMS320C40.  */
-static unsigned int c4x_revision = 0;   /* CPU revision */
-static unsigned int c4x_idle2 = 0;      /* Idle2 support */
-static unsigned int c4x_lowpower = 0;   /* Lowpower support */
-static unsigned int c4x_enhanced = 0;   /* Enhanced opcode support */
-static unsigned int c4x_big_model = 0; /* Default to small memory model.  */
-static unsigned int c4x_reg_args = 0;  /* Default to args passed on stack.  */
-static unsigned long c4x_oplevel = 0;   /* Opcode level */
+static unsigned int tic4x_cpu = 0;        /* Default to TMS320C40.  */
+static unsigned int tic4x_revision = 0;   /* CPU revision */
+static unsigned int tic4x_idle2 = 0;      /* Idle2 support */
+static unsigned int tic4x_lowpower = 0;   /* Lowpower support */
+static unsigned int tic4x_enhanced = 0;   /* Enhanced opcode support */
+static unsigned int tic4x_big_model = 0;  /* Default to small memory model.  */
+static unsigned int tic4x_reg_args = 0;   /* Default to args passed on stack.  */
+static unsigned long tic4x_oplevel = 0;   /* Opcode level */

 
 #define OPTION_CPU      'm'
 #define OPTION_BIG      (OPTION_MD_BASE + 1)
 
 #define OPTION_CPU      'm'
 #define OPTION_BIG      (OPTION_MD_BASE + 1)


@@ -91,7 +77,7 @@ static unsigned long c4x_oplevel = 0;   /* Opcode level */
 #define OPTION_ENHANCED (OPTION_MD_BASE + 7)
 #define OPTION_REV      (OPTION_MD_BASE + 8)
 
 #define OPTION_ENHANCED (OPTION_MD_BASE + 7)
 #define OPTION_REV      (OPTION_MD_BASE + 8)
 

-CONST char *md_shortopts = "bm:prs";
+const char *md_shortopts = "bm:prs";

 struct option md_longopts[] =
 {
   { "mcpu",   required_argument, NULL, OPTION_CPU },
 struct option md_longopts[] =
 {
   { "mcpu",   required_argument, NULL, OPTION_CPU },


@@ -115,182 +101,91 @@ typedef enum
     M_UNKNOWN, M_IMMED, M_DIRECT, M_REGISTER, M_INDIRECT,
     M_IMMED_F, M_PARALLEL, M_HI
   }
     M_UNKNOWN, M_IMMED, M_DIRECT, M_REGISTER, M_INDIRECT,
     M_IMMED_F, M_PARALLEL, M_HI
   }

-c4x_addr_mode_t;
+tic4x_addr_mode_t;

 
 

-typedef struct c4x_operand
+typedef struct tic4x_operand

   {
   {

-    c4x_addr_mode_t mode;      /* Addressing mode.  */
+    tic4x_addr_mode_t mode;    /* Addressing mode.  */

     expressionS expr;          /* Expression.  */
     int disp;                  /* Displacement for indirect addressing.  */
     int aregno;                        /* Aux. register number.  */
     LITTLENUM_TYPE fwords[MAX_LITTLENUMS];     /* Float immed. number.  */
   }
     expressionS expr;          /* Expression.  */
     int disp;                  /* Displacement for indirect addressing.  */
     int aregno;                        /* Aux. register number.  */
     LITTLENUM_TYPE fwords[MAX_LITTLENUMS];     /* Float immed. number.  */
   }

-c4x_operand_t;
+tic4x_operand_t;

 
 

-typedef struct c4x_insn
+typedef struct tic4x_insn

   {
   {

-    char name[C4X_NAME_MAX];   /* Mnemonic of instruction.  */
+    char name[TIC4X_NAME_MAX]; /* Mnemonic of instruction.  */

     unsigned int in_use;       /* True if in_use.  */
     unsigned int parallel;     /* True if parallel instruction.  */
     unsigned int nchars;       /* This is always 4 for the C30.  */
     unsigned long opcode;      /* Opcode number.  */
     expressionS exp;           /* Expression required for relocation.  */
     unsigned int in_use;       /* True if in_use.  */
     unsigned int parallel;     /* True if parallel instruction.  */
     unsigned int nchars;       /* This is always 4 for the C30.  */
     unsigned long opcode;      /* Opcode number.  */
     expressionS exp;           /* Expression required for relocation.  */

-    int reloc;                 /* Relocation type required.  */
+    /* Relocation type required.  */
+    bfd_reloc_code_real_type reloc;

     int pcrel;                 /* True if relocation PC relative.  */
     char *pname;               /* Name of instruction in parallel.  */
     unsigned int num_operands; /* Number of operands in total.  */
     int pcrel;                 /* True if relocation PC relative.  */
     char *pname;               /* Name of instruction in parallel.  */
     unsigned int num_operands; /* Number of operands in total.  */

-    c4x_inst_t *inst;          /* Pointer to first template.  */
-    c4x_operand_t operands[C4X_OPERANDS_MAX];
+    tic4x_inst_t *inst;                /* Pointer to first template.  */
+    tic4x_operand_t operands[TIC4X_OPERANDS_MAX];

   }
   }

-c4x_insn_t;
-
-static c4x_insn_t the_insn;    /* Info about our instruction.  */
-static c4x_insn_t *insn = &the_insn;
-
-static int c4x_gen_to_words
-  PARAMS ((FLONUM_TYPE, LITTLENUM_TYPE *, int ));
-static char *c4x_atof
-  PARAMS ((char *, char, LITTLENUM_TYPE * ));
-static void c4x_insert_reg
-  PARAMS ((char *, int ));
-static void c4x_insert_sym
-  PARAMS ((char *, int ));
-static char *c4x_expression
-  PARAMS ((char *, expressionS *));
-static char *c4x_expression_abs
-  PARAMS ((char *, int *));
-static void c4x_emit_char
-  PARAMS ((char, int));
-static void c4x_seg_alloc
-  PARAMS ((char *, segT, int, symbolS *));
-static void c4x_asg
-  PARAMS ((int));
-static void c4x_bss
-  PARAMS ((int));
-static void c4x_globl
-  PARAMS ((int));
-static void c4x_cons
-  PARAMS ((int));
-static void c4x_stringer
-  PARAMS ((int));
-static void c4x_eval
-  PARAMS ((int));
-static void c4x_newblock
-  PARAMS ((int));
-static void c4x_sect
-  PARAMS ((int));
-static void c4x_set
-  PARAMS ((int));
-static void c4x_usect
-  PARAMS ((int));
-static void c4x_version
-  PARAMS ((int));
-static void c4x_init_regtable
-  PARAMS ((void));
-static void c4x_init_symbols
-  PARAMS ((void));
-static int c4x_inst_insert
-  PARAMS ((c4x_inst_t *));
-static c4x_inst_t *c4x_inst_make
-  PARAMS ((char *, unsigned long, char *));
-static int c4x_inst_add
-  PARAMS ((c4x_inst_t *));
-void md_begin
-  PARAMS ((void));
-void c4x_end
-  PARAMS ((void));
-static int c4x_indirect_parse
-  PARAMS ((c4x_operand_t *, const c4x_indirect_t *));
-static char *c4x_operand_parse
-  PARAMS ((char *, c4x_operand_t *));
-static int c4x_operands_match
-  PARAMS ((c4x_inst_t *, c4x_insn_t *, int));
-static void c4x_insn_check
-  PARAMS ((c4x_insn_t *));
-static void c4x_insn_output
-  PARAMS ((c4x_insn_t *));
-static int c4x_operands_parse
-  PARAMS ((char *, c4x_operand_t *, int ));
-void md_assemble
-  PARAMS ((char *));
-void c4x_cleanup
-  PARAMS ((void));
-char *md_atof
-  PARAMS ((int, char *, int *));
-void md_apply_fix3
-  PARAMS ((fixS *, valueT *, segT ));
-void md_convert_frag
-  PARAMS ((bfd *, segT, fragS *));
-void md_create_short_jump
-  PARAMS ((char *, addressT, addressT, fragS *, symbolS *));
-void md_create_long_jump
-  PARAMS ((char *, addressT, addressT, fragS *, symbolS *));
-int md_estimate_size_before_relax
-  PARAMS ((register fragS *, segT));
-int md_parse_option
-  PARAMS ((int, char *));
-void md_show_usage
-  PARAMS ((FILE *));
-int c4x_unrecognized_line
-  PARAMS ((int));
-symbolS *md_undefined_symbol
-  PARAMS ((char *));
-void md_operand
-  PARAMS ((expressionS *));
-valueT md_section_align
-  PARAMS ((segT, valueT));
-static int c4x_pc_offset
-  PARAMS ((unsigned int));
-long md_pcrel_from
-  PARAMS ((fixS *));
-int c4x_do_align
-  PARAMS ((int, const char *, int, int));
-void c4x_start_line
-  PARAMS ((void));
-arelent *tc_gen_reloc
-  PARAMS ((asection *, fixS *));
+tic4x_insn_t;
+
+static tic4x_insn_t the_insn;  /* Info about our instruction.  */
+static tic4x_insn_t *insn = &the_insn;
+
+static void tic4x_asg (int);
+static void tic4x_bss (int);
+static void tic4x_globl (int);
+static void tic4x_cons (int);
+static void tic4x_stringer (int);
+static void tic4x_eval (int);
+static void tic4x_newblock (int);
+static void tic4x_sect (int);
+static void tic4x_set (int);
+static void tic4x_usect (int);
+static void tic4x_version (int);

 
 
 const pseudo_typeS
   md_pseudo_table[] =
 {
   {"align", s_align_bytes, 32},
 
 
 const pseudo_typeS
   md_pseudo_table[] =
 {
   {"align", s_align_bytes, 32},

-  {"ascii", c4x_stringer, 1},
-  {"asciz", c4x_stringer, 0},
-  {"asg", c4x_asg, 0},
+  {"ascii", tic4x_stringer, 1},
+  {"asciz", tic4x_stringer, 0},
+  {"asg", tic4x_asg, 0},

   {"block", s_space, 4},
   {"block", s_space, 4},

-  {"byte", c4x_cons, 1},
-  {"bss", c4x_bss, 0},
+  {"byte", tic4x_cons, 1},
+  {"bss", tic4x_bss, 0},

   {"copy", s_include, 0},
   {"copy", s_include, 0},

-  {"def", c4x_globl, 0},
-  {"equ", c4x_set, 0},
-  {"eval", c4x_eval, 0},
-  {"global", c4x_globl, 0},
-  {"globl", c4x_globl, 0},
-  {"hword", c4x_cons, 2},
+  {"def", tic4x_globl, 0},
+  {"equ", tic4x_set, 0},
+  {"eval", tic4x_eval, 0},
+  {"global", tic4x_globl, 0},
+  {"globl", tic4x_globl, 0},
+  {"hword", tic4x_cons, 2},

   {"ieee", float_cons, 'i'},
   {"ieee", float_cons, 'i'},

-  {"int", c4x_cons, 4},                 /* .int allocates 4 bytes.  */
+  {"int", tic4x_cons, 4},               /* .int allocates 4 bytes.  */

   {"ldouble", float_cons, 'e'},
   {"ldouble", float_cons, 'e'},

-  {"newblock", c4x_newblock, 0},
+  {"newblock", tic4x_newblock, 0},

   {"ref", s_ignore, 0},                 /* All undefined treated as external.  */
   {"ref", s_ignore, 0},                 /* All undefined treated as external.  */

-  {"set", c4x_set, 0},
-  {"sect", c4x_sect, 1},        /* Define named section.  */
+  {"set", tic4x_set, 0},
+  {"sect", tic4x_sect, 1},      /* Define named section.  */

   {"space", s_space, 4},
   {"space", s_space, 4},

-  {"string", c4x_stringer, 0},
-  {"usect", c4x_usect, 0},       /* Reserve space in uninit. named sect.  */
-  {"version", c4x_version, 0},
-  {"word", c4x_cons, 4},        /* .word allocates 4 bytes.  */
-  {"xdef", c4x_globl, 0},
+  {"string", tic4x_stringer, 0},
+  {"usect", tic4x_usect, 0},       /* Reserve space in uninit. named sect.  */
+  {"version", tic4x_version, 0},
+  {"word", tic4x_cons, 4},      /* .word allocates 4 bytes.  */
+  {"xdef", tic4x_globl, 0},

   {NULL, 0, 0},
 };
 
 int md_short_jump_size = 4;
 int md_long_jump_size = 4;
   {NULL, 0, 0},
 };
 
 int md_short_jump_size = 4;
 int md_long_jump_size = 4;

-const int md_reloc_size = RELSZ;       /* Coff headers.  */

 
 /* This array holds the chars that always start a comment.  If the
    pre-processor is disabled, these aren't very useful.  */
 
 /* This array holds the chars that always start a comment.  If the
    pre-processor is disabled, these aren't very useful.  */

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

 const char comment_chars[] = ";!";
 #else
 const char comment_chars[] = ";";
 const char comment_chars[] = ";!";
 #else
 const char comment_chars[] = ";";


@@ -298,10 +193,10 @@ const char comment_chars[] = ";";
 
 /* This array holds the chars that only start a comment at the beginning of
    a line.  If the line seems to have the form '# 123 filename'
 
 /* This array holds the chars that only start a comment at the beginning of
    a line.  If the line seems to have the form '# 123 filename'

-   .line and .file directives will appear in the pre-processed output. 
+   .line and .file directives will appear in the pre-processed output.

    Note that input_file.c hand checks for '#' at the beginning of the
    first line of the input file.  This is because the compiler outputs
    Note that input_file.c hand checks for '#' at the beginning of the
    first line of the input file.  This is because the compiler outputs

-   #NO_APP at the beginning of its output. 
+   #NO_APP at the beginning of its output.

    Also note that comments like this one will always work.  */
 const char line_comment_chars[] = "#*";
 
    Also note that comments like this one will always work.  */
 const char line_comment_chars[] = "#*";
 


@@ -325,8 +220,8 @@ const char FLT_CHARS[] = "fFilsS";
 extern FLONUM_TYPE generic_floating_point_number;
 
 /* Precision in LittleNums.  */
 extern FLONUM_TYPE generic_floating_point_number;
 
 /* Precision in LittleNums.  */

-#define MAX_PRECISION (4)       /* Its a bit overkill for us, but the code
-                                   reqires it... */
+#define MAX_PRECISION (4)       /* It's a bit overkill for us, but the code
+                                   requires it... */

 #define S_PRECISION (1)                /* Short float constants 16-bit.  */
 #define F_PRECISION (2)                /* Float and double types 32-bit.  */
 #define E_PRECISION (4)         /* Extended precision, 64-bit (real 40-bit). */
 #define S_PRECISION (1)                /* Short float constants 16-bit.  */
 #define F_PRECISION (2)                /* Float and double types 32-bit.  */
 #define E_PRECISION (4)         /* Extended precision, 64-bit (real 40-bit). */


@@ -334,10 +229,7 @@ extern FLONUM_TYPE generic_floating_point_number;
 
 /* Turn generic_floating_point_number into a real short/float/double.  */
 static int
 
 /* Turn generic_floating_point_number into a real short/float/double.  */
 static int

-c4x_gen_to_words (flonum, words, precision)
-     FLONUM_TYPE flonum;
-     LITTLENUM_TYPE *words;
-     int precision;
+tic4x_gen_to_words (FLONUM_TYPE flonum, LITTLENUM_TYPE *words, int precision)

 {
   int return_value = 0;
   LITTLENUM_TYPE *p;           /* Littlenum pointer.  */
 {
   int return_value = 0;
   LITTLENUM_TYPE *p;           /* Littlenum pointer.  */


@@ -352,11 +244,11 @@ c4x_gen_to_words (flonum, words, precision)
   unsigned int rbit;            /* Round bit. */
   int shift;                   /* Shift count.  */
 
   unsigned int rbit;            /* Round bit. */
   int shift;                   /* Shift count.  */
 

-  /* NOTE: Svein Seldal <Svein.Seldal@solidas.com>
+  /* NOTE: Svein Seldal <Svein@dev.seldal.com>

      The code in this function is altered slightly to support floats
      with 31-bits mantissas, thus the documentation below may be a
      little bit inaccurate.
      The code in this function is altered slightly to support floats
      with 31-bits mantissas, thus the documentation below may be a
      little bit inaccurate.

-     
+

      By Michael P. Hayes <m.hayes@elec.canterbury.ac.nz>
      Here is how a generic floating point number is stored using
      flonums (an extension of bignums) where p is a pointer to an
      By Michael P. Hayes <m.hayes@elec.canterbury.ac.nz>
      Here is how a generic floating point number is stored using
      flonums (an extension of bignums) where p is a pointer to an


@@ -463,7 +355,7 @@ c4x_gen_to_words (flonum, words, precision)
 
      We now have to left shift the other littlenums by the same amount,
      propagating the shifted bits into the more significant littlenums.
 
      We now have to left shift the other littlenums by the same amount,
      propagating the shifted bits into the more significant littlenums.

-     To save a lot of unecessary shifting we only have to consider
+     To save a lot of unnecessary shifting we only have to consider

      two or three littlenums, since the greatest number of mantissa
      bits required is 24 + 1 rounding bit.  While two littlenums
      provide 32 bits of precision, the most significant littlenum
      two or three littlenums, since the greatest number of mantissa
      bits required is 24 + 1 rounding bit.  While two littlenums
      provide 32 bits of precision, the most significant littlenum


@@ -494,7 +386,7 @@ c4x_gen_to_words (flonum, words, precision)
       || flonum.sign == 0) /* = NaN */
     {
       if(flonum.sign == 0)
       || flonum.sign == 0) /* = NaN */
     {
       if(flonum.sign == 0)

-        as_bad ("Nan, using zero.");
+        as_bad (_("Nan, using zero."));

       words[0] = 0x8000;
       return return_value;
     }
       words[0] = 0x8000;
       return return_value;
     }


@@ -504,7 +396,7 @@ c4x_gen_to_words (flonum, words, precision)
       /* +INF:  Replace with maximum float.  */
       if (precision == S_PRECISION)
        words[0] = 0x77ff;
       /* +INF:  Replace with maximum float.  */
       if (precision == S_PRECISION)
        words[0] = 0x77ff;

-      else 
+      else

        {
          words[0] = 0x7f7f;
          words[1] = 0xffff;
        {
          words[0] = 0x7f7f;
          words[1] = 0xffff;


@@ -521,7 +413,7 @@ c4x_gen_to_words (flonum, words, precision)
       /* -INF:  Replace with maximum float.  */
       if (precision == S_PRECISION)
        words[0] = 0x7800;
       /* -INF:  Replace with maximum float.  */
       if (precision == S_PRECISION)
        words[0] = 0x7800;

-      else 
+      else

         words[0] = 0x7f80;
       if (precision == E_PRECISION)
         words[2] = 0x8000;
         words[0] = 0x7f80;
       if (precision == E_PRECISION)
         words[2] = 0x8000;


@@ -616,7 +508,7 @@ c4x_gen_to_words (flonum, words, precision)
     }
 
   if (abs (exponent) >= (1 << (exponent_bits - 1)))
     }
 
   if (abs (exponent) >= (1 << (exponent_bits - 1)))

-    as_bad ("Cannot represent exponent in %d bits", exponent_bits);
+    as_bad (_("Cannot represent exponent in %d bits"), exponent_bits);

 
   /* Force exponent to fit in desired field width.  */
   exponent &= (1 << (exponent_bits)) - 1;
 
   /* Force exponent to fit in desired field width.  */
   exponent &= (1 << (exponent_bits)) - 1;


@@ -651,10 +543,7 @@ c4x_gen_to_words (flonum, words, precision)
 
 /* Returns pointer past text consumed.  */
 static char *
 
 /* Returns pointer past text consumed.  */
 static char *

-c4x_atof (str, what_kind, words)
-     char *str;
-     char what_kind;
-     LITTLENUM_TYPE *words;
+tic4x_atof (char *str, char what_kind, LITTLENUM_TYPE *words)

 {
   /* Extra bits for zeroed low-order bits.  The 1st MAX_PRECISION are
      zeroed, the last contain flonum bits.  */
 {
   /* Extra bits for zeroed low-order bits.  The 1st MAX_PRECISION are
      zeroed, the last contain flonum bits.  */


@@ -702,7 +591,7 @@ c4x_atof (str, what_kind, words)
       break;
 
     default:
       break;
 
     default:

-      as_bad ("Invalid floating point number");
+      as_bad (_("Invalid floating point number"));

       return (NULL);
     }
 
       return (NULL);
     }
 


@@ -712,11 +601,11 @@ c4x_atof (str, what_kind, words)
   if (atof_generic (&return_value, ".", EXP_CHARS,
                    &generic_floating_point_number))
     {
   if (atof_generic (&return_value, ".", EXP_CHARS,
                    &generic_floating_point_number))
     {

-      as_bad ("Invalid floating point number");
+      as_bad (_("Invalid floating point number"));

       return (NULL);
     }
 
       return (NULL);
     }
 

-  c4x_gen_to_words (generic_floating_point_number,
+  tic4x_gen_to_words (generic_floating_point_number,

                    words, precision);
 
   /* Restore the generic_floating_point_number's storage alloc (and
                    words, precision);
 
   /* Restore the generic_floating_point_number's storage alloc (and


@@ -726,10 +615,8 @@ c4x_atof (str, what_kind, words)
   return return_value;
 }
 
   return return_value;
 }
 

-static void 
-c4x_insert_reg (regname, regnum)
-     char *regname;
-     int regnum;
+static void
+tic4x_insert_reg (const char *regname, int regnum)

 {
   char buf[32];
   int i;
 {
   char buf[32];
   int i;


@@ -737,17 +624,15 @@ c4x_insert_reg (regname, regnum)
   symbol_table_insert (symbol_new (regname, reg_section, (valueT) regnum,
                                   &zero_address_frag));
   for (i = 0; regname[i]; i++)
   symbol_table_insert (symbol_new (regname, reg_section, (valueT) regnum,
                                   &zero_address_frag));
   for (i = 0; regname[i]; i++)

-    buf[i] = islower (regname[i]) ? toupper (regname[i]) : regname[i];
+    buf[i] = ISLOWER (regname[i]) ? TOUPPER (regname[i]) : regname[i];

   buf[i] = '\0';
 
   symbol_table_insert (symbol_new (buf, reg_section, (valueT) regnum,
                                   &zero_address_frag));
 }
 
   buf[i] = '\0';
 
   symbol_table_insert (symbol_new (buf, reg_section, (valueT) regnum,
                                   &zero_address_frag));
 }
 

-static void 
-c4x_insert_sym (symname, value)
-     char *symname;
-     int value;
+static void
+tic4x_insert_sym (const char *symname, int value)

 {
   symbolS *symbolP;
 
 {
   symbolS *symbolP;
 


@@ -758,9 +643,7 @@ c4x_insert_sym (symname, value)
 }
 
 static char *
 }
 
 static char *

-c4x_expression (str, exp)
-     char *str;
-     expressionS *exp;
+tic4x_expression (char *str, expressionS *exp)

 {
   char *s;
   char *t;
 {
   char *s;
   char *t;


@@ -774,9 +657,7 @@ c4x_expression (str, exp)
 }
 
 static char *
 }
 
 static char *

-c4x_expression_abs (str, value)
-     char *str;
-     int *value;
+tic4x_expression_abs (char *str, offsetT *value)

 {
   char *s;
   char *t;
 {
   char *s;
   char *t;


@@ -789,10 +670,8 @@ c4x_expression_abs (str, value)
   return s;
 }
 
   return s;
 }
 

-static void 
-c4x_emit_char (c,b)
-     char c;
-     int b;
+static void
+tic4x_emit_char (char c, int b)

 {
   expressionS exp;
 
 {
   expressionS exp;
 


@@ -801,12 +680,11 @@ c4x_emit_char (c,b)
   emit_expr (&exp, b);
 }
 
   emit_expr (&exp, b);
 }
 

-static void 
-c4x_seg_alloc (name, seg, size, symbolP)
-     char *name ATTRIBUTE_UNUSED;
-     segT seg ATTRIBUTE_UNUSED;
-     int size;
-     symbolS *symbolP;
+static void
+tic4x_seg_alloc (char *name ATTRIBUTE_UNUSED,
+                segT seg ATTRIBUTE_UNUSED,
+                int size,
+                symbolS *symbolP)

 {
   /* Note that the size is in words
      so we multiply it by 4 to get the number of bytes to allocate.  */
 {
   /* Note that the size is in words
      so we multiply it by 4 to get the number of bytes to allocate.  */


@@ -827,14 +705,12 @@ c4x_seg_alloc (name, seg, size, symbolP)
 }
 
 /* .asg ["]character-string["], symbol */
 }
 
 /* .asg ["]character-string["], symbol */

-static void 
-c4x_asg (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_asg (int x ATTRIBUTE_UNUSED)

 {
   char c;
   char *name;
   char *str;
 {
   char c;
   char *name;
   char *str;

-  char *tmp;

 
   SKIP_WHITESPACE ();
   str = input_line_pointer;
 
   SKIP_WHITESPACE ();
   str = input_line_pointer;


@@ -844,35 +720,29 @@ c4x_asg (x)
     input_line_pointer++;
   if (*input_line_pointer != ',')
     {
     input_line_pointer++;
   if (*input_line_pointer != ',')
     {

-      as_bad ("Comma expected\n");
+      as_bad (_("Comma expected\n"));

       return;
     }
   *input_line_pointer++ = '\0';
       return;
     }
   *input_line_pointer++ = '\0';

-  name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
-  tmp = xmalloc (strlen (str) + 1);
-  strcpy (tmp, str);
-  str = tmp;
-  tmp = xmalloc (strlen (name) + 1);
-  strcpy (tmp, name);
-  name = tmp;
-  if (hash_find (c4x_asg_hash, name))
-    hash_replace (c4x_asg_hash, name, (PTR) str);
+  c = get_symbol_name (&name); /* Get terminator.  */
+  str = xstrdup (str);
+  name = xstrdup (name);
+  if (hash_find (tic4x_asg_hash, name))
+    hash_replace (tic4x_asg_hash, name, (void *) str);

   else
   else

-    hash_insert (c4x_asg_hash, name, (PTR) str);
-  *input_line_pointer = c;
+    hash_insert (tic4x_asg_hash, name, (void *) str);
+  (void) restore_line_pointer (c);

   demand_empty_rest_of_line ();
 }
 
 /* .bss symbol, size  */
   demand_empty_rest_of_line ();
 }
 
 /* .bss symbol, size  */

-static void 
-c4x_bss (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_bss (int x ATTRIBUTE_UNUSED)

 {
   char c;
   char *name;
   char *p;
 {
   char c;
   char *name;
   char *p;

-  int size;
+  offsetT size;

   segT current_seg;
   subsegT current_subseg;
   symbolS *symbolP;
   segT current_seg;
   subsegT current_subseg;
   symbolS *symbolP;


@@ -881,19 +751,20 @@ c4x_bss (x)
   current_subseg = now_subseg; /* Save current subseg.  */
 
   SKIP_WHITESPACE ();
   current_subseg = now_subseg; /* Save current subseg.  */
 
   SKIP_WHITESPACE ();

-  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"));

       return;
     }
 
   input_line_pointer =
       return;
     }
 
   input_line_pointer =

-    c4x_expression_abs (++input_line_pointer, &size);
+    tic4x_expression_abs (++input_line_pointer, &size);

   if (size < 0)
     {
   if (size < 0)
     {

-      as_bad (".bss size %d < 0!", size);
+      as_bad (_(".bss size %ld < 0!"), (long) size);

       return;
     }
   subseg_set (bss_section, 0);
       return;
     }
   subseg_set (bss_section, 0);


@@ -921,8 +792,7 @@ c4x_bss (x)
 }
 
 static void
 }
 
 static void

-c4x_globl (ignore)
-     int ignore ATTRIBUTE_UNUSED;
+tic4x_globl (int ignore ATTRIBUTE_UNUSED)

 {
   char *name;
   int c;
 {
   char *name;
   int c;


@@ -930,12 +800,12 @@ c4x_globl (ignore)
 
   do
     {
 
   do
     {

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

       symbolP = symbol_find_or_make (name);
       *input_line_pointer = c;
       symbolP = symbol_find_or_make (name);
       *input_line_pointer = c;

-      SKIP_WHITESPACE ();
+      SKIP_WHITESPACE_AFTER_NAME ();

       S_SET_STORAGE_CLASS (symbolP, C_EXT);
       S_SET_STORAGE_CLASS (symbolP, C_EXT);

+      S_SET_EXTERNAL (symbolP);

       if (c == ',')
        {
          input_line_pointer++;
       if (c == ',')
        {
          input_line_pointer++;


@@ -950,11 +820,10 @@ c4x_globl (ignore)
 }
 
 /* Handle .byte, .word. .int, .long */
 }
 
 /* Handle .byte, .word. .int, .long */

-static void 
-c4x_cons (bytes)
-     int bytes;
+static void
+tic4x_cons (int bytes)

 {
 {

-  register unsigned int c;
+  unsigned int c;

   do
     {
       SKIP_WHITESPACE ();
   do
     {
       SKIP_WHITESPACE ();


@@ -962,14 +831,14 @@ c4x_cons (bytes)
        {
          input_line_pointer++;
          while (is_a_char (c = next_char_of_string ()))
        {
          input_line_pointer++;
          while (is_a_char (c = next_char_of_string ()))

-           c4x_emit_char (c, 4);
+           tic4x_emit_char (c, 4);

          know (input_line_pointer[-1] == '\"');
        }
       else
        {
          expressionS exp;
 
          know (input_line_pointer[-1] == '\"');
        }
       else
        {
          expressionS exp;
 

-         input_line_pointer = c4x_expression (input_line_pointer, &exp);
+         input_line_pointer = tic4x_expression (input_line_pointer, &exp);

          if (exp.X_op == O_constant)
            {
              switch (bytes)
          if (exp.X_op == O_constant)
            {
              switch (bytes)


@@ -994,12 +863,11 @@ c4x_cons (bytes)
 }
 
 /* Handle .ascii, .asciz, .string */
 }
 
 /* Handle .ascii, .asciz, .string */

-static void 
-c4x_stringer (append_zero)
-     int append_zero; /*ex: bytes */
+static void
+tic4x_stringer (int append_zero)

 {
   int bytes;
 {
   int bytes;

-  register unsigned int c;
+  unsigned int c;

 
   bytes = 0;
   do
 
   bytes = 0;
   do


@@ -1010,13 +878,13 @@ c4x_stringer (append_zero)
          input_line_pointer++;
          while (is_a_char (c = next_char_of_string ()))
             {
          input_line_pointer++;
          while (is_a_char (c = next_char_of_string ()))
             {

-              c4x_emit_char (c, 1);
+              tic4x_emit_char (c, 1);

               bytes++;
             }
 
           if (append_zero)
             {
               bytes++;
             }
 
           if (append_zero)
             {

-              c4x_emit_char (c, 1);
+              tic4x_emit_char (c, 1);

               bytes++;
             }
 
               bytes++;
             }
 


@@ -1026,13 +894,13 @@ c4x_stringer (append_zero)
        {
          expressionS exp;
 
        {
          expressionS exp;
 

-         input_line_pointer = c4x_expression (input_line_pointer, &exp);
+         input_line_pointer = tic4x_expression (input_line_pointer, &exp);

          if (exp.X_op != O_constant)
             {
          if (exp.X_op != O_constant)
             {

-              as_bad("Non-constant symbols not allowed\n");
+              as_bad (_("Non-constant symbols not allowed\n"));

               return;
             }
               return;
             }

-          exp.X_add_number &= 255; /* Limit numeber to 8-bit */
+          exp.X_add_number &= 255; /* Limit number to 8-bit */

          emit_expr (&exp, 1);
           bytes++;
        }
          emit_expr (&exp, 1);
           bytes++;
        }


@@ -1041,64 +909,60 @@ c4x_stringer (append_zero)
 
   /* Fill out the rest of the expression with 0's to fill up a full word */
   if ( bytes&0x3 )
 
   /* Fill out the rest of the expression with 0's to fill up a full word */
   if ( bytes&0x3 )

-    c4x_emit_char (0, 4-(bytes&0x3));
+    tic4x_emit_char (0, 4-(bytes&0x3));

 
   input_line_pointer--;                /* Put terminator back into stream.  */
   demand_empty_rest_of_line ();
 }
 
 /* .eval expression, symbol */
 
   input_line_pointer--;                /* Put terminator back into stream.  */
   demand_empty_rest_of_line ();
 }
 
 /* .eval expression, symbol */

-static void 
-c4x_eval (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_eval (int x ATTRIBUTE_UNUSED)

 {
   char c;
 {
   char c;

-  int value;
+  offsetT value;

   char *name;
 
   SKIP_WHITESPACE ();
   input_line_pointer =
   char *name;
 
   SKIP_WHITESPACE ();
   input_line_pointer =

-    c4x_expression_abs (input_line_pointer, &value);
+    tic4x_expression_abs (input_line_pointer, &value);

   if (*input_line_pointer++ != ',')
     {
   if (*input_line_pointer++ != ',')
     {

-      as_bad ("Symbol missing\n");
+      as_bad (_("Symbol missing\n"));

       return;
     }
       return;
     }

-  name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
+  c = get_symbol_name (&name); /* Get terminator.  */
+  tic4x_insert_sym (name, value);
+  (void) restore_line_pointer (c);

   demand_empty_rest_of_line ();
   demand_empty_rest_of_line ();

-  c4x_insert_sym (name, value);

 }
 
 /* Reset local labels.  */
 }
 
 /* Reset local labels.  */

-static void 
-c4x_newblock (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_newblock (int x ATTRIBUTE_UNUSED)

 {
   dollar_label_clear ();
 }
 
 /* .sect "section-name" [, value] */
 /* .sect ["]section-name[:subsection-name]["] [, value] */
 {
   dollar_label_clear ();
 }
 
 /* .sect "section-name" [, value] */
 /* .sect ["]section-name[:subsection-name]["] [, value] */

-static void 
-c4x_sect (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_sect (int x ATTRIBUTE_UNUSED)

 {
   char c;
   char *section_name;
 {
   char c;
   char *section_name;

-  char *subsection_name;

   char *name;
   segT seg;
   char *name;
   segT seg;

-  int num;
+  offsetT num;

 
   SKIP_WHITESPACE ();
   if (*input_line_pointer == '"')
     input_line_pointer++;
 
   SKIP_WHITESPACE ();
   if (*input_line_pointer == '"')
     input_line_pointer++;

-  section_name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
+  c = get_symbol_name (&section_name); /* Get terminator.  */
+  if (c == '"')
+    c = * ++ input_line_pointer;

   input_line_pointer++;                /* Skip null symbol terminator.  */
   input_line_pointer++;                /* Skip null symbol terminator.  */

-  name = xmalloc (input_line_pointer - section_name + 1);
-  strcpy (name, section_name);
+  name = xstrdup (section_name);

 
   /* TI C from version 5.0 allows a section name to contain a
      subsection name as well. The subsection name is separated by a
 
   /* TI C from version 5.0 allows a section name to contain a
      subsection name as well. The subsection name is separated by a


@@ -1107,23 +971,25 @@ c4x_sect (x)
      Volker Kuhlmann  <v.kuhlmann@elec.canterbury.ac.nz>.  */
   if (c == ':')
     {
      Volker Kuhlmann  <v.kuhlmann@elec.canterbury.ac.nz>.  */
   if (c == ':')
     {

-      subsection_name = input_line_pointer;
-      c = get_symbol_end ();   /* Get terminator.  */
+      char *subname;
+      c = get_symbol_name (&subname);  /* Get terminator.  */
+      if (c == '"')
+       c = * ++ input_line_pointer;

       input_line_pointer++;    /* Skip null symbol terminator.  */
       input_line_pointer++;    /* Skip null symbol terminator.  */

-      as_warn (".sect: subsection name ignored");
+      as_warn (_(".sect: subsection name ignored"));

     }
 
   /* We might still have a '"' to discard, but the character after a
     }
 
   /* We might still have a '"' to discard, but the character after a

-     symbol name will be overwritten with a \0 by get_symbol_end()
+     symbol name will be overwritten with a \0 by get_symbol_name()

      [VK].  */
 
   if (c == ',')
     input_line_pointer =
      [VK].  */
 
   if (c == ',')
     input_line_pointer =

-      c4x_expression_abs (input_line_pointer, &num);
+      tic4x_expression_abs (input_line_pointer, &num);

   else if (*input_line_pointer == ',')
     {
       input_line_pointer =
   else if (*input_line_pointer == ',')
     {
       input_line_pointer =

-       c4x_expression_abs (++input_line_pointer, &num);
+       tic4x_expression_abs (++input_line_pointer, &num);

     }
   else
     num = 0;
     }
   else
     num = 0;


@@ -1135,14 +1001,14 @@ c4x_sect (x)
       symbol_set_frag (line_label, frag_now);
     }
 
       symbol_set_frag (line_label, frag_now);
     }
 

-  if (bfd_get_section_flags (stdoutput, seg) == SEC_NO_FLAGS)
+  if (bfd_section_flags (seg) == SEC_NO_FLAGS)

     {
     {

-      if (!bfd_set_section_flags (stdoutput, seg, SEC_DATA))
-       as_warn ("Error setting flags for \"%s\": %s", name,
+      if (!bfd_set_section_flags (seg, SEC_DATA))
+       as_warn (_("Error setting flags for \"%s\": %s"), name,

                 bfd_errmsg (bfd_get_error ()));
     }
 
                 bfd_errmsg (bfd_get_error ()));
     }
 

-  /* If the last character overwritten by get_symbol_end() was an
+  /* If the last character overwritten by get_symbol_name() was an

      end-of-line, we must restore it or the end of the line will not be
      recognised and scanning extends into the next line, stopping with
      an error (blame Volker Kuhlmann <v.kuhlmann@elec.canterbury.ac.nz>
      end-of-line, we must restore it or the end of the line will not be
      recognised and scanning extends into the next line, stopping with
      an error (blame Volker Kuhlmann <v.kuhlmann@elec.canterbury.ac.nz>


@@ -1154,9 +1020,8 @@ c4x_sect (x)
 }
 
 /* symbol[:] .set value  or  .set symbol, value */
 }
 
 /* symbol[:] .set value  or  .set symbol, value */

-static void 
-c4x_set (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_set (int x ATTRIBUTE_UNUSED)

 {
   symbolS *symbolP;
 
 {
   symbolS *symbolP;
 


@@ -1166,14 +1031,16 @@ c4x_set (x)
       char c;
       char *name;
 
       char c;
       char *name;
 

-      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 (".set syntax invalid\n");
+         as_bad (_(".set syntax invalid\n"));

          ignore_rest_of_line ();
          return;
        }
          ignore_rest_of_line ();
          return;
        }

+      ++input_line_pointer;

       symbolP = symbol_find_or_make (name);
     }
   else
       symbolP = symbol_find_or_make (name);
     }
   else


@@ -1184,15 +1051,14 @@ c4x_set (x)
 }
 
 /* [symbol] .usect ["]section-name["], size-in-words [, alignment-flag] */
 }
 
 /* [symbol] .usect ["]section-name["], size-in-words [, alignment-flag] */

-static void 
-c4x_usect (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_usect (int x ATTRIBUTE_UNUSED)

 {
   char c;
   char *name;
   char *section_name;
   segT seg;
 {
   char c;
   char *name;
   char *section_name;
   segT seg;

-  int size, alignment_flag;
+  offsetT size, alignment_flag;

   segT current_seg;
   subsegT current_subseg;
 
   segT current_seg;
   subsegT current_subseg;
 


@@ -1202,19 +1068,19 @@ c4x_usect (x)
   SKIP_WHITESPACE ();
   if (*input_line_pointer == '"')
     input_line_pointer++;
   SKIP_WHITESPACE ();
   if (*input_line_pointer == '"')
     input_line_pointer++;

-  section_name = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
+  c = get_symbol_name (&section_name); /* Get terminator.  */
+  if (c == '"')
+    c = * ++ input_line_pointer;

   input_line_pointer++;                /* Skip null symbol terminator.  */
   input_line_pointer++;                /* Skip null symbol terminator.  */

-  name = xmalloc (input_line_pointer - section_name + 1);
-  strcpy (name, section_name);
+  name = xstrdup (section_name);

 
   if (c == ',')
     input_line_pointer =
 
   if (c == ',')
     input_line_pointer =

-      c4x_expression_abs (input_line_pointer, &size);
+      tic4x_expression_abs (input_line_pointer, &size);

   else if (*input_line_pointer == ',')
     {
       input_line_pointer =
   else if (*input_line_pointer == ',')
     {
       input_line_pointer =

-       c4x_expression_abs (++input_line_pointer, &size);
+       tic4x_expression_abs (++input_line_pointer, &size);

     }
   else
     size = 0;
     }
   else
     size = 0;


@@ -1223,12 +1089,12 @@ c4x_usect (x)
   if (*input_line_pointer == ',')
     {
       input_line_pointer =
   if (*input_line_pointer == ',')
     {
       input_line_pointer =

-       c4x_expression_abs (++input_line_pointer, &alignment_flag);
+       tic4x_expression_abs (++input_line_pointer, &alignment_flag);

     }
   else
     alignment_flag = 0;
   if (alignment_flag)
     }
   else
     alignment_flag = 0;
   if (alignment_flag)

-    as_warn (".usect: non-zero alignment flag ignored");
+    as_warn (_(".usect: non-zero alignment flag ignored"));

 
   seg = subseg_new (name, 0);
   if (line_label != NULL)
 
   seg = subseg_new (name, 0);
   if (line_label != NULL)


@@ -1238,10 +1104,10 @@ c4x_usect (x)
       S_SET_VALUE (line_label, frag_now_fix ());
     }
   seg_info (seg)->bss = 1;     /* Uninitialised data.  */
       S_SET_VALUE (line_label, frag_now_fix ());
     }
   seg_info (seg)->bss = 1;     /* Uninitialised data.  */

-  if (!bfd_set_section_flags (stdoutput, seg, SEC_ALLOC))
-    as_warn ("Error setting flags for \"%s\": %s", name,
+  if (!bfd_set_section_flags (seg, SEC_ALLOC))
+    as_warn (_("Error setting flags for \"%s\": %s"), name,

             bfd_errmsg (bfd_get_error ()));
             bfd_errmsg (bfd_get_error ()));

-  c4x_seg_alloc (name, seg, size, line_label);
+  tic4x_seg_alloc (name, seg, size, line_label);

 
   if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
     S_SET_STORAGE_CLASS (line_label, C_STAT);
 
   if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
     S_SET_STORAGE_CLASS (line_label, C_STAT);


@@ -1251,44 +1117,43 @@ c4x_usect (x)
 }
 
 /* .version cpu-version.  */
 }
 
 /* .version cpu-version.  */

-static void 
-c4x_version (x)
-     int x ATTRIBUTE_UNUSED;
+static void
+tic4x_version (int x ATTRIBUTE_UNUSED)

 {
 {

-  unsigned int temp;
+  offsetT temp;

 
   input_line_pointer =
 
   input_line_pointer =

-    c4x_expression_abs (input_line_pointer, &temp);
-  if (!IS_CPU_C3X (temp) && !IS_CPU_C4X (temp))
-    as_bad ("This assembler does not support processor generation %d",
-           temp);
-
-  if (c4x_cpu && temp != c4x_cpu)
-    as_warn ("Changing processor generation on fly not supported...");
-  c4x_cpu = temp;
+    tic4x_expression_abs (input_line_pointer, &temp);
+  if (!IS_CPU_TIC3X (temp) && !IS_CPU_TIC4X (temp))
+    as_bad (_("This assembler does not support processor generation %ld"),
+           (long) temp);
+
+  if (tic4x_cpu && temp != (offsetT) tic4x_cpu)
+    as_warn (_("Changing processor generation on fly not supported..."));
+  tic4x_cpu = temp;

   demand_empty_rest_of_line ();
 }
 
   demand_empty_rest_of_line ();
 }
 

-static void 
-c4x_init_regtable ()
+static void
+tic4x_init_regtable (void)

 {
   unsigned int i;
 
 {
   unsigned int i;
 

-  for (i = 0; i < c3x_num_registers; i++)
-    c4x_insert_reg (c3x_registers[i].name,
-                   c3x_registers[i].regno);
+  for (i = 0; i < tic3x_num_registers; i++)
+    tic4x_insert_reg (tic3x_registers[i].name,
+                   tic3x_registers[i].regno);

 
 

-  if (IS_CPU_C4X (c4x_cpu))
+  if (IS_CPU_TIC4X (tic4x_cpu))

     {
     {

-      /* Add additional C4x registers, overriding some C3x ones.  */
-      for (i = 0; i < c4x_num_registers; i++)
-       c4x_insert_reg (c4x_registers[i].name,
-                       c4x_registers[i].regno);
+      /* Add additional Tic4x registers, overriding some C3x ones.  */
+      for (i = 0; i < tic4x_num_registers; i++)
+       tic4x_insert_reg (tic4x_registers[i].name,
+                       tic4x_registers[i].regno);

     }
 }
 
     }
 }
 

-static void 
-c4x_init_symbols ()
+static void
+tic4x_init_symbols (void)

 {
   /* The TI tools accept case insensitive versions of these symbols,
      we don't !
 {
   /* The TI tools accept case insensitive versions of these symbols,
      we don't !


@@ -1317,36 +1182,35 @@ c4x_init_symbols ()
 
      Source: TI: TMS320C3x/C4x Assembly Language Tools User's Guide,
      1997, SPRU035C, p. 3-17/3-18.  */
 
      Source: TI: TMS320C3x/C4x Assembly Language Tools User's Guide,
      1997, SPRU035C, p. 3-17/3-18.  */

-  c4x_insert_sym (".REGPARM", c4x_reg_args);
-  c4x_insert_sym (".MEMPARM", !c4x_reg_args);  
-  c4x_insert_sym (".BIGMODEL", c4x_big_model);
-  c4x_insert_sym (".C30INTERRUPT", 0);
-  c4x_insert_sym (".TMS320xx", c4x_cpu == 0 ? 40 : c4x_cpu);
-  c4x_insert_sym (".C3X", c4x_cpu == 30 || c4x_cpu == 31 || c4x_cpu == 32 || c4x_cpu == 33);
-  c4x_insert_sym (".C3x", c4x_cpu == 30 || c4x_cpu == 31 || c4x_cpu == 32 || c4x_cpu == 33);
-  c4x_insert_sym (".C4X", c4x_cpu == 0 || c4x_cpu == 40 || c4x_cpu == 44);
-  c4x_insert_sym (".C4x", c4x_cpu == 0 || c4x_cpu == 40 || c4x_cpu == 44);
+  tic4x_insert_sym (".REGPARM", tic4x_reg_args);
+  tic4x_insert_sym (".MEMPARM", !tic4x_reg_args);
+  tic4x_insert_sym (".BIGMODEL", tic4x_big_model);
+  tic4x_insert_sym (".C30INTERRUPT", 0);
+  tic4x_insert_sym (".TMS320xx", tic4x_cpu == 0 ? 40 : tic4x_cpu);
+  tic4x_insert_sym (".C3X", tic4x_cpu == 30 || tic4x_cpu == 31 || tic4x_cpu == 32 || tic4x_cpu == 33);
+  tic4x_insert_sym (".C3x", tic4x_cpu == 30 || tic4x_cpu == 31 || tic4x_cpu == 32 || tic4x_cpu == 33);
+  tic4x_insert_sym (".C4X", tic4x_cpu == 0 || tic4x_cpu == 40 || tic4x_cpu == 44);
+  tic4x_insert_sym (".C4x", tic4x_cpu == 0 || tic4x_cpu == 40 || tic4x_cpu == 44);

   /* Do we need to have the following symbols also in lower case?  */
   /* Do we need to have the following symbols also in lower case?  */

-  c4x_insert_sym (".TMS320C30", c4x_cpu == 30 || c4x_cpu == 31 || c4x_cpu == 32 || c4x_cpu == 33);
-  c4x_insert_sym (".tms320C30", c4x_cpu == 30 || c4x_cpu == 31 || c4x_cpu == 32 || c4x_cpu == 33);
-  c4x_insert_sym (".TMS320C31", c4x_cpu == 31);
-  c4x_insert_sym (".tms320C31", c4x_cpu == 31);
-  c4x_insert_sym (".TMS320C32", c4x_cpu == 32);
-  c4x_insert_sym (".tms320C32", c4x_cpu == 32);
-  c4x_insert_sym (".TMS320C33", c4x_cpu == 33);
-  c4x_insert_sym (".tms320C33", c4x_cpu == 33);
-  c4x_insert_sym (".TMS320C40", c4x_cpu == 40 || c4x_cpu == 44 || c4x_cpu == 0);
-  c4x_insert_sym (".tms320C40", c4x_cpu == 40 || c4x_cpu == 44 || c4x_cpu == 0);
-  c4x_insert_sym (".TMS320C44", c4x_cpu == 44);
-  c4x_insert_sym (".tms320C44", c4x_cpu == 44);
-  c4x_insert_sym (".TMX320C40", 0);    /* C40 first pass silicon ?  */
-  c4x_insert_sym (".tmx320C40", 0);
+  tic4x_insert_sym (".TMS320C30", tic4x_cpu == 30 || tic4x_cpu == 31 || tic4x_cpu == 32 || tic4x_cpu == 33);
+  tic4x_insert_sym (".tms320C30", tic4x_cpu == 30 || tic4x_cpu == 31 || tic4x_cpu == 32 || tic4x_cpu == 33);
+  tic4x_insert_sym (".TMS320C31", tic4x_cpu == 31);
+  tic4x_insert_sym (".tms320C31", tic4x_cpu == 31);
+  tic4x_insert_sym (".TMS320C32", tic4x_cpu == 32);
+  tic4x_insert_sym (".tms320C32", tic4x_cpu == 32);
+  tic4x_insert_sym (".TMS320C33", tic4x_cpu == 33);
+  tic4x_insert_sym (".tms320C33", tic4x_cpu == 33);
+  tic4x_insert_sym (".TMS320C40", tic4x_cpu == 40 || tic4x_cpu == 44 || tic4x_cpu == 0);
+  tic4x_insert_sym (".tms320C40", tic4x_cpu == 40 || tic4x_cpu == 44 || tic4x_cpu == 0);
+  tic4x_insert_sym (".TMS320C44", tic4x_cpu == 44);
+  tic4x_insert_sym (".tms320C44", tic4x_cpu == 44);
+  tic4x_insert_sym (".TMX320C40", 0);  /* C40 first pass silicon ?  */
+  tic4x_insert_sym (".tmx320C40", 0);

 }
 
 /* Insert a new instruction template into hash table.  */
 }
 
 /* Insert a new instruction template into hash table.  */

-static int 
-c4x_inst_insert (inst)
-     c4x_inst_t *inst;
+static int
+tic4x_inst_insert (const tic4x_inst_t *inst)

 {
   static char prev_name[16];
   const char *retval = NULL;
 {
   static char prev_name[16];
   const char *retval = NULL;


@@ -1355,7 +1219,7 @@ c4x_inst_insert (inst)
   if (!strcmp (inst->name, prev_name) || inst->name[0] == '\0')
     return 1;
 
   if (!strcmp (inst->name, prev_name) || inst->name[0] == '\0')
     return 1;
 

-  retval = hash_insert (c4x_op_hash, inst->name, (PTR) inst);
+  retval = hash_insert (tic4x_op_hash, inst->name, (void *) inst);

   if (retval != NULL)
     fprintf (stderr, "internal error: can't hash `%s': %s\n",
             inst->name, retval);
   if (retval != NULL)
     fprintf (stderr, "internal error: can't hash `%s': %s\n",
             inst->name, retval);


@@ -1365,44 +1229,39 @@ c4x_inst_insert (inst)
 }
 
 /* Make a new instruction template.  */
 }
 
 /* Make a new instruction template.  */

-static c4x_inst_t *
-c4x_inst_make (name, opcode, args)
-     char *name;
-     unsigned long opcode;
-     char *args;
+static tic4x_inst_t *
+tic4x_inst_make (const char *name, unsigned long opcode, const char *args)

 {
 {

-  static c4x_inst_t *insts = NULL;
+  static tic4x_inst_t *insts = NULL;

   static char *names = NULL;
   static char *names = NULL;

-  static int index = 0;
+  static int iindex = 0;

 
   if (insts == NULL)
     {
       /* Allocate memory to store name strings.  */
 
   if (insts == NULL)
     {
       /* Allocate memory to store name strings.  */

-      names = (char *) xmalloc (sizeof (char) * 8192);
+      names = XNEWVEC (char, 8192);

       /* Allocate memory for additional insts.  */
       /* Allocate memory for additional insts.  */

-      insts = (c4x_inst_t *)
-       xmalloc (sizeof (c4x_inst_t) * 1024);
+      insts = XNEWVEC (tic4x_inst_t, 1024);

     }
     }

-  insts[index].name = names;
-  insts[index].opcode = opcode;
-  insts[index].opmask = 0xffffffff;
-  insts[index].args = args;
-  index++;
+  insts[iindex].name = names;
+  insts[iindex].opcode = opcode;
+  insts[iindex].opmask = 0xffffffff;
+  insts[iindex].args = args;
+  iindex++;

 
   do
     *names++ = *name++;
   while (*name);
   *names++ = '\0';
 
 
   do
     *names++ = *name++;
   while (*name);
   *names++ = '\0';
 

-  return &insts[index - 1];
+  return &insts[iindex - 1];

 }
 
 /* Add instruction template, creating dynamic templates as required.  */
 }
 
 /* Add instruction template, creating dynamic templates as required.  */

-static int 
-c4x_inst_add (insts)
-     c4x_inst_t *insts;
+static int
+tic4x_inst_add (const tic4x_inst_t *insts)

 {
 {

-  char *s = insts->name;
+  const char *s = insts->name;

   char *d;
   unsigned int i;
   int ok = 1;
   char *d;
   unsigned int i;
   int ok = 1;


@@ -1411,8 +1270,8 @@ c4x_inst_add (insts)
   d = name;
 
   /* We do not care about INSNs that is not a part of our
   d = name;
 
   /* We do not care about INSNs that is not a part of our

-     oplevel setting */
-  if (!insts->oplevel & c4x_oplevel)
+     oplevel setting.  */
+  if ((insts->oplevel & tic4x_oplevel) == 0)

     return ok;
 
   while (1)
     return ok;
 
   while (1)


@@ -1422,11 +1281,11 @@ c4x_inst_add (insts)
        case 'B':
        case 'C':
          /* Dynamically create all the conditional insts.  */
        case 'B':
        case 'C':
          /* Dynamically create all the conditional insts.  */

-         for (i = 0; i < num_conds; i++)
+         for (i = 0; i < tic4x_num_conds; i++)

            {
            {

-             c4x_inst_t *inst;
+             tic4x_inst_t *inst;

              int k = 0;
              int k = 0;

-             char *c = c4x_conds[i].name;
+             const char *c = tic4x_conds[i].name;

              char *e = d;
 
              while (*c)
              char *e = d;
 
              while (*c)


@@ -1437,17 +1296,17 @@ c4x_inst_add (insts)
              *e = '\0';
 
              /* If instruction found then have already processed it.  */
              *e = '\0';
 
              /* If instruction found then have already processed it.  */

-             if (hash_find (c4x_op_hash, name))
+             if (hash_find (tic4x_op_hash, name))

                return 1;
 
              do
                {
                return 1;
 
              do
                {

-                 inst = c4x_inst_make (name, insts[k].opcode +
-                                       (c4x_conds[i].cond <<
+                 inst = tic4x_inst_make (name, insts[k].opcode +
+                                       (tic4x_conds[i].cond <<

                                         (*s == 'B' ? 16 : 23)),
                                        insts[k].args);
                  if (k == 0)   /* Save strcmp() with following func.  */
                                         (*s == 'B' ? 16 : 23)),
                                        insts[k].args);
                  if (k == 0)   /* Save strcmp() with following func.  */

-                   ok &= c4x_inst_insert (inst);
+                   ok &= tic4x_inst_insert (inst);

                  k++;
                }
              while (!strcmp (insts->name,
                  k++;
                }
              while (!strcmp (insts->name,


@@ -1457,7 +1316,7 @@ c4x_inst_add (insts)
          break;
 
        case '\0':
          break;
 
        case '\0':

-         return c4x_inst_insert (insts);
+         return tic4x_inst_insert (insts);

          break;
 
        default:
          break;
 
        default:


@@ -1470,76 +1329,75 @@ c4x_inst_add (insts)
 /* This function is called once, at assembler startup time.  It should
    set up all the tables, etc., that the MD part of the assembler will
    need.  */
 /* This function is called once, at assembler startup time.  It should
    set up all the tables, etc., that the MD part of the assembler will
    need.  */

-void 
-md_begin ()
+void
+md_begin (void)

 {
   int ok = 1;
   unsigned int i;
 
   /* Setup the proper opcode level according to the
      commandline parameters */
 {
   int ok = 1;
   unsigned int i;
 
   /* Setup the proper opcode level according to the
      commandline parameters */

-  c4x_oplevel = OP_C3X;
-
-  if ( IS_CPU_C4X(c4x_cpu) )
-    c4x_oplevel |= OP_C4X;
-
-  if ( (   c4x_cpu == 31 && c4x_revision >= 6)
-       || (c4x_cpu == 32 && c4x_revision >= 2)
-       || (c4x_cpu == 33)
-       || c4x_enhanced )
-    c4x_oplevel |= OP_ENH;
-
-  if ( (   c4x_cpu == 30 && c4x_revision >= 7)
-       || (c4x_cpu == 31 && c4x_revision >= 5)
-       || (c4x_cpu == 32)
-       || c4x_lowpower )
-    c4x_oplevel |= OP_LPWR;
-
-  if ( (   c4x_cpu == 30 && c4x_revision >= 7)
-       || (c4x_cpu == 31 && c4x_revision >= 5)
-       || (c4x_cpu == 32)
-       || (c4x_cpu == 33)
-       || (c4x_cpu == 40 && c4x_revision >= 5)
-       || (c4x_cpu == 44)
-       || c4x_idle2 )
-    c4x_oplevel |= OP_IDLE2;
+  tic4x_oplevel = OP_C3X;
+
+  if ( IS_CPU_TIC4X(tic4x_cpu) )
+    tic4x_oplevel |= OP_C4X;
+
+  if ( (   tic4x_cpu == 31 && tic4x_revision >= 6)
+       || (tic4x_cpu == 32 && tic4x_revision >= 2)
+       || (tic4x_cpu == 33)
+       || tic4x_enhanced )
+    tic4x_oplevel |= OP_ENH;
+
+  if ( (   tic4x_cpu == 30 && tic4x_revision >= 7)
+       || (tic4x_cpu == 31 && tic4x_revision >= 5)
+       || (tic4x_cpu == 32)
+       || tic4x_lowpower )
+    tic4x_oplevel |= OP_LPWR;
+
+  if ( (   tic4x_cpu == 30 && tic4x_revision >= 7)
+       || (tic4x_cpu == 31 && tic4x_revision >= 5)
+       || (tic4x_cpu == 32)
+       || (tic4x_cpu == 33)
+       || (tic4x_cpu == 40 && tic4x_revision >= 5)
+       || (tic4x_cpu == 44)
+       || tic4x_idle2 )
+    tic4x_oplevel |= OP_IDLE2;

 
   /* Create hash table for mnemonics.  */
 
   /* Create hash table for mnemonics.  */

-  c4x_op_hash = hash_new ();
+  tic4x_op_hash = hash_new ();

 
   /* Create hash table for asg pseudo.  */
 
   /* Create hash table for asg pseudo.  */

-  c4x_asg_hash = hash_new ();
+  tic4x_asg_hash = hash_new ();

 
   /* Add mnemonics to hash table, expanding conditional mnemonics on fly.  */
 
   /* Add mnemonics to hash table, expanding conditional mnemonics on fly.  */

-  for (i = 0; i < c4x_num_insts; i++)
-    ok &= c4x_inst_add ((void *) &c4x_insts[i]);
+  for (i = 0; i < tic4x_num_insts; i++)
+    ok &= tic4x_inst_add (tic4x_insts + i);

 
   /* Create dummy inst to avoid errors accessing end of table.  */
 
   /* Create dummy inst to avoid errors accessing end of table.  */

-  c4x_inst_make ("", 0, "");
+  tic4x_inst_make ("", 0, "");

 
   if (!ok)
     as_fatal ("Broken assembler.  No assembly attempted.");
 
   /* Add registers to symbol table.  */
 
   if (!ok)
     as_fatal ("Broken assembler.  No assembly attempted.");
 
   /* Add registers to symbol table.  */

-  c4x_init_regtable ();
+  tic4x_init_regtable ();

 
   /* Add predefined symbols to symbol table.  */
 
   /* Add predefined symbols to symbol table.  */

-  c4x_init_symbols ();
+  tic4x_init_symbols ();

 }
 
 }
 

-void 
-c4x_end ()
+void
+tic4x_end (void)

 {
 {

-  bfd_set_arch_mach (stdoutput, bfd_arch_tic4x, 
-                    IS_CPU_C4X (c4x_cpu) ? bfd_mach_c4x : bfd_mach_c3x);
+  bfd_set_arch_mach (stdoutput, bfd_arch_tic4x,
+                    IS_CPU_TIC4X (tic4x_cpu) ? bfd_mach_tic4x : bfd_mach_tic3x);

 }
 
 }
 

-static int 
-c4x_indirect_parse (operand, indirect)
-     c4x_operand_t *operand;
-     const c4x_indirect_t *indirect;
+static int
+tic4x_indirect_parse (tic4x_operand_t *operand,
+                     const tic4x_indirect_t *indirect)

 {
 {

-  char *n = indirect->name;
+  const char *n = indirect->name;

   char *s = input_line_pointer;
   char *b;
   symbolS *symbolP;
   char *s = input_line_pointer;
   char *b;
   symbolS *symbolP;


@@ -1552,11 +1410,11 @@ c4x_indirect_parse (operand, indirect)
        {
        case 'a':               /* Need to match aux register.  */
          b = name;
        {
        case 'a':               /* Need to match aux register.  */
          b = name;

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

          if (*s == '%')
            s++;
 #endif
          if (*s == '%')
            s++;
 #endif

-         while (isalnum (*s))
+         while (ISALNUM (*s))

            *b++ = *s++;
          *b++ = '\0';
          if (!(symbolP = symbol_find (name)))
            *b++ = *s++;
          *b++ = '\0';
          if (!(symbolP = symbol_find (name)))


@@ -1569,21 +1427,21 @@ c4x_indirect_parse (operand, indirect)
          if (operand->aregno >= REG_AR0 && operand->aregno <= REG_AR7)
            break;
 
          if (operand->aregno >= REG_AR0 && operand->aregno <= REG_AR7)
            break;
 

-         as_bad ("Auxiliary register AR0--AR7 required for indirect");
+         as_bad (_("Auxiliary register AR0--AR7 required for indirect"));

          return -1;
 
        case 'd':               /* Need to match constant for disp.  */
          return -1;
 
        case 'd':               /* Need to match constant for disp.  */

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

          if (*s == '%')        /* expr() will die if we don't skip this.  */
            s++;
 #endif
          if (*s == '%')        /* expr() will die if we don't skip this.  */
            s++;
 #endif

-         s = c4x_expression (s, &operand->expr);
+         s = tic4x_expression (s, &operand->expr);

          if (operand->expr.X_op != O_constant)
            return 0;
          operand->disp = operand->expr.X_add_number;
          if (operand->disp < 0 || operand->disp > 255)
            {
          if (operand->expr.X_op != O_constant)
            return 0;
          operand->disp = operand->expr.X_add_number;
          if (operand->disp < 0 || operand->disp > 255)
            {

-             as_bad ("Bad displacement %d (require 0--255)\n",
+             as_bad (_("Bad displacement %d (require 0--255)\n"),

                      operand->disp);
              return -1;
            }
                      operand->disp);
              return -1;
            }


@@ -1591,17 +1449,17 @@ c4x_indirect_parse (operand, indirect)
 
        case 'y':               /* Need to match IR0.  */
        case 'z':               /* Need to match IR1.  */
 
        case 'y':               /* Need to match IR0.  */
        case 'z':               /* Need to match IR1.  */

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

          if (*s == '%')
            s++;
 #endif
          if (*s == '%')
            s++;
 #endif

-         s = c4x_expression (s, &operand->expr);
+         s = tic4x_expression (s, &operand->expr);

          if (operand->expr.X_op != O_register)
            return 0;
          if (operand->expr.X_add_number != REG_IR0
              && operand->expr.X_add_number != REG_IR1)
            {
          if (operand->expr.X_op != O_register)
            return 0;
          if (operand->expr.X_add_number != REG_IR0
              && operand->expr.X_add_number != REG_IR1)
            {

-             as_bad ("Index register IR0,IR1 required for displacement");
+             as_bad (_("Index register IR0,IR1 required for displacement"));

              return -1;
            }
 
              return -1;
            }
 


@@ -1623,7 +1481,7 @@ c4x_indirect_parse (operand, indirect)
          break;
 
        default:
          break;
 
        default:

-         if (tolower (*s) != *n)
+         if (TOLOWER (*s) != *n)

            return 0;
          s++;
        }
            return 0;
          s++;
        }


@@ -1635,9 +1493,7 @@ c4x_indirect_parse (operand, indirect)
 }
 
 static char *
 }
 
 static char *

-c4x_operand_parse (s, operand)
-     char *s;
-     c4x_operand_t *operand;
+tic4x_operand_parse (char *s, tic4x_operand_t *operand)

 {
   unsigned int i;
   char c;
 {
   unsigned int i;
   char c;


@@ -1645,49 +1501,48 @@ c4x_operand_parse (s, operand)
   expressionS *exp = &operand->expr;
   char *save = input_line_pointer;
   char *str;
   expressionS *exp = &operand->expr;
   char *save = input_line_pointer;
   char *str;

-  char *new;
+  char *new_pointer;

   struct hash_entry *entry = NULL;
 
   input_line_pointer = s;
   SKIP_WHITESPACE ();
 
   struct hash_entry *entry = NULL;
 
   input_line_pointer = s;
   SKIP_WHITESPACE ();
 

-  str = input_line_pointer;
-  c = get_symbol_end ();       /* Get terminator.  */
-  new = input_line_pointer;
-  if (strlen (str) && (entry = hash_find (c4x_asg_hash, str)) != NULL)
+  c = get_symbol_name (&str);  /* Get terminator.  */
+  new_pointer = input_line_pointer;
+  if (strlen (str) && (entry = hash_find (tic4x_asg_hash, str)) != NULL)

     {
     {

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

       input_line_pointer = (char *) entry;
     }
   else
     {
       input_line_pointer = (char *) entry;
     }
   else
     {

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

       input_line_pointer = str;
     }
 
   operand->mode = M_UNKNOWN;
   switch (*input_line_pointer)
     {
       input_line_pointer = str;
     }
 
   operand->mode = M_UNKNOWN;
   switch (*input_line_pointer)
     {

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

     case '%':
     case '%':

-      input_line_pointer = c4x_expression (++input_line_pointer, exp);
+      input_line_pointer = tic4x_expression (++input_line_pointer, exp);

       if (exp->X_op != O_register)
       if (exp->X_op != O_register)

-       as_bad ("Expecting a register name");
+       as_bad (_("Expecting a register name"));

       operand->mode = M_REGISTER;
       break;
 
     case '^':
       /* Denotes high 16 bits.  */
       operand->mode = M_REGISTER;
       break;
 
     case '^':
       /* Denotes high 16 bits.  */

-      input_line_pointer = c4x_expression (++input_line_pointer, exp);
+      input_line_pointer = tic4x_expression (++input_line_pointer, exp);

       if (exp->X_op == O_constant)
        operand->mode = M_IMMED;
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number)
       if (exp->X_op == O_constant)
        operand->mode = M_IMMED;
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number)

-           as_bad ("Number too large");        /* bignum required */
+           as_bad (_("Number too large"));     /* bignum required */

          else
            {
          else
            {

-             c4x_gen_to_words (generic_floating_point_number,
+             tic4x_gen_to_words (generic_floating_point_number,

                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }
                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }


@@ -1695,22 +1550,22 @@ c4x_operand_parse (s, operand)
       /* Allow ori ^foo, ar0 to be equivalent to ldi .hi.foo, ar0  */
       /* WARNING : The TI C40 assembler cannot do this.  */
       else if (exp->X_op == O_symbol)
       /* Allow ori ^foo, ar0 to be equivalent to ldi .hi.foo, ar0  */
       /* WARNING : The TI C40 assembler cannot do this.  */
       else if (exp->X_op == O_symbol)

-       {
-         operand->mode = M_HI;
-         break;
-       }
+       operand->mode = M_HI;
+      else
+       as_bad (_("Expecting a constant value"));
+      break;

 
     case '#':
 
     case '#':

-      input_line_pointer = c4x_expression (++input_line_pointer, exp);
+      input_line_pointer = tic4x_expression (++input_line_pointer, exp);

       if (exp->X_op == O_constant)
        operand->mode = M_IMMED;
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number > 0)
       if (exp->X_op == O_constant)
        operand->mode = M_IMMED;
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number > 0)

-           as_bad ("Number too large");        /* bignum required.  */
+           as_bad (_("Number too large"));     /* bignum required.  */

          else
            {
          else
            {

-             c4x_gen_to_words (generic_floating_point_number,
+             tic4x_gen_to_words (generic_floating_point_number,

                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }
                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }


@@ -1718,24 +1573,21 @@ c4x_operand_parse (s, operand)
       /* Allow ori foo, ar0 to be equivalent to ldi .lo.foo, ar0  */
       /* WARNING : The TI C40 assembler cannot do this.  */
       else if (exp->X_op == O_symbol)
       /* Allow ori foo, ar0 to be equivalent to ldi .lo.foo, ar0  */
       /* WARNING : The TI C40 assembler cannot do this.  */
       else if (exp->X_op == O_symbol)

-       {
-         operand->mode = M_IMMED;
-         break;
-       }
-
+       operand->mode = M_IMMED;

       else
       else

-       as_bad ("Expecting a constant value");
+       as_bad (_("Expecting a constant value"));

       break;
       break;

+

     case '\\':
 #endif
     case '@':
     case '\\':
 #endif
     case '@':

-      input_line_pointer = c4x_expression (++input_line_pointer, exp);
+      input_line_pointer = tic4x_expression (++input_line_pointer, exp);

       if (exp->X_op != O_constant && exp->X_op != O_symbol)
       if (exp->X_op != O_constant && exp->X_op != O_symbol)

-       as_bad ("Bad direct addressing construct %s", s);
+       as_bad (_("Bad direct addressing construct %s"), s);

       if (exp->X_op == O_constant)
        {
          if (exp->X_add_number < 0)
       if (exp->X_op == O_constant)
        {
          if (exp->X_add_number < 0)

-           as_bad ("Direct value of %ld is not suitable",
+           as_bad (_("Direct value of %ld is not suitable"),

                    (long) exp->X_add_number);
        }
       operand->mode = M_DIRECT;
                    (long) exp->X_add_number);
        }
       operand->mode = M_DIRECT;


@@ -1743,29 +1595,29 @@ c4x_operand_parse (s, operand)
 
     case '*':
       ret = -1;
 
     case '*':
       ret = -1;

-      for (i = 0; i < c4x_num_indirects; i++)
-       if ((ret = c4x_indirect_parse (operand, &c4x_indirects[i])))
+      for (i = 0; i < tic4x_num_indirects; i++)
+       if ((ret = tic4x_indirect_parse (operand, &tic4x_indirects[i])))

          break;
       if (ret < 0)
        break;
          break;
       if (ret < 0)
        break;

-      if (i < c4x_num_indirects)
+      if (i < tic4x_num_indirects)

        {
          operand->mode = M_INDIRECT;
          /* Indirect addressing mode number.  */
        {
          operand->mode = M_INDIRECT;
          /* Indirect addressing mode number.  */

-         operand->expr.X_add_number = c4x_indirects[i].modn;
+         operand->expr.X_add_number = tic4x_indirects[i].modn;

          /* Convert *+ARn(0) to *ARn etc.  Maybe we should
             squeal about silly ones?  */
          if (operand->expr.X_add_number < 0x08 && !operand->disp)
            operand->expr.X_add_number = 0x18;
        }
       else
          /* Convert *+ARn(0) to *ARn etc.  Maybe we should
             squeal about silly ones?  */
          if (operand->expr.X_add_number < 0x08 && !operand->disp)
            operand->expr.X_add_number = 0x18;
        }
       else

-       as_bad ("Unknown indirect addressing mode");
+       as_bad (_("Unknown indirect addressing mode"));

       break;
 
     default:
       operand->mode = M_IMMED; /* Assume immediate.  */
       str = input_line_pointer;
       break;
 
     default:
       operand->mode = M_IMMED; /* Assume immediate.  */
       str = input_line_pointer;

-      input_line_pointer = c4x_expression (input_line_pointer, exp);
+      input_line_pointer = tic4x_expression (input_line_pointer, exp);

       if (exp->X_op == O_register)
        {
          know (exp->X_add_symbol == 0);
       if (exp->X_op == O_register)
        {
          know (exp->X_add_symbol == 0);


@@ -1776,16 +1628,16 @@ c4x_operand_parse (s, operand)
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number > 0)
       else if (exp->X_op == O_big)
        {
          if (exp->X_add_number > 0)

-           as_bad ("Number too large");        /* bignum required.  */
+           as_bad (_("Number too large"));     /* bignum required.  */

          else
            {
          else
            {

-             c4x_gen_to_words (generic_floating_point_number,
+             tic4x_gen_to_words (generic_floating_point_number,

                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }
          break;
        }
                                operand->fwords, S_PRECISION);
              operand->mode = M_IMMED_F;
            }
          break;
        }

-#ifdef C4X_ALT_SYNTAX
+#ifdef TIC4X_ALT_SYNTAX

       /* Allow ldi foo, ar0 to be equivalent to ldi @foo, ar0.  */
       else if (exp->X_op == O_symbol)
        {
       /* Allow ldi foo, ar0 to be equivalent to ldi @foo, ar0.  */
       else if (exp->X_op == O_symbol)
        {


@@ -1795,21 +1647,18 @@ c4x_operand_parse (s, operand)
 #endif
     }
   if (entry == NULL)
 #endif
     }
   if (entry == NULL)

-    new = input_line_pointer;
+    new_pointer = input_line_pointer;

   input_line_pointer = save;
   input_line_pointer = save;

-  return new;
+  return new_pointer;

 }
 
 }
 

-static int 
-c4x_operands_match (inst, insn, check)
-     c4x_inst_t *inst;
-     c4x_insn_t *insn;
-     int check;
+static int
+tic4x_operands_match (tic4x_inst_t *inst, tic4x_insn_t *tinsn, int check)

 {
   const char *args = inst->args;
   unsigned long opcode = inst->opcode;
 {
   const char *args = inst->args;
   unsigned long opcode = inst->opcode;

-  int num_operands = insn->num_operands;
-  c4x_operand_t *operand = insn->operands;
+  int num_operands = tinsn->num_operands;
+  tic4x_operand_t *operand = tinsn->operands;

   expressionS *exp = &operand->expr;
   int ret = 1;
   int reg;
   expressionS *exp = &operand->expr;
   int ret = 1;
   int reg;


@@ -1820,13 +1669,13 @@ c4x_operands_match (inst, insn, check)
      If an operand matches, we modify insn or opcode appropriately,
      and do a "continue".  If an operand fails to match, we "break".  */
 
      If an operand matches, we modify insn or opcode appropriately,
      and do a "continue".  If an operand fails to match, we "break".  */
 

-  insn->nchars = 4;            /* Instructions always 4 bytes.  */
-  insn->reloc = NO_RELOC;
-  insn->pcrel = 0;
+  tinsn->nchars = 4;           /* Instructions always 4 bytes.  */
+  tinsn->reloc = NO_RELOC;
+  tinsn->pcrel = 0;

 
   if (*args == '\0')
     {
 
   if (*args == '\0')
     {

-      insn->opcode = opcode;
+      tinsn->opcode = opcode;

       return num_operands == 0;
     }
 
       return num_operands == 0;
     }
 


@@ -1838,7 +1687,7 @@ c4x_operands_match (inst, insn, check)
        case '\0':              /* End of args.  */
          if (num_operands == 1)
            {
        case '\0':              /* End of args.  */
          if (num_operands == 1)
            {

-             insn->opcode = opcode;
+             tinsn->opcode = opcode;

              return ret;
            }
          break;                /* Too many operands.  */
              return ret;
            }
          break;                /* Too many operands.  */


@@ -1850,8 +1699,8 @@ c4x_operands_match (inst, insn, check)
             use an immediate mode form of ldiu or ldpk instruction.  */
          if (exp->X_op == O_constant)
            {
             use an immediate mode form of ldiu or ldpk instruction.  */
          if (exp->X_op == O_constant)
            {

-              if( ( IS_CPU_C4X (c4x_cpu) && exp->X_add_number <= 65535 )
-                  || ( IS_CPU_C3X (c4x_cpu) && exp->X_add_number <= 255 ) )
+              if( ( IS_CPU_TIC4X (tic4x_cpu) && exp->X_add_number <= 65535 )
+                  || ( IS_CPU_TIC3X (tic4x_cpu) && exp->X_add_number <= 255 ) )

                 {
                   INSERTS (opcode, exp->X_add_number, 15, 0);
                   continue;
                 {
                   INSERTS (opcode, exp->X_add_number, 15, 0);
                   continue;


@@ -1859,7 +1708,7 @@ c4x_operands_match (inst, insn, check)
               else
                 {
                  if (!check)
               else
                 {
                  if (!check)

-                    as_bad ("Immediate value of %ld is too large for ldf",
+                    as_bad (_("Immediate value of %ld is too large for ldf"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;


@@ -1867,8 +1716,8 @@ c4x_operands_match (inst, insn, check)
            }
          else if (exp->X_op == O_symbol)
            {
            }
          else if (exp->X_op == O_symbol)
            {

-             insn->reloc = BFD_RELOC_HI16;
-             insn->exp = *exp;
+             tinsn->reloc = BFD_RELOC_HI16;
+             tinsn->exp = *exp;

              continue;
            }
          break;                /* Not direct (dp) addressing.  */
              continue;
            }
          break;                /* Not direct (dp) addressing.  */


@@ -1877,26 +1726,15 @@ c4x_operands_match (inst, insn, check)
          if (operand->mode != M_DIRECT)
            break;
          if (exp->X_op == O_constant)
          if (operand->mode != M_DIRECT)
            break;
          if (exp->X_op == O_constant)

-           {
-              if(exp->X_add_number <= 65535)
-                {
-                  /* Store only the 16 LSBs of the number.  */
-                  INSERTS (opcode, exp->X_add_number, 15, 0);
-                  continue;
-                }
-              else
-                {
-                 if (!check)
-                    as_bad ("Direct value of %ld is too large",
-                            (long) exp->X_add_number);
-                 ret = -1;
-                 continue;
-                }
+            {
+              /* Store only the 16 LSBs of the number.  */
+              INSERTS (opcode, exp->X_add_number, 15, 0);
+              continue;

            }
          else if (exp->X_op == O_symbol)
            {
            }
          else if (exp->X_op == O_symbol)
            {

-             insn->reloc = BFD_RELOC_LO16;
-             insn->exp = *exp;
+             tinsn->reloc = BFD_RELOC_LO16;
+             tinsn->exp = *exp;

              continue;
            }
          break;                /* Not direct addressing.  */
              continue;
            }
          break;                /* Not direct addressing.  */


@@ -1910,7 +1748,7 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Destination register must be ARn");
+                as_bad (_("Destination register must be ARn"));

              ret = -1;
            }
          continue;
              ret = -1;
            }
          continue;


@@ -1929,27 +1767,27 @@ c4x_operands_match (inst, insn, check)
              else
                {
                  if (!check)
              else
                {
                  if (!check)

-                    as_bad ("Immediate value of %ld is too large",
+                    as_bad (_("Immediate value of %ld is too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }

-         if (IS_CPU_C4X (c4x_cpu))
+         if (IS_CPU_TIC4X (tic4x_cpu))

            {
            {

-             insn->reloc = BFD_RELOC_24_PCREL;
-             insn->pcrel = 1;
+             tinsn->reloc = BFD_RELOC_24_PCREL;
+             tinsn->pcrel = 1;

            }
          else
            {
            }
          else
            {

-             insn->reloc = BFD_RELOC_24;
-             insn->pcrel = 0;
+             tinsn->reloc = BFD_RELOC_24;
+             tinsn->pcrel = 0;

            }
            }

-         insn->exp = *exp;
+         tinsn->exp = *exp;

          continue;
 
        case 'C':
          continue;
 
        case 'C':

-         if (!IS_CPU_C4X (c4x_cpu))
+         if (!IS_CPU_TIC4X (tic4x_cpu))

            break;
          if (operand->mode != M_INDIRECT)
            break;
            break;
          if (operand->mode != M_INDIRECT)
            break;


@@ -1958,7 +1796,7 @@ c4x_operands_match (inst, insn, check)
              && operand->expr.X_add_number != 0x18)
            {
               if (!check)
              && operand->expr.X_add_number != 0x18)
            {
               if (!check)

-                as_bad ("Invalid indirect addressing mode");
+                as_bad (_("Invalid indirect addressing mode"));

               ret = -1;
              continue;
            }
               ret = -1;
              continue;
            }


@@ -1976,13 +1814,13 @@ c4x_operands_match (inst, insn, check)
           if (!(operand->mode == M_REGISTER))
             break;
          reg = exp->X_add_number;
           if (!(operand->mode == M_REGISTER))
             break;
          reg = exp->X_add_number;

-         if ( (reg >= REG_R0 && reg <= REG_R7) 
-               || (IS_CPU_C4X (c4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )
+         if ( (reg >= REG_R0 && reg <= REG_R7)
+               || (IS_CPU_TIC4X (tic4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )

            INSERTU (opcode, reg, 7, 0);
          else
            {
               if (!check)
            INSERTU (opcode, reg, 7, 0);
          else
            {
               if (!check)

-                as_bad ("Register must be Rn");
+                as_bad (_("Register must be Rn"));

              ret = -1;
            }
           continue;
              ret = -1;
            }
           continue;


@@ -2000,7 +1838,7 @@ c4x_operands_match (inst, insn, check)
 
              /* Create floating point number string.  */
              sprintf (string, "%d.0", (int) exp->X_add_number);
 
              /* Create floating point number string.  */
              sprintf (string, "%d.0", (int) exp->X_add_number);

-             c4x_atof (string, 's', operand->fwords);
+             tic4x_atof (string, 's', operand->fwords);

            }
 
          INSERTU (opcode, operand->fwords[0], 15, 0);
            }
 
          INSERTU (opcode, operand->fwords[0], 15, 0);


@@ -2016,13 +1854,13 @@ c4x_operands_match (inst, insn, check)
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;

-         if ( (reg >= REG_R0 && reg <= REG_R7) 
-               || (IS_CPU_C4X (c4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )
+         if ( (reg >= REG_R0 && reg <= REG_R7)
+               || (IS_CPU_TIC4X (tic4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )

            INSERTU (opcode, reg, 15, 8);
          else
            {
               if (!check)
            INSERTU (opcode, reg, 15, 8);
          else
            {
               if (!check)

-                as_bad ("Register must be Rn");
+                as_bad (_("Register must be Rn"));

              ret = -1;
            }
           continue;
              ret = -1;
            }
           continue;


@@ -2036,14 +1874,14 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be R0--R7");
+                as_bad (_("Register must be R0--R7"));

              ret = -1;
            }
          continue;
 
         case 'i':
           if ( operand->mode == M_REGISTER
              ret = -1;
            }
          continue;
 
         case 'i':
           if ( operand->mode == M_REGISTER

-               && c4x_oplevel & OP_ENH )
+               && tic4x_oplevel & OP_ENH )

             {
               reg = exp->X_add_number;
               INSERTU (opcode, reg, 4, 0);
             {
               reg = exp->X_add_number;
               INSERTU (opcode, reg, 4, 0);


@@ -2057,10 +1895,10 @@ c4x_operands_match (inst, insn, check)
            break;
          if (operand->disp != 0 && operand->disp != 1)
            {
            break;
          if (operand->disp != 0 && operand->disp != 1)
            {

-             if (IS_CPU_C4X (c4x_cpu))
+             if (IS_CPU_TIC4X (tic4x_cpu))

                break;
               if (!check)
                break;
               if (!check)

-                as_bad ("Invalid indirect addressing mode displacement %d",
+                as_bad (_("Invalid indirect addressing mode displacement %d"),

                         operand->disp);
              ret = -1;
              continue;
                         operand->disp);
              ret = -1;
              continue;


@@ -2071,7 +1909,7 @@ c4x_operands_match (inst, insn, check)
 
         case 'j':
           if ( operand->mode == M_REGISTER
 
         case 'j':
           if ( operand->mode == M_REGISTER

-               && c4x_oplevel & OP_ENH )
+               && tic4x_oplevel & OP_ENH )

             {
               reg = exp->X_add_number;
               INSERTU (opcode, reg, 12, 8);
             {
               reg = exp->X_add_number;
               INSERTU (opcode, reg, 12, 8);


@@ -2085,10 +1923,10 @@ c4x_operands_match (inst, insn, check)
            break;
          if (operand->disp != 0 && operand->disp != 1)
            {
            break;
          if (operand->disp != 0 && operand->disp != 1)
            {

-             if (IS_CPU_C4X (c4x_cpu))
+             if (IS_CPU_TIC4X (tic4x_cpu))

                break;
               if (!check)
                break;
               if (!check)

-                as_bad ("Invalid indirect addressing mode displacement %d",
+                as_bad (_("Invalid indirect addressing mode displacement %d"),

                         operand->disp);
              ret = -1;
              continue;
                         operand->disp);
              ret = -1;
              continue;


@@ -2106,7 +1944,7 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be R0--R7");
+                as_bad (_("Register must be R0--R7"));

              ret = -1;
            }
          continue;
              ret = -1;
            }
          continue;


@@ -2120,7 +1958,7 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be R0--R7");
+                as_bad (_("Register must be R0--R7"));

              ret = -1;
            }
          continue;
              ret = -1;
            }
          continue;


@@ -2134,7 +1972,7 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Destination register must be R2 or R3");
+                as_bad (_("Destination register must be R2 or R3"));

              ret = -1;
            }
          continue;
              ret = -1;
            }
          continue;


@@ -2148,13 +1986,13 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Destination register must be R0 or R1");
+                as_bad (_("Destination register must be R0 or R1"));

              ret = -1;
            }
          continue;
 
        case 'O':
              ret = -1;
            }
          continue;
 
        case 'O':

-         if (!IS_CPU_C4X (c4x_cpu))
+         if (!IS_CPU_TIC4X (tic4x_cpu))

            break;
          if (operand->mode != M_INDIRECT)
            break;
            break;
          if (operand->mode != M_INDIRECT)
            break;


@@ -2163,7 +2001,7 @@ c4x_operands_match (inst, insn, check)
              && operand->expr.X_add_number != 0x18)
            {
               if (!check)
              && operand->expr.X_add_number != 0x18)
            {
               if (!check)

-                as_bad ("Invalid indirect addressing mode");
+                as_bad (_("Invalid indirect addressing mode"));

              ret = -1;
              continue;
            }
              ret = -1;
              continue;
            }


@@ -2185,15 +2023,15 @@ c4x_operands_match (inst, insn, check)
              else
                {
                   if (!check)
              else
                {
                   if (!check)

-                    as_bad ("Displacement value of %ld is too large",
+                    as_bad (_("Displacement value of %ld is too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }

-         insn->reloc = BFD_RELOC_16_PCREL;
-         insn->pcrel = 1;
-         insn->exp = *exp;
+         tinsn->reloc = BFD_RELOC_16_PCREL;
+         tinsn->pcrel = 1;
+         tinsn->exp = *exp;

          continue;
 
        case 'Q':
          continue;
 
        case 'Q':


@@ -2207,13 +2045,13 @@ c4x_operands_match (inst, insn, check)
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;

-         if ( (reg >= REG_R0 && reg <= REG_R7) 
-               || (IS_CPU_C4X (c4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )
+         if ( (reg >= REG_R0 && reg <= REG_R7)
+               || (IS_CPU_TIC4X (tic4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )

            INSERTU (opcode, reg, 15, 0);
          else
            {
               if (!check)
            INSERTU (opcode, reg, 15, 0);
          else
            {
               if (!check)

-                as_bad ("Register must be Rn");
+                as_bad (_("Register must be Rn"));

              ret = -1;
            }
           continue;
              ret = -1;
            }
           continue;


@@ -2229,13 +2067,13 @@ c4x_operands_match (inst, insn, check)
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;

-         if ( (reg >= REG_R0 && reg <= REG_R7) 
-               || (IS_CPU_C4X (c4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )
+         if ( (reg >= REG_R0 && reg <= REG_R7)
+               || (IS_CPU_TIC4X (tic4x_cpu) && reg >= REG_R8 && reg <= REG_R11) )

            INSERTU (opcode, reg, 20, 16);
          else
            {
               if (!check)
            INSERTU (opcode, reg, 20, 16);
          else
            {
               if (!check)

-                as_bad ("Register must be Rn");
+                as_bad (_("Register must be Rn"));

              ret = -1;
            }
           continue;
              ret = -1;
            }
           continue;


@@ -2246,7 +2084,7 @@ c4x_operands_match (inst, insn, check)
          if (exp->X_op == O_big)
            {
               if (!check)
          if (exp->X_op == O_big)
            {
               if (!check)

-                as_bad ("Floating point number not valid in expression");
+                as_bad (_("Floating point number not valid in expression"));

              ret = -1;
              continue;
            }
              ret = -1;
              continue;
            }


@@ -2260,7 +2098,7 @@ c4x_operands_match (inst, insn, check)
              else
                {
                  if (!check)
              else
                {
                  if (!check)

-                    as_bad ("Signed immediate value %ld too large",
+                    as_bad (_("Signed immediate value %ld too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;


@@ -2270,25 +2108,25 @@ c4x_operands_match (inst, insn, check)
            {
              if (operand->mode == M_HI)
                {
            {
              if (operand->mode == M_HI)
                {

-                 insn->reloc = BFD_RELOC_HI16;
+                 tinsn->reloc = BFD_RELOC_HI16;

                }
              else
                {
                }
              else
                {

-                 insn->reloc = BFD_RELOC_LO16;
+                 tinsn->reloc = BFD_RELOC_LO16;

                }
                }

-             insn->exp = *exp;
+             tinsn->exp = *exp;

              continue;
            }
          /* Handle cases like ldi foo - $, ar0  where foo
             is a forward reference.  Perhaps we should check
             for X_op == O_symbol and disallow things like
             ldi foo, ar0.  */
              continue;
            }
          /* Handle cases like ldi foo - $, ar0  where foo
             is a forward reference.  Perhaps we should check
             for X_op == O_symbol and disallow things like
             ldi foo, ar0.  */

-         insn->reloc = BFD_RELOC_16;
-         insn->exp = *exp;
+         tinsn->reloc = BFD_RELOC_16;
+         tinsn->exp = *exp;

          continue;
 
          continue;
 

-       case 'T':               /* 5-bit immediate value for c4x stik.  */
-         if (!IS_CPU_C4X (c4x_cpu))
+       case 'T':               /* 5-bit immediate value for tic4x stik.  */
+         if (!IS_CPU_TIC4X (tic4x_cpu))

            break;
          if (operand->mode != M_IMMED)
            break;
            break;
          if (operand->mode != M_IMMED)
            break;


@@ -2302,7 +2140,7 @@ c4x_operands_match (inst, insn, check)
              else
                {
                   if (!check)
              else
                {
                   if (!check)

-                    as_bad ("Immediate value of %ld is too large",
+                    as_bad (_("Immediate value of %ld is too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;


@@ -2323,7 +2161,7 @@ c4x_operands_match (inst, insn, check)
              else
                {
                   if (!check)
              else
                {
                   if (!check)

-                    as_bad ("Unsigned immediate value %ld too large",
+                    as_bad (_("Unsigned immediate value %ld too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;


@@ -2332,15 +2170,15 @@ c4x_operands_match (inst, insn, check)
          else if (exp->X_op == O_symbol)
            {
              if (operand->mode == M_HI)
          else if (exp->X_op == O_symbol)
            {
              if (operand->mode == M_HI)

-               insn->reloc = BFD_RELOC_HI16;
+               tinsn->reloc = BFD_RELOC_HI16;

              else
              else

-               insn->reloc = BFD_RELOC_LO16;
+               tinsn->reloc = BFD_RELOC_LO16;

 
 

-             insn->exp = *exp;
+             tinsn->exp = *exp;

              continue;
            }
              continue;
            }

-         insn->reloc = BFD_RELOC_16;
-         insn->exp = *exp;
+         tinsn->reloc = BFD_RELOC_16;
+         tinsn->exp = *exp;

          continue;
 
        case 'V':               /* Trap numbers (immediate field).  */
          continue;
 
        case 'V':               /* Trap numbers (immediate field).  */


@@ -2348,20 +2186,20 @@ c4x_operands_match (inst, insn, check)
            break;
          if (exp->X_op == O_constant)
            {
            break;
          if (exp->X_op == O_constant)
            {

-             if (exp->X_add_number < 512 && IS_CPU_C4X (c4x_cpu))
+             if (exp->X_add_number < 512 && IS_CPU_TIC4X (tic4x_cpu))

                {
                  INSERTU (opcode, exp->X_add_number, 8, 0);
                  continue;
                }
                {
                  INSERTU (opcode, exp->X_add_number, 8, 0);
                  continue;
                }

-             else if (exp->X_add_number < 32 && IS_CPU_C3X (c4x_cpu))
+             else if (exp->X_add_number < 32 && IS_CPU_TIC3X (tic4x_cpu))

                {
                {

-                 INSERTU (opcode, exp->X_add_number | 0x20, 4, 0);
+                 INSERTU (opcode, exp->X_add_number | 0x20, 5, 0);

                  continue;
                }
              else
                {
                   if (!check)
                  continue;
                }
              else
                {
                   if (!check)

-                    as_bad ("Immediate value of %ld is too large",
+                    as_bad (_("Immediate value of %ld is too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;


@@ -2370,14 +2208,14 @@ c4x_operands_match (inst, insn, check)
          break;                /* No relocations allowed.  */
 
        case 'W':               /* Short immediate int (0--7).  */
          break;                /* No relocations allowed.  */
 
        case 'W':               /* Short immediate int (0--7).  */

-         if (!IS_CPU_C4X (c4x_cpu))
+         if (!IS_CPU_TIC4X (tic4x_cpu))

            break;
          if (operand->mode != M_IMMED)
            break;
          if (exp->X_op == O_big)
            {
               if (!check)
            break;
          if (operand->mode != M_IMMED)
            break;
          if (exp->X_op == O_big)
            {
               if (!check)

-                as_bad ("Floating point number not valid in expression");
+                as_bad (_("Floating point number not valid in expression"));

              ret = -1;
              continue;
            }
              ret = -1;
              continue;
            }


@@ -2391,17 +2229,17 @@ c4x_operands_match (inst, insn, check)
              else
                {
                   if (!check)
              else
                {
                   if (!check)

-                    as_bad ("Immediate value %ld too large",
+                    as_bad (_("Immediate value %ld too large"),

                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }
                             (long) exp->X_add_number);
                  ret = -1;
                  continue;
                }
            }

-         insn->reloc = BFD_RELOC_16;
-         insn->exp = *exp;
+         tinsn->reloc = BFD_RELOC_16;
+         tinsn->exp = *exp;

          continue;
 
          continue;
 

-       case 'X':               /* Expansion register for c4x.  */
+       case 'X':               /* Expansion register for tic4x.  */

          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;


@@ -2410,12 +2248,12 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be ivtp or tvtp");
+                as_bad (_("Register must be ivtp or tvtp"));

              ret = -1;
            }
          continue;
 
              ret = -1;
            }
          continue;
 

-       case 'Y':               /* Address register for c4x lda.  */
+       case 'Y':               /* Address register for tic4x lda.  */

          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;


@@ -2424,12 +2262,12 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be address register");
+                as_bad (_("Register must be address register"));

              ret = -1;
            }
          continue;
 
              ret = -1;
            }
          continue;
 

-       case 'Z':               /* Expansion register for c4x.  */
+       case 'Z':               /* Expansion register for tic4x.  */

          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;
          if (operand->mode != M_REGISTER)
            break;
          reg = exp->X_add_number;


@@ -2438,7 +2276,7 @@ c4x_operands_match (inst, insn, check)
          else
            {
               if (!check)
          else
            {
               if (!check)

-                as_bad ("Register must be ivtp or tvtp");
+                as_bad (_("Register must be ivtp or tvtp"));

              ret = -1;
            }
          continue;
              ret = -1;
            }
          continue;


@@ -2452,7 +2290,7 @@ c4x_operands_match (inst, insn, check)
          continue;
 
        case '|':               /* treat as `,' if have ldi_ldi form.  */
          continue;
 
        case '|':               /* treat as `,' if have ldi_ldi form.  */

-         if (insn->parallel)
+         if (tinsn->parallel)

            {
              if (--num_operands < 0)
                break;          /* Too few operands.  */
            {
              if (--num_operands < 0)
                break;          /* Too few operands.  */


@@ -2486,79 +2324,74 @@ c4x_operands_match (inst, insn, check)
 }
 
 static void
 }
 
 static void

-c4x_insn_check (insn)
-     c4x_insn_t *insn;
+tic4x_insn_check (tic4x_insn_t *tinsn)

 {
 {

-  
-  if (!strcmp(insn->name, "lda"))
+
+  if (!strcmp (tinsn->name, "lda"))

     {
     {

-      if (insn->num_operands < 2 || insn->num_operands > 2)
+      if (tinsn->num_operands < 2 || tinsn->num_operands > 2)

         as_fatal ("Illegal internal LDA insn definition");
 
         as_fatal ("Illegal internal LDA insn definition");
 

-      if ( insn->operands[0].mode == M_REGISTER
-           && insn->operands[1].mode == M_REGISTER
-           && insn->operands[0].expr.X_add_number == insn->operands[1].expr.X_add_number )
-        as_bad ("Source and destination register should not be equal");
+      if (tinsn->operands[0].mode == M_REGISTER
+         && tinsn->operands[1].mode == M_REGISTER
+         && tinsn->operands[0].expr.X_add_number == tinsn->operands[1].expr.X_add_number )
+        as_bad (_("Source and destination register should not be equal"));

     }
     }

-  else if( !strcmp(insn->name, "ldi_ldi")
-           || !strcmp(insn->name, "ldi1_ldi2")
-           || !strcmp(insn->name, "ldi2_ldi1")
-           || !strcmp(insn->name, "ldf_ldf")
-           || !strcmp(insn->name, "ldf1_ldf2")
-           || !strcmp(insn->name, "ldf2_ldf1") )
+  else if (!strcmp (tinsn->name, "ldi_ldi")
+           || !strcmp (tinsn->name, "ldi1_ldi2")
+           || !strcmp (tinsn->name, "ldi2_ldi1")
+           || !strcmp (tinsn->name, "ldf_ldf")
+           || !strcmp (tinsn->name, "ldf1_ldf2")
+           || !strcmp (tinsn->name, "ldf2_ldf1") )

     {
     {

-      if ( insn->num_operands < 4 && insn->num_operands > 5 )
-        as_fatal ("Illegal internal %s insn definition", insn->name);
-      
-      if ( insn->operands[1].mode == M_REGISTER
-           && insn->operands[insn->num_operands-1].mode == M_REGISTER
-           && insn->operands[1].expr.X_add_number == insn->operands[insn->num_operands-1].expr.X_add_number )
-        as_warn ("Equal parallell destination registers, one result will be discarded");
+      if (tinsn->num_operands < 4 || tinsn->num_operands > 5)
+        as_fatal ("Illegal internal %s insn definition", tinsn->name);
+
+      if (tinsn->operands[1].mode == M_REGISTER
+         && tinsn->operands[tinsn->num_operands-1].mode == M_REGISTER
+         && tinsn->operands[1].expr.X_add_number == tinsn->operands[tinsn->num_operands-1].expr.X_add_number )
+        as_warn (_("Equal parallel destination registers, one result will be discarded"));

     }
 }
 
     }
 }
 

-static void 
-c4x_insn_output (insn)
-     c4x_insn_t *insn;
+static void
+tic4x_insn_output (tic4x_insn_t *tinsn)

 {
   char *dst;
 
   /* Grab another fragment for opcode.  */
 {
   char *dst;
 
   /* Grab another fragment for opcode.  */

-  dst = frag_more (insn->nchars);
+  dst = frag_more (tinsn->nchars);

 
   /* Put out opcode word as a series of bytes in little endian order.  */
 
   /* Put out opcode word as a series of bytes in little endian order.  */

-  md_number_to_chars (dst, insn->opcode, insn->nchars);
+  md_number_to_chars (dst, tinsn->opcode, tinsn->nchars);

 
   /* Put out the symbol-dependent stuff.  */
 
   /* Put out the symbol-dependent stuff.  */

-  if (insn->reloc != NO_RELOC)
+  if (tinsn->reloc != NO_RELOC)

     {
       /* Where is the offset into the fragment for this instruction.  */
       fix_new_exp (frag_now,
                   dst - frag_now->fr_literal,  /* where */
     {
       /* Where is the offset into the fragment for this instruction.  */
       fix_new_exp (frag_now,
                   dst - frag_now->fr_literal,  /* where */

-                  insn->nchars,        /* size */
-                  &insn->exp,
-                  insn->pcrel,
-                  insn->reloc);
+                  tinsn->nchars,       /* size */
+                  &tinsn->exp,
+                  tinsn->pcrel,
+                  tinsn->reloc);

     }
 }
 
 /* Parse the operands.  */
     }
 }
 
 /* Parse the operands.  */

-int 
-c4x_operands_parse (s, operands, num_operands)
-     char *s;
-     c4x_operand_t *operands;
-     int num_operands;
+static int
+tic4x_operands_parse (char *s, tic4x_operand_t *operands, int num_operands)

 {
   if (!*s)
     return num_operands;
 
   do
 {
   if (!*s)
     return num_operands;
 
   do

-    s = c4x_operand_parse (s, &operands[num_operands++]);
-  while (num_operands < C4X_OPERANDS_MAX && *s++ == ',');
+    s = tic4x_operand_parse (s, &operands[num_operands++]);
+  while (num_operands < TIC4X_OPERANDS_MAX && *s++ == ',');

 
 

-  if (num_operands > C4X_OPERANDS_MAX)
+  if (num_operands > TIC4X_OPERANDS_MAX)

     {
     {

-      as_bad ("Too many operands scanned");
+      as_bad (_("Too many operands scanned"));

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


@@ -2567,41 +2400,58 @@ c4x_operands_parse (s, operands, num_operands)
 /* Assemble a single instruction.  Its label has already been handled
    by the generic front end.  We just parse mnemonic and operands, and
    produce the bytes of data and relocation.  */
 /* Assemble a single instruction.  Its label has already been handled
    by the generic front end.  We just parse mnemonic and operands, and
    produce the bytes of data and relocation.  */

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

 {
   int ok = 0;
   char *s;
   int i;
   int parsed = 0;
 {
   int ok = 0;
   char *s;
   int i;
   int parsed = 0;

-  c4x_inst_t *inst;            /* Instruction template.  */
-  c4x_inst_t *first_inst;
+  size_t len;
+  tic4x_inst_t *inst;          /* Instruction template.  */
+  tic4x_inst_t *first_inst;

 
 

-  if (str && insn->parallel)
+  /* Scan for parallel operators */
+  if (str)

     {
     {

-      int star;
+      s = str;
+      while (*s && *s != '|')
+        s++;
+
+      if (*s && s[1]=='|')
+        {
+          if(insn->parallel)
+            {
+              as_bad (_("Parallel opcode cannot contain more than two instructions"));
+              insn->parallel = 0;
+              insn->in_use = 0;
+              return;
+            }

 
 

+          /* Lets take care of the first part of the parallel insn */
+          *s++ = 0;
+          md_assemble(str);
+          insn->parallel = 1;
+          str = ++s;
+          /* .. and let the second run though here */
+        }
+    }
+
+  if (str && insn->parallel)
+    {

       /* Find mnemonic (second part of parallel instruction).  */
       s = str;
       /* Skip past instruction mnemonic.  */
       /* Find mnemonic (second part of parallel instruction).  */
       s = str;
       /* Skip past instruction mnemonic.  */

-      while (*s && *s != ' ' && *s != '*')
+      while (*s && *s != ' ')

        s++;
        s++;

-      star = *s == '*';

       if (*s)                  /* Null terminate for hash_find.  */
        *s++ = '\0';            /* and skip past null.  */
       if (*s)                  /* Null terminate for hash_find.  */
        *s++ = '\0';            /* and skip past null.  */

-      strcat (insn->name, "_");
-      strncat (insn->name, str, C4X_NAME_MAX - strlen (insn->name));
-
-      /* Kludge to overcome problems with scrubber removing
-         space between mnemonic and indirect operand (starting with *)
-         on second line of parallel instruction.  */
-      if (star)
-       *--s = '*';
+      len = strlen (insn->name);
+      snprintf (insn->name + len, TIC4X_NAME_MAX - len, "_%s", str);

 
       insn->operands[insn->num_operands++].mode = M_PARALLEL;
 
 
       insn->operands[insn->num_operands++].mode = M_PARALLEL;
 

-      if ((i = c4x_operands_parse
+      if ((i = tic4x_operands_parse

           (s, insn->operands, insn->num_operands)) < 0)
        {
          insn->parallel = 0;
           (s, insn->operands, insn->num_operands)) < 0)
        {
          insn->parallel = 0;


@@ -2614,10 +2464,10 @@ md_assemble (str)
 
   if (insn->in_use)
     {
 
   if (insn->in_use)
     {

-      if ((insn->inst = (struct c4x_inst *)
-          hash_find (c4x_op_hash, insn->name)) == NULL)
+      if ((insn->inst = (struct tic4x_inst *)
+          hash_find (tic4x_op_hash, insn->name)) == NULL)

        {
        {

-         as_bad ("Unknown opcode `%s'.", insn->name);
+         as_bad (_("Unknown opcode `%s'."), insn->name);

          insn->parallel = 0;
          insn->in_use = 0;
          return;
          insn->parallel = 0;
          insn->in_use = 0;
          return;


@@ -2627,28 +2477,29 @@ md_assemble (str)
       first_inst = NULL;
       do
         {
       first_inst = NULL;
       do
         {

-          ok = c4x_operands_match (inst, insn, 1);
+          ok = tic4x_operands_match (inst, insn, 1);

           if (ok < 0)
             {
               if (!first_inst)
                 first_inst = inst;
               ok = 0;
             }
           if (ok < 0)
             {
               if (!first_inst)
                 first_inst = inst;
               ok = 0;
             }

-      } while (!ok && !strcmp (inst->name, inst[1].name) && inst++);
+       }
+      while (!ok && !strcmp (inst->name, inst[1].name) && inst++);

 
       if (ok > 0)
         {
 
       if (ok > 0)
         {

-          c4x_insn_check (insn);
-          c4x_insn_output (insn);
+          tic4x_insn_check (insn);
+          tic4x_insn_output (insn);

         }
       else if (!ok)
         {
           if (first_inst)
         }
       else if (!ok)
         {
           if (first_inst)

-            c4x_operands_match (first_inst, insn, 0);
-          as_bad ("Invalid operands for %s", insn->name);
+            tic4x_operands_match (first_inst, insn, 0);
+          as_bad (_("Invalid operands for %s"), insn->name);

         }
       else
         }
       else

-       as_bad ("Invalid instruction %s", insn->name);
+       as_bad (_("Invalid instruction %s"), insn->name);

     }
 
   if (str && !parsed)
     }
 
   if (str && !parsed)


@@ -2659,11 +2510,12 @@ md_assemble (str)
        s++;
       if (*s)                  /* Null terminate for hash_find.  */
        *s++ = '\0';            /* and skip past null.  */
        s++;
       if (*s)                  /* Null terminate for hash_find.  */
        *s++ = '\0';            /* and skip past null.  */

-      strncpy (insn->name, str, C4X_NAME_MAX - 3);
+      strncpy (insn->name, str, TIC4X_NAME_MAX - 1);
+      insn->name[TIC4X_NAME_MAX - 1] = '\0';

 
 

-      if ((i = c4x_operands_parse (s, insn->operands, 0)) < 0)
+      if ((i = tic4x_operands_parse (s, insn->operands, 0)) < 0)

        {
        {

-         insn->inst = NULL;    /* Flag that error occured.  */
+         insn->inst = NULL;    /* Flag that error occurred.  */

          insn->parallel = 0;
          insn->in_use = 0;
          return;
          insn->parallel = 0;
          insn->in_use = 0;
          return;


@@ -2677,7 +2529,7 @@ md_assemble (str)
 }
 
 void
 }
 
 void

-c4x_cleanup ()
+tic4x_cleanup (void)

 {
   if (insn->in_use)
     md_assemble (NULL);
 {
   if (insn->in_use)
     md_assemble (NULL);


@@ -2685,71 +2537,68 @@ c4x_cleanup ()
 
 /* Turn a string in input_line_pointer into a floating point constant
    of type type, and store the appropriate bytes in *litP.  The number
 
 /* Turn a string in input_line_pointer into a floating point constant
    of type type, and store the appropriate bytes in *litP.  The number

-   of LITTLENUMS emitted is stored in *sizeP.  An error message is
+   of chars emitted is stored in *sizeP.  An error message is

    returned, or NULL on OK.  */
 
    returned, or NULL on OK.  */
 

-char *
-md_atof (type, litP, sizeP)
-     int type;
-     char *litP;
-     int *sizeP;
+const char *
+md_atof (int type, char *litP, int *sizeP)

 {
   int prec;
   int ieee;
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   LITTLENUM_TYPE *wordP;
 {
   int prec;
   int ieee;
   LITTLENUM_TYPE words[MAX_LITTLENUMS];
   LITTLENUM_TYPE *wordP;

-  unsigned char *t;
+  char *t;

 
   switch (type)
     {
 
   switch (type)
     {

-    case 's':                  /* .single */
+    case 's':          /* .single  */

     case 'S':
       ieee = 0;
       prec = 1;
       break;
 
     case 'S':
       ieee = 0;
       prec = 1;
       break;
 

-    case 'd':                  /* .double */
+    case 'd':          /* .double  */

     case 'D':
     case 'D':

-    case 'f':                  /* .float or .single */
+    case 'f':          /* .float  */

     case 'F':
       ieee = 0;
     case 'F':
       ieee = 0;

-      prec = 2;                        /* 1 32-bit word */
+      prec = 2;                /* 1 32-bit word */

       break;
 
       break;
 

-    case 'i':                  /* .ieee */
+    case 'i':          /* .ieee */

     case 'I':
       prec = 2;
       ieee = 1;
     case 'I':
       prec = 2;
       ieee = 1;

-      type = 'f';  /* Rewrite type to be usable by atof_ieee() */
+      type = 'f';  /* Rewrite type to be usable by atof_ieee().  */

       break;
 
       break;
 

-    case 'e':                  /* .ldouble */
+    case 'e':          /* .ldouble */

     case 'E':
     case 'E':

-      prec = 4;                        /* 2 32-bit words */
+      prec = 4;                /* 2 32-bit words */

       ieee = 0;
       break;
 
     default:
       *sizeP = 0;
       ieee = 0;
       break;
 
     default:
       *sizeP = 0;

-      return "Bad call to md_atof()";
+      return _("Unrecognized or unsupported floating point constant");

     }
 
   if (ieee)
     t = atof_ieee (input_line_pointer, type, words);
   else
     }
 
   if (ieee)
     t = atof_ieee (input_line_pointer, type, words);
   else

-    t = c4x_atof (input_line_pointer, type, words);
+    t = tic4x_atof (input_line_pointer, type, words);

   if (t)
     input_line_pointer = t;
   *sizeP = prec * sizeof (LITTLENUM_TYPE);
   if (t)
     input_line_pointer = t;
   *sizeP = prec * sizeof (LITTLENUM_TYPE);

-  t = litP;
+

   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
      little endian byte order.  */
   /* SES: However it is required to put the words (32-bits) out in the
      correct order, hence we write 2 and 2 littlenums in little endian
   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
      little endian byte order.  */
   /* SES: However it is required to put the words (32-bits) out in the
      correct order, hence we write 2 and 2 littlenums in little endian

-     order, while we keep the original order on successive words. */
-  for(wordP = words; wordP<(words+prec) ; wordP+=2)
+     order, while we keep the original order on successive words.  */
+  for (wordP = words; wordP<(words+prec) ; wordP+=2)

     {
     {

-      if (wordP<(words+prec-1)) /* Dump wordP[1] (if we have one) */
+      if (wordP < (words + prec - 1)) /* Dump wordP[1] (if we have one).  */

         {
           md_number_to_chars (litP, (valueT) (wordP[1]),
                               sizeof (LITTLENUM_TYPE));
         {
           md_number_to_chars (litP, (valueT) (wordP[1]),
                               sizeof (LITTLENUM_TYPE));


@@ -2761,14 +2610,11 @@ md_atof (type, litP, sizeP)
                           sizeof (LITTLENUM_TYPE));
       litP += sizeof (LITTLENUM_TYPE);
     }
                           sizeof (LITTLENUM_TYPE));
       litP += sizeof (LITTLENUM_TYPE);
     }

-  return 0;
+  return NULL;

 }
 
 }
 

-void 
-md_apply_fix3 (fixP, value, seg)
-     fixS *fixP;
-     valueT *value;
-     segT seg ATTRIBUTE_UNUSED;
+void
+md_apply_fix (fixS *fixP, valueT *value, segT seg ATTRIBUTE_UNUSED)

 {
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   valueT val = *value;
 {
   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
   valueT val = *value;


@@ -2790,9 +2636,11 @@ md_apply_fix3 (fixP, value, seg)
     {
     case BFD_RELOC_32:
       buf[3] = val >> 24;
     {
     case BFD_RELOC_32:
       buf[3] = val >> 24;

+      /* Fall through.  */

     case BFD_RELOC_24:
     case BFD_RELOC_24_PCREL:
       buf[2] = val >> 16;
     case BFD_RELOC_24:
     case BFD_RELOC_24_PCREL:
       buf[2] = val >> 16;

+      /* Fall through.  */

     case BFD_RELOC_16:
     case BFD_RELOC_16_PCREL:
     case BFD_RELOC_LO16:
     case BFD_RELOC_16:
     case BFD_RELOC_16_PCREL:
     case BFD_RELOC_LO16:


@@ -2803,52 +2651,48 @@ md_apply_fix3 (fixP, value, seg)
 
     case NO_RELOC:
     default:
 
     case NO_RELOC:
     default:

-      as_bad ("Bad relocation type: 0x%02x", fixP->fx_r_type);
+      as_bad (_("Bad relocation type: 0x%02x"), fixP->fx_r_type);

       break;
     }
 
   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) fixP->fx_done = 1;
 }
 
       break;
     }
 
   if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) fixP->fx_done = 1;
 }
 

-/* Should never be called for c4x.  */
-void 
-md_convert_frag (headers, sec, fragP)
-     bfd *headers ATTRIBUTE_UNUSED;
-     segT sec ATTRIBUTE_UNUSED;
-     fragS *fragP ATTRIBUTE_UNUSED;
+/* Should never be called for tic4x.  */
+void
+md_convert_frag (bfd *headers ATTRIBUTE_UNUSED,
+                segT sec ATTRIBUTE_UNUSED,
+                fragS *fragP ATTRIBUTE_UNUSED)

 {
   as_fatal ("md_convert_frag");
 }
 
 {
   as_fatal ("md_convert_frag");
 }
 

-/* Should never be called for c4x.  */
+/* Should never be called for tic4x.  */

 void
 void

-md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr ATTRIBUTE_UNUSED;
-     addressT from_addr ATTRIBUTE_UNUSED;
-     addressT to_addr ATTRIBUTE_UNUSED;
-     fragS *frag ATTRIBUTE_UNUSED;
-     symbolS *to_symbol ATTRIBUTE_UNUSED;
+md_create_short_jump (char *ptr ATTRIBUTE_UNUSED,
+                     addressT from_addr ATTRIBUTE_UNUSED,
+                     addressT to_addr ATTRIBUTE_UNUSED,
+                     fragS *frag ATTRIBUTE_UNUSED,
+                     symbolS *to_symbol ATTRIBUTE_UNUSED)

 {
   as_fatal ("md_create_short_jmp\n");
 }
 
 {
   as_fatal ("md_create_short_jmp\n");
 }
 

-/* Should never be called for c4x.  */
+/* Should never be called for tic4x.  */

 void
 void

-md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
-     char *ptr ATTRIBUTE_UNUSED;
-     addressT from_addr ATTRIBUTE_UNUSED;
-     addressT to_addr ATTRIBUTE_UNUSED;
-     fragS *frag ATTRIBUTE_UNUSED;
-     symbolS *to_symbol ATTRIBUTE_UNUSED;
+md_create_long_jump (char *ptr ATTRIBUTE_UNUSED,
+                    addressT from_addr ATTRIBUTE_UNUSED,
+                    addressT to_addr ATTRIBUTE_UNUSED,
+                    fragS *frag ATTRIBUTE_UNUSED,
+                    symbolS *to_symbol ATTRIBUTE_UNUSED)

 {
   as_fatal ("md_create_long_jump\n");
 }
 
 {
   as_fatal ("md_create_long_jump\n");
 }
 

-/* Should never be called for c4x.  */
+/* Should never be called for tic4x.  */

 int
 int

-md_estimate_size_before_relax (fragP, segtype)
-     register fragS *fragP ATTRIBUTE_UNUSED;
-     segT segtype ATTRIBUTE_UNUSED;
+md_estimate_size_before_relax (fragS *fragP ATTRIBUTE_UNUSED,
+                              segT segtype ATTRIBUTE_UNUSED)

 {
   as_fatal ("md_estimate_size_before_relax\n");
   return 0;
 {
   as_fatal ("md_estimate_size_before_relax\n");
   return 0;


@@ -2856,58 +2700,60 @@ md_estimate_size_before_relax (fragP, segtype)
 
 
 int
 
 
 int

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

 {
   switch (c)
     {
     case OPTION_CPU:             /* cpu brand */
 {
   switch (c)
     {
     case OPTION_CPU:             /* cpu brand */

-      if (tolower (*arg) == 'c')
+      if (TOLOWER (*arg) == 'c')

        arg++;
        arg++;

-      c4x_cpu = atoi (arg);
-      if (!IS_CPU_C3X (c4x_cpu) && !IS_CPU_C4X (c4x_cpu))
-       as_warn ("Unsupported processor generation %d", c4x_cpu);
+      tic4x_cpu = atoi (arg);
+      if (!IS_CPU_TIC3X (tic4x_cpu) && !IS_CPU_TIC4X (tic4x_cpu))
+       as_warn (_("Unsupported processor generation %d"), tic4x_cpu);

       break;
 
     case OPTION_REV:             /* cpu revision */
       break;
 
     case OPTION_REV:             /* cpu revision */

-      c4x_revision = atoi (arg);
+      tic4x_revision = atoi (arg);

       break;
 
     case 'b':
       break;
 
     case 'b':

-      as_warn ("Option -b is depreciated, please use -mbig");
+      as_warn (_("Option -b is depreciated, please use -mbig"));
+      /* Fall through.  */

     case OPTION_BIG:             /* big model */
     case OPTION_BIG:             /* big model */

-      c4x_big_model = 1;
+      tic4x_big_model = 1;

       break;
 
     case 'p':
       break;
 
     case 'p':

-      as_warn ("Option -p is depreciated, please use -mmemparm");
+      as_warn (_("Option -p is depreciated, please use -mmemparm"));
+      /* Fall through.  */

     case OPTION_MEMPARM:         /* push args */
     case OPTION_MEMPARM:         /* push args */

-      c4x_reg_args = 0;
+      tic4x_reg_args = 0;

       break;
 
       break;
 

-    case 'r':                  
-      as_warn ("Option -r is depreciated, please use -mregparm");
+    case 'r':
+      as_warn (_("Option -r is depreciated, please use -mregparm"));
+      /* Fall through.  */

     case OPTION_REGPARM:        /* register args */
     case OPTION_REGPARM:        /* register args */

-      c4x_reg_args = 1;
+      tic4x_reg_args = 1;

       break;
 
     case 's':
       break;
 
     case 's':

-      as_warn ("Option -s is depreciated, please use -msmall");
+      as_warn (_("Option -s is depreciated, please use -msmall"));
+      /* Fall through.  */

     case OPTION_SMALL:         /* small model */
     case OPTION_SMALL:         /* small model */

-      c4x_big_model = 0;
+      tic4x_big_model = 0;

       break;
 
     case OPTION_IDLE2:
       break;
 
     case OPTION_IDLE2:

-      c4x_idle2 = 1;
+      tic4x_idle2 = 1;

       break;
 
     case OPTION_LOWPOWER:
       break;
 
     case OPTION_LOWPOWER:

-      c4x_lowpower = 1;
+      tic4x_lowpower = 1;

       break;
 
     case OPTION_ENHANCED:
       break;
 
     case OPTION_ENHANCED:

-      c4x_enhanced = 1;
+      tic4x_enhanced = 1;

       break;
 
     default:
       break;
 
     default:


@@ -2918,8 +2764,7 @@ md_parse_option (c, arg)
 }
 
 void
 }
 
 void

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

 {
   fprintf (stream,
       _("\nTIC4X options:\n"
 {
   fprintf (stream,
       _("\nTIC4X options:\n"


@@ -2946,21 +2791,20 @@ md_show_usage (stream)
 /* This is called when a line is unrecognized.  This is used to handle
    definitions of TI C3x tools style local labels $n where n is a single
    decimal digit.  */
 /* This is called when a line is unrecognized.  This is used to handle
    definitions of TI C3x tools style local labels $n where n is a single
    decimal digit.  */

-int 
-c4x_unrecognized_line (c)
-     int c;
+int
+tic4x_unrecognized_line (int c)

 {
   int lab;
   char *s;
 
 {
   int lab;
   char *s;
 

-  if (c != '$' || !isdigit (input_line_pointer[0]))
+  if (c != '$' || ! ISDIGIT (input_line_pointer[0]))

     return 0;
 
   s = input_line_pointer;
 
   /* Let's allow multiple digit local labels.  */
   lab = 0;
     return 0;
 
   s = input_line_pointer;
 
   /* Let's allow multiple digit local labels.  */
   lab = 0;

-  while (isdigit (*s))
+  while (ISDIGIT (*s))

     {
       lab = lab * 10 + *s - '0';
       s++;
     {
       lab = lab * 10 + *s - '0';
       s++;


@@ -2968,7 +2812,7 @@ c4x_unrecognized_line (c)
 
   if (dollar_label_defined (lab))
     {
 
   if (dollar_label_defined (lab))
     {

-      as_bad ("Label \"$%d\" redefined", lab);
+      as_bad (_("Label \"$%d\" redefined"), lab);

       return 0;
     }
 
       return 0;
     }
 


@@ -2981,17 +2825,16 @@ c4x_unrecognized_line (c)
 
 /* Handle local labels peculiar to us referred to in an expression.  */
 symbolS *
 
 /* Handle local labels peculiar to us referred to in an expression.  */
 symbolS *

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

 {
   /* Look for local labels of the form $n.  */
 {
   /* Look for local labels of the form $n.  */

-  if (name[0] == '$' && isdigit (name[1]))
+  if (name[0] == '$' && ISDIGIT (name[1]))

     {
       symbolS *symbolP;
       char *s = name + 1;
       int lab = 0;
 
     {
       symbolS *symbolP;
       char *s = name + 1;
       int lab = 0;
 

-      while (isdigit ((unsigned char) *s))
+      while (ISDIGIT ((unsigned char) *s))

        {
          lab = lab * 10 + *s - '0';
          s++;
        {
          lab = lab * 10 + *s - '0';
          s++;


@@ -3014,23 +2857,19 @@ md_undefined_symbol (name)
 
 /* Parse an operand that is machine-specific.  */
 void
 
 /* Parse an operand that is machine-specific.  */
 void

-md_operand (expressionP)
-     expressionS *expressionP ATTRIBUTE_UNUSED;
+md_operand (expressionS *expressionP ATTRIBUTE_UNUSED)

 {
 }
 
 /* Round up a section size to the appropriate boundary---do we need this?  */
 valueT
 {
 }
 
 /* Round up a section size to the appropriate boundary---do we need this?  */
 valueT

-md_section_align (segment, size)
-     segT segment ATTRIBUTE_UNUSED;
-     valueT size;
+md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)

 {
   return size;                 /* Byte (i.e., 32-bit) alignment is fine?  */
 }
 
 {
   return size;                 /* Byte (i.e., 32-bit) alignment is fine?  */
 }
 

-static int 
-c4x_pc_offset (op)
-     unsigned int op;
+static int
+tic4x_pc_offset (unsigned int op)

 {
   /* Determine the PC offset for a C[34]x instruction.
      This could be simplified using some boolean algebra
 {
   /* Determine the PC offset for a C[34]x instruction.
      This could be simplified using some boolean algebra


@@ -3092,55 +2931,56 @@ c4x_pc_offset (op)
    DBcondD, BcondD  disp + PC + 3 => PC
  */
 long
    DBcondD, BcondD  disp + PC + 3 => PC
  */
 long

-md_pcrel_from (fixP)
-     fixS *fixP;
+md_pcrel_from (fixS *fixP)

 {
 {

-  unsigned char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
+  unsigned char *buf;

   unsigned int op;
 
   unsigned int op;
 

-  op = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
+  buf = (unsigned char *) fixP->fx_frag->fr_literal + fixP->fx_where;
+  op = ((unsigned) buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];

 
   return ((fixP->fx_where + fixP->fx_frag->fr_address) >> 2) +
 
   return ((fixP->fx_where + fixP->fx_frag->fr_address) >> 2) +

-    c4x_pc_offset (op);
+    tic4x_pc_offset (op);

 }
 
 /* Fill the alignment area with NOP's on .text, unless fill-data
    was specified. */
 }
 
 /* Fill the alignment area with NOP's on .text, unless fill-data
    was specified. */

-int 
-c4x_do_align (alignment, fill, len, max)
-     int alignment ATTRIBUTE_UNUSED;
-     const char *fill ATTRIBUTE_UNUSED;
-     int len ATTRIBUTE_UNUSED;
-     int max ATTRIBUTE_UNUSED;
+int
+tic4x_do_align (int alignment,
+               const char *fill,
+               int len,
+               int max)

 {
 {

-  unsigned long nop = NOP_OPCODE;
-
-  /* Because we are talking lwords, not bytes, adjust aligment to do words */
+  /* Because we are talking lwords, not bytes, adjust alignment to do words */

   alignment += 2;
   alignment += 2;

-  
+

   if (alignment != 0 && !need_pass_2)
     {
       if (fill == NULL)
         {
   if (alignment != 0 && !need_pass_2)
     {
       if (fill == NULL)
         {

-          /*if (subseg_text_p (now_seg))*/  /* FIXME: doesnt work for .text for some reason */
-          frag_align_pattern( alignment, (const char *)&nop, sizeof(nop), max);
-          return 1;
-          /*else
-            frag_align (alignment, 0, max);*/
+          if (subseg_text_p (now_seg))
+           {
+             char nop[4];
+
+             md_number_to_chars (nop, TIC_NOP_OPCODE, 4);
+             frag_align_pattern (alignment, nop, sizeof (nop), max);
+           }
+          else
+            frag_align (alignment, 0, max);

        }
       else if (len <= 1)
        frag_align (alignment, *fill, max);
       else
        frag_align_pattern (alignment, fill, len, max);
     }
        }
       else if (len <= 1)
        frag_align (alignment, *fill, max);
       else
        frag_align_pattern (alignment, fill, len, max);
     }

-  
-  /* Return 1 to skip the default aligment function */
+
+  /* Return 1 to skip the default alignment function */

   return 1;
 }
 
 /* Look for and remove parallel instruction operator ||.  */
   return 1;
 }
 
 /* Look for and remove parallel instruction operator ||.  */

-void 
-c4x_start_line ()
+void
+tic4x_start_line (void)

 {
   char *s = input_line_pointer;
 
 {
   char *s = input_line_pointer;
 


@@ -3152,13 +2992,15 @@ c4x_start_line ()
       if (insn->in_use)
        {
          insn->parallel = 1;
       if (insn->in_use)
        {
          insn->parallel = 1;

-         input_line_pointer += 2;
+         input_line_pointer ++;
+          *input_line_pointer = ' ';

          /* So line counters get bumped.  */
          input_line_pointer[-1] = '\n';
        }
     }
   else
     {
          /* So line counters get bumped.  */
          input_line_pointer[-1] = '\n';
        }
     }
   else
     {

+      /* Write out the previous insn here */

       if (insn->in_use)
        md_assemble (NULL);
       input_line_pointer = s;
       if (insn->in_use)
        md_assemble (NULL);
       input_line_pointer = s;


@@ -3166,15 +3008,13 @@ c4x_start_line ()
 }
 
 arelent *
 }
 
 arelent *

-tc_gen_reloc (seg, fixP)
-     asection *seg ATTRIBUTE_UNUSED;
-     fixS *fixP;
+tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixP)

 {
   arelent *reloc;
 
 {
   arelent *reloc;
 

-  reloc = (arelent *) xmalloc (sizeof (arelent));
+  reloc = XNEW (arelent);

 
 

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

   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
   reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
   reloc->address /= OCTETS_PER_BYTE;
   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
   reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
   reloc->address /= OCTETS_PER_BYTE;


@@ -3182,7 +3022,7 @@ tc_gen_reloc (seg, fixP)
   if (reloc->howto == (reloc_howto_type *) NULL)
     {
       as_bad_where (fixP->fx_file, fixP->fx_line,
   if (reloc->howto == (reloc_howto_type *) NULL)
     {
       as_bad_where (fixP->fx_file, fixP->fx_line,

-                   "Reloc %d not supported by object file format",
+                   _("Reloc %d not supported by object file format"),

                    (int) fixP->fx_r_type);
       return NULL;
     }
                    (int) fixP->fx_r_type);
       return NULL;
     }