Fix formatting

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

/* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X
   Copyright (C) 1999, 2000 Free Software Foundation.
   Contributed by Timothy Wall (twall@cygnus.com)

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   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.  */

/*
   Texas Instruments TMS320C54X machine specific gas.
   Written by Timothy Wall (twall@alum.mit.edu).

   Valuable things to do:
   Pipeline conflict warnings
   We encode/decode "ld #_label, dp" differently in relocatable files
     This means we're not compatible with TI output containing those
     expressions.  We store the upper nine bits; TI stores the lower nine
     bits.  How they recover the original upper nine bits is beyond me.

   Tests to add to expect testsuite:
     '=' and '==' with .if, .elseif, and .break

   Incompatibilities (mostly trivial):
   We don't allow '''
   We fill text section with zeroes instead of "nop"s
   We don't convert '' or "" to a single instance
   We don't convert '' to '\0'
   We don't allow strings with .byte/.half/.short/.long
   Probably details of the subsym stuff are different
   TI sets labels to be data type 4 (T_INT); GAS uses T_NULL
 */

#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include "as.h"
#include "sb.h"
#include "macro.h"
#include "subsegs.h"
#include "struc-symbol.h"
#include "opcode/tic54x.h"
#include "obj-coff.h"
#include <math.h>

#define MAX_LINE 256 /* lines longer than this are truncated by TI's asm */

const char comment_chars[] = ";";
const char line_comment_chars[] = ";*#"; /* at column zero only */
const char line_separator_chars[] = "";/* not permitted */

/* characters which indicate that this is a floating point constant */
const char FLT_CHARS[] = "fF"; 
/* Characters that can be used to separate mantissa from exp in FP nums */
const char EXP_CHARS[] = "eE";

/* only word (et al.), align, or conditionals are allowed within
   .struct/.union */
#define ILLEGAL_WITHIN_STRUCT() \
do if (current_stag != NULL){ \
as_bad (_("pseudo-op illegal within .struct/.union"));return; } while (0)

void
md_show_usage (stream)
  FILE *stream;
{
  fprintf (stream, _("C54x-specific command line  options:\n"));
  fprintf (stream, _("-mfar-mode | -mf          Use extended addressing\n"));
  fprintf (stream, _("-mcpu=<CPU version>       Specify the CPU version\n"));
  /*  fprintf (stream, _("-mcoff-version={0|1|2}    Select COFF version\n"));*/
  fprintf (stream, _("-merrors-to-file <filename>\n"));
  fprintf (stream, _("-me <filename>            Redirect errors to a file\n"));
}

const char *md_shortopts = "";
enum cpu_version { 
  VNONE = 0, V541 = 1, V542 = 2, V543 = 3, V545 = 5, V548 = 8, V549 = 9,
  V545LP = 15, V546LP = 16
};

enum address_mode {
  c_mode,   /* 16-bit addresses */                         
  far_mode  /* >16-bit addresses */
};

#define OPTION_ADDRESS_MODE     (OPTION_MD_BASE)
#define OPTION_CPU_VERSION      (OPTION_ADDRESS_MODE+1)
#define OPTION_COFF_VERSION     (OPTION_CPU_VERSION+1)
#define OPTION_STDERR_TO_FILE   (OPTION_COFF_VERSION+1)

struct option md_longopts[] = 
{
  { "mfar-mode",       no_argument,         NULL, OPTION_ADDRESS_MODE },
  { "mf",              no_argument,         NULL, OPTION_ADDRESS_MODE },
  { "mcpu",            required_argument,   NULL, OPTION_CPU_VERSION },
  /*  { "mcoff-version",   required_argument,   NULL, OPTION_COFF_VERSION },*/
  { "merrors-to-file", required_argument,   NULL, OPTION_STDERR_TO_FILE },
  { "me",              required_argument,   NULL, OPTION_STDERR_TO_FILE },
  { NULL, no_argument, NULL, 0},
};

size_t md_longopts_size = sizeof (md_longopts);

static int assembly_begun = 0; 
/* Addressing mode is not entirely implemented; the latest rev of the Other
   assembler doesn't seem to make any distinction whatsoever; all relocations
   are stored as extended relocatiosn.  Older versions used REL16 vs RELEXT16,
   but now it seems all relocations are RELEXT16.  We use all RELEXT16.

   The cpu version is kind of a waste of time as well.  There is one
   instruction (RND) for LP devices only, and several for devices with
   extended addressing only.  We include it for compatibility.
 */
static enum address_mode amode = c_mode;
static enum cpu_version cpu  = VNONE;

/* include string substitutions in listing? */
static int listing_sslist = 0;
/* did we do subsym substitutions on the line? */
static int substitution_line = 0;
/* last label seen */
static symbolS *last_label_seen = NULL;
/* this ensures that all new labels are unique */
static int local_label_id;

static struct hash_control *subsym_recurse_hash; /* prevent infinite recurse */
static struct hash_control *math_hash; /* built-in math functions */
/* allow maximum levels of macro nesting; level 0 is the main substitution
   symbol table.  The other assembler only does 32 levels, so there! */
static struct hash_control *subsym_hash[100];
/* keep track of local labels so we can substitute them before GAS sees them 
   since macros use their own 'namespace' for local labels, use a separate hash

   We do our own local label handling 'cuz it's subtly different from the
   stock GAS handling.

   We use our own macro nesting counter, since GAS overloads it when expanding
   other things (like conditionals and repeat loops).
 */
static int macro_level = 0;
static struct hash_control *local_label_hash[100];
/* keep track of struct/union tags */
static struct hash_control *stag_hash;
static struct hash_control *op_hash;
static struct hash_control *parop_hash;
static struct hash_control *reg_hash;
static struct hash_control *mmreg_hash;
static struct hash_control *cc_hash;
static struct hash_control *cc2_hash;
static struct hash_control *cc3_hash;
static struct hash_control *sbit_hash;
static struct hash_control *misc_symbol_hash;

static char *subsym_substitute PARAMS ((char *line, int forced));
static char *subsym_lookup PARAMS ((char *name, int nest_level));
static void subsym_create_or_replace PARAMS ((char *name, char *value));
static float math_ceil PARAMS ((float, float));
static float math_cvi PARAMS ((float, float));
static float math_floor PARAMS ((float, float));
static float math_fmod PARAMS ((float, float));
static float math_int PARAMS ((float, float));
static float math_round PARAMS ((float, float));
static float math_sgn PARAMS ((float, float));
static float math_trunc PARAMS ((float, float));
static float math_acos PARAMS ((float, float));
static float math_asin PARAMS ((float, float));
static float math_atan PARAMS ((float, float));
static float math_atan2 PARAMS ((float, float));
static float math_cosh PARAMS ((float, float));
static float math_cos PARAMS ((float, float));
static float math_cvf PARAMS ((float, float));
static float math_exp PARAMS ((float, float));
static float math_fabs PARAMS ((float, float));
static float math_ldexp PARAMS ((float, float));
static float math_log10 PARAMS ((float, float));
static float math_log PARAMS ((float, float));
static float math_max PARAMS ((float, float));
static float math_pow PARAMS ((float, float));
static float math_sin PARAMS ((float, float));
static float math_sinh PARAMS ((float, float));
static float math_sqrt PARAMS ((float, float));
static float math_tan PARAMS ((float, float));
static float math_tanh PARAMS ((float, float));

static struct stag {
  symbolS *sym;                     /* symbol for this stag; value is offset */
  const char *name;                 /* shortcut to symbol name */
  bfd_vma size;                     /* size of struct/union */
  int current_bitfield_offset;      /* temporary for tracking fields */
  int is_union;
  struct stag_field {               /* list of fields */
    const char *name;
    bfd_vma offset;                 /* of start of this field */
    int bitfield_offset;            /* of start of this field */
    struct stag *stag;              /* if field is struct/union */
    struct stag_field *next;
  } *field;
  /* for nesting; used only in stag construction */
  struct stag *inner;               /* enclosed .struct */
  struct stag *outer;               /* enclosing .struct */
} *current_stag = NULL;

static segT stag_saved_seg;
static subsegT stag_saved_subseg;

/* output a single character (upper octect is zero) */
static void 
tic54x_emit_char (char c)
{
  expressionS exp;

  exp.X_op = O_constant;
  exp.X_add_number = c;
  emit_expr (&exp, 2);
}

/* walk backwards in the frag chain */
static fragS *
frag_prev (frag, seg)
  fragS *frag;
  segT seg;
{
  segment_info_type *seginfo = seg_info (seg);
  fragS *fragp;

  for (fragp = seginfo->frchainP->frch_root;fragp;fragp = fragp->fr_next)
    if (fragp->fr_next == frag)
      return fragp;
  return NULL;
}

static fragS *
bit_offset_frag (frag, seg)
  fragS *frag;
  segT seg;
{
  while (frag != NULL)
    {
      if (frag->fr_fix == 0 
          && frag->fr_opcode == NULL 
          && frag->tc_frag_data == 0)
        frag = frag_prev (frag, seg);
      else
        return frag;
    }
  return NULL;
}

/* return the number of bits allocated in the most recent word, or zero if
   none. .field/.space/.bes may leave words partially allocated */
static int
frag_bit_offset (frag, seg)
  fragS *frag;
  segT seg;
{
  frag = bit_offset_frag (frag, seg);
  if (frag)
    {
      return frag->fr_opcode != NULL ? -1 : frag->tc_frag_data;
    }
  return 0;
}

/* read an expression from a C string; returns a pointer past the end of the
   expression  */
static char *
parse_expression (char *str, expressionS * exp)
{
  char *s;
  char *tmp;

  tmp = input_line_pointer;	/* Save line pointer.  */
  input_line_pointer = str;
  expression (exp);
  s = input_line_pointer;
  input_line_pointer = tmp;	/* Restore line pointer.  */
  return s;			/* Return pointer to where parsing stopped.  */
}

/* .asg "character-string"|character-string, symbol 
   
   .eval is the only pseudo-op allowed to perform arithmetic on substitution
   symbols.  all other use of symbols defined with .asg are currently
   unsupported. 
*/
static void 
tic54x_asg (x)
  int x ATTRIBUTE_UNUSED;
{
  int c;
  char *name;
  char *str;
  char *tmp;
  int quoted = *input_line_pointer == '"';

  ILLEGAL_WITHIN_STRUCT ();

  if (quoted)
    {
      int len;
      str = demand_copy_C_string (&len);
      c = *input_line_pointer;
    }
  else
    {
      str = input_line_pointer;
      while ((c = *input_line_pointer) != ',')
        {
          if (is_end_of_line[(int)*input_line_pointer])
            break;
          ++input_line_pointer;
        }
      *input_line_pointer = 0;
    }
  if (c != ',')
    {
      as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'"));
      ignore_rest_of_line ();
      return;
    }

  name = ++input_line_pointer;
  c = get_symbol_end ();	/* Get terminator.  */
  if (!isalpha (*name))
    {
      as_bad ("symbols assigned with .asg must begin with a letter");
      ignore_rest_of_line ();
      return;
    }

  tmp = xmalloc (strlen (str) + 1);
  strcpy (tmp, str);
  str = tmp;
  tmp = xmalloc (strlen (name) + 1);
  strcpy (tmp, name);
  name = tmp;
  subsym_create_or_replace (name, str);
  *input_line_pointer = c;
  demand_empty_rest_of_line ();
}

/* .eval expression, symbol 
   There's something screwy about this.  The other assembler sometimes does and
   sometimes doesn't substitute symbols defined with .eval.  
   We'll put the symbols into the subsym table as well as the normal symbol
   table, since that's what works best.
*/
static void 
tic54x_eval (x)
  int x ATTRIBUTE_UNUSED;
{
  char c;
  int value;
  char *name;
  symbolS *symbolP;
  char valuestr[32], *tmp;
  int quoted;

  ILLEGAL_WITHIN_STRUCT ();

  SKIP_WHITESPACE ();

  quoted = *input_line_pointer == '"';
  if (quoted)
    ++input_line_pointer;
  value = get_absolute_expression ();
  if (quoted)
    {
      if (*input_line_pointer != '"')
        {
          as_bad (_("Unterminated string after absolute expression"));
          ignore_rest_of_line ();
          return;
        }
      ++input_line_pointer;
    }
  if (*input_line_pointer++ != ',')
    {
      as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'"));
      ignore_rest_of_line ();
      return;
    }
  name = input_line_pointer;
  c = get_symbol_end ();	/* Get terminator.  */
  tmp = xmalloc (strlen (name)+1);
  name = strcpy (tmp, name);
  *input_line_pointer = c;

  if (!isalpha (*name))
    {
      as_bad (_("symbols assigned with .eval must begin with a letter"));
      ignore_rest_of_line ();
      return;
    }
  symbolP = symbol_new (name, absolute_section,
			(valueT) value, &zero_address_frag);
  SF_SET_LOCAL (symbolP);
  symbol_table_insert (symbolP);

  /* The "other" assembler sometimes doesn't put .eval's in the subsym table
     But since there's not written rule as to when, don't even bother trying
     to match their behavior */
  sprintf (valuestr, "%d", value);
  tmp = xmalloc (strlen (valuestr) + 1);
  strcpy (tmp, valuestr);
  subsym_create_or_replace (name, tmp);

  demand_empty_rest_of_line ();
}

/* .bss symbol, size [, [blocking flag] [, alignment flag] 

   alignment is to a longword boundary; blocking is to 128-word boundary.

   1) if there is a hole in memory, this directive should attempt to fill it
      (not yet implemented).

   2) if the blocking flag is not set, allocate at the current SPC
      otherwise, check to see if the current SPC plus the space to be
      allocated crosses the page boundary (128 words).
      if there's not enough space, create a hole and align with the next page
      boundary. 
      (not yet implemented)

 */
static void 
tic54x_bss (x)
  int x ATTRIBUTE_UNUSED;
{
  char c;
  char *name;
  char *p;
  int words;
  segT current_seg;
  subsegT current_subseg;
  symbolS *symbolP;
  int block = 0;
  int align = 0;

  ILLEGAL_WITHIN_STRUCT ();

  current_seg = now_seg;	/* save current seg.  */
  current_subseg = now_subseg;	/* save current subseg.  */

  name = input_line_pointer;
  c = get_symbol_end ();	/* Get terminator.  */
  if (c != ',')
    {
      as_bad (".bss size argument missing\n");
      ignore_rest_of_line ();
      return;
    }

  ++input_line_pointer;
  words = get_absolute_expression ();
  if (words < 0)
    {
      as_bad (".bss size %d < 0!", words);
      ignore_rest_of_line ();
      return;
    }

  if (*input_line_pointer == ',')
    {
      /* the blocking flag may be missing */
      ++input_line_pointer;
      if (*input_line_pointer != ',')
          block = get_absolute_expression ();
      else
          block = 0;

      if (*input_line_pointer == ',')
        {
          ++input_line_pointer;
          align = get_absolute_expression ();
        }
      else
        align = 0;
    }
  else
    block = align = 0;

  subseg_set (bss_section, 0);
  symbolP = symbol_find_or_make (name);

  if (S_GET_SEGMENT (symbolP) == bss_section)
    symbolP->sy_frag->fr_symbol = (symbolS *) NULL;

  symbol_set_frag (symbolP, frag_now);
  p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
		(offsetT)(words << 1), (char *) 0);
  *p = 0;			/* fill char.  */

  S_SET_SEGMENT (symbolP, bss_section);

  /* The symbol may already have been created with a preceding
     ".globl" directive -- be careful not to step on storage class
     in that case.  Otherwise, set it to static.  */
  if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
    S_SET_STORAGE_CLASS (symbolP, C_STAT);

  if (align)
    {
      /* s_align eats end of line; restore it */
      s_align_bytes (4);
      --input_line_pointer;
    }

  if (block)
      bss_section->flags |= SEC_BLOCK;

  subseg_set (current_seg, current_subseg);	/* restore current seg.  */
  demand_empty_rest_of_line ();
}

static void
stag_add_field_symbols (struct stag *stag,
                        const char *path, 
                        bfd_vma base_offset, 
                        symbolS *rootsym,
                        const char *root_stag_name)
{
  char prefix[strlen (path) + 2];
  struct stag_field *field = stag->field;
  
  /* construct a symbol for every field contained within this structure 
     including fields within structure fields
   */
  strcpy (prefix, path);
  if (*path)
    strcat (prefix, ".");

  while (field != NULL)
    {
      int len = strlen (prefix) + strlen (field->name) + 2;
      char *name = xmalloc (len);
      strcpy (name, prefix);
      strcat (name, field->name);

      if (rootsym == NULL)
        {
          symbolS *sym;
          sym = symbol_new (name, absolute_section, 
                            (field->stag ? field->offset :
                             (valueT)(base_offset + field->offset)), 
                            &zero_address_frag);
          SF_SET_LOCAL (sym);
          symbol_table_insert (sym);
        }
      else
        {
          char *replacement = xmalloc (strlen (name) + strlen (stag->name) + 2);
          strcpy (replacement, S_GET_NAME (rootsym));
          strcat (replacement, "+");
          strcat (replacement, root_stag_name);
          strcat (replacement, name + strlen (S_GET_NAME (rootsym)));
          hash_insert (subsym_hash[0], name, replacement);
        }

      /* recurse if the field is a structure 
         note the field offset is relative to the outermost struct
       */
      if (field->stag != NULL)
        stag_add_field_symbols (field->stag, name, 
                                field->offset, 
                                rootsym, root_stag_name);
      field = field->next;
    }
}

/* keep track of stag fields so that when structures are nested we can add the
   complete dereferencing symbols to the symbol table */
static void
stag_add_field (struct stag *parent, const char *name, bfd_vma offset, 
                struct stag *stag)
{
  struct stag_field *sfield = xmalloc (sizeof (struct stag_field));

  memset (sfield, 0, sizeof (*sfield));
  sfield->name = strcpy (xmalloc (strlen (name)+1), name);
  sfield->offset = offset;
  sfield->bitfield_offset = parent->current_bitfield_offset;
  sfield->stag = stag;
  if (parent->field == NULL)
    parent->field = sfield;
  else {
    struct stag_field *sf = parent->field;
    while (sf->next != NULL)
      sf = sf->next;
    sf->next = sfield;
  }
  /* only create a symbol for this field if the parent has no name */
  if (!strncmp (".fake", parent->name, 5))
    {
      symbolS *sym = symbol_new (name, absolute_section, 
                                 (valueT)offset, &zero_address_frag);
      SF_SET_LOCAL (sym);
      symbol_table_insert (sym);
    }
}

/* [STAG] .struct       [OFFSET]
   start defining structure offsets (symbols in absolute section)

 */
static void
tic54x_struct (int arg)
{
  int start_offset = 0;
  int is_union = arg;

  if (!current_stag)
    {
      /* starting a new struct, switch to absolute section */
      stag_saved_seg = now_seg;
      stag_saved_subseg = now_subseg;
      subseg_set (absolute_section, 0);
    }
  /* align the current pointer */
  else if (current_stag->current_bitfield_offset != 0)
    {
      ++abs_section_offset;
      current_stag->current_bitfield_offset = 0;
    }

  /* offset expression is only meaningful for global .structs */
  if (!is_union)
    {
      /* offset is ignored in inner structs */
      SKIP_WHITESPACE ();
      if (!is_end_of_line[(int)*input_line_pointer])
        start_offset = get_absolute_expression ();
      else
        start_offset = 0;
    }

  if (current_stag)
    {
      /* nesting, link to outer one */
      current_stag->inner = (struct stag *)xmalloc (sizeof (struct stag));
      memset (current_stag->inner, 0, sizeof (struct stag));
      current_stag->inner->outer = current_stag;
      current_stag = current_stag->inner;
      if (start_offset)
        as_warn (_("Offset on nested structures is ignored"));
      start_offset = abs_section_offset;
    }
  else 
    {
      current_stag = (struct stag *)xmalloc (sizeof (struct stag));
      memset (current_stag, 0, sizeof (struct stag));
      abs_section_offset = start_offset;
    }
  current_stag->is_union = is_union;

  if (line_label == NULL)
    {
      static int struct_count = 0;
      char fake[] = ".fake_stagNNNNNNN";
      sprintf (fake, ".fake_stag%d", struct_count++);
      current_stag->sym = symbol_new (fake, absolute_section,
                                      (valueT)abs_section_offset,
                                      &zero_address_frag);
    }
  else
    {
      char label[strlen (S_GET_NAME (line_label)) + 1];
      strcpy (label, S_GET_NAME (line_label));
      current_stag->sym = symbol_new (label, absolute_section,
                                      (valueT)abs_section_offset,
                                      &zero_address_frag);
    }
  current_stag->name = S_GET_NAME (current_stag->sym);
  SF_SET_LOCAL (current_stag->sym);
  /* nested .structs don't go into the symbol table */
  if (current_stag->outer == NULL)
    symbol_table_insert (current_stag->sym);

  line_label = NULL;
}

/* [LABEL] .endstruct 
   finish defining structure offsets; optional LABEL's value will be the size
   of the structure
 */
static void
tic54x_endstruct (int is_union)
{
  int size;
  const char *path = 
    !strncmp (current_stag->name, ".fake", 5) ? "" : current_stag->name;
  if (!current_stag || current_stag->is_union != is_union)
    {
      as_bad (_(".end%s without preceding .%s"), 
              is_union ? "union" : "struct",
              is_union ? "union" : "struct");
      ignore_rest_of_line ();
      return;
    }

  /* align end of structures */
  if (current_stag->current_bitfield_offset)
    {
      ++abs_section_offset;
      current_stag->current_bitfield_offset = 0;
    }

  if (current_stag->is_union)
    size = current_stag->size;
  else
    size = abs_section_offset - S_GET_VALUE (current_stag->sym);
  if (line_label != NULL)
    {
      S_SET_VALUE (line_label, size);
      symbol_table_insert (line_label);
      line_label = NULL;
    }

  /* union size has already been calculated */
  if (!current_stag->is_union)
    current_stag->size = size;
  /* nested .structs don't get put in the stag table */
  if (current_stag->outer == NULL)
    {
      hash_insert (stag_hash, current_stag->name, current_stag);
      stag_add_field_symbols (current_stag, path, 
                              S_GET_VALUE (current_stag->sym),
                              NULL, NULL);
    }
  current_stag = current_stag->outer;

  /* if this is a nested .struct/.union, add it as a field to the enclosing
     one.  otherwise, restore the section we were in   */
  if (current_stag != NULL)
    {
      stag_add_field (current_stag, current_stag->inner->name,
                      S_GET_VALUE (current_stag->inner->sym), 
                      current_stag->inner);
    }
  else
    subseg_set (stag_saved_seg, stag_saved_subseg);
}

/* [LABEL]      .tag    STAG
   Reference a structure within a structure, as a sized field with an optional
   label. 
   If used outside of a .struct/.endstruct, overlays the given structure
   format on the existing allocated space.
 */
static void
tic54x_tag (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  char *name = input_line_pointer;
  int c = get_symbol_end ();
  struct stag *stag = (struct stag *)hash_find (stag_hash, name);

  if (!stag)
    {
      if (*name)
        as_bad (_("Unrecognized struct/union tag '%s'"), name);
      else
        as_bad (_(".tag requires a structure tag"));
      ignore_rest_of_line ();
      return;
    }
  if (line_label == NULL)
    {
      as_bad (_("Label required for .tag"));
      ignore_rest_of_line ();
      return;
    }
  else
    {
      char label[strlen (S_GET_NAME (line_label))+1];
      strcpy (label,  S_GET_NAME (line_label));
      if (current_stag != NULL)
        stag_add_field (current_stag, label, 
                        abs_section_offset - S_GET_VALUE (current_stag->sym), 
                        stag);
      else
        {
          symbolS *sym = symbol_find (label);
          if (!sym)
            {
              as_bad (_(".tag target '%s' undefined"), label);
              ignore_rest_of_line ();
              return;
            }
          stag_add_field_symbols (stag, S_GET_NAME (sym), 
                                  S_GET_VALUE (stag->sym), sym, stag->name);
        }
    }
    
  /* bump by the struct size, but only if we're within a .struct section */
  if (current_stag != NULL && !current_stag->is_union)
    abs_section_offset += stag->size;

  *input_line_pointer = c;
  demand_empty_rest_of_line ();
  line_label = NULL;
}

/* handle all .byte, .char, .double, .field, .float, .half, .int, .long,
   .short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword,
   and .word 
*/
static void
tic54x_struct_field (int type)
{
  int size;
  int count = 1;
  int new_bitfield_offset = 0;
  int field_align = current_stag->current_bitfield_offset != 0;
  int longword_align = 0;

  SKIP_WHITESPACE ();
  if (!is_end_of_line[(int)*input_line_pointer])
    count = get_absolute_expression ();

  switch (type)
    {
    case 'b':
    case 'B':
    case 'c':
    case 'C':
    case 'h':
    case 'H':
    case 'i':
    case 'I':
    case 's':
    case 'S':
    case 'w':
    case 'W':
    case '*': /* string */
      size = 1;
      break;
    case 'f':
    case 'l':
    case 'L':
      longword_align = 1;
      size = 2;
      break;
    case '.': /* bitfield */
      size = 0;
      if (count < 1 || count > 32)
        {
          as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count);
          ignore_rest_of_line ();
          return;
        }
      if (current_stag->current_bitfield_offset + count > 16)
        {
          /* set the appropriate size and new field offset */
          if (count == 32)
            {
              size = 2; count = 1;
            }
          else if (count > 16)
            {
              size = 1; count = 1;
              new_bitfield_offset = count - 16;
            }
          else
            {
              new_bitfield_offset = count;
            }
        }
      else
        {
          field_align = 0;
          new_bitfield_offset = current_stag->current_bitfield_offset + count;
        }
      break;
    default:
      as_bad (_("Unrecognized field type '%c'"), type);
      ignore_rest_of_line ();
      return;
    }

  if (field_align)
    {
      /* align to the actual starting position of the field */
      current_stag->current_bitfield_offset = 0;
      ++abs_section_offset;
    }
  /* align to longword boundary */
  if (longword_align && (abs_section_offset & 0x1))
    ++abs_section_offset;

  if (line_label == NULL)
    {
      static int fieldno = 0;
      char fake[] = ".fake_fieldNNNNN";
      sprintf (fake, ".fake_field%d", fieldno++);
      stag_add_field (current_stag, fake, 
                      abs_section_offset - S_GET_VALUE (current_stag->sym), 
                      NULL);
    }
  else
    {
      char label[strlen (S_GET_NAME (line_label) + 1)];
      strcpy (label, S_GET_NAME (line_label));
      stag_add_field (current_stag, label, 
                      abs_section_offset - S_GET_VALUE (current_stag->sym), 
                      NULL);
    }

  if (current_stag->is_union)
    {
      /* Note we treat the element as if it were an array of COUNT */
      if (current_stag->size < (unsigned)size * count)
        current_stag->size = size * count;
    }
  else
    {
      abs_section_offset += (unsigned)size * count;
      current_stag->current_bitfield_offset = new_bitfield_offset;
    }
  line_label = NULL;
}

/* Handle .byte, .word. .int, .long and all variants */
int emitting_long = 0;
static void 
tic54x_cons (int type)
{
  register unsigned int c;
  int octets;

  /* if we're within a .struct construct, don't actually allocate space */
  if (current_stag != NULL)
    {
      tic54x_struct_field (type);
      return;
    }

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  generate_lineno_debug ();

  /* align long words to long word boundaries (4 octets) */
  if (type == 'l' || type == 'L')
    {
      frag_align (2, 0, 2);
      /* if there's a label, assign it to the first allocated word */
      if (line_label != NULL)
        {
          symbol_set_frag (line_label, frag_now);
          S_SET_VALUE (line_label, frag_now_fix ());
        }
    }

  switch (type)
    {
    case 'l':
    case 'L':
    case 'x':
      octets = 4;
      break;
    case 'b':
    case 'B':
    case 'c':
    case 'C':
      octets = 1;
      break;
    default:
      octets = 2;
      break;
    }

  do
    {
      if (*input_line_pointer == '"')
	{
	  input_line_pointer++;
	  while (is_a_char (c = next_char_of_string ()))
	    tic54x_emit_char (c);
	  know (input_line_pointer[-1] == '\"');
	}
      else
	{
	  expressionS exp;

	  input_line_pointer = parse_expression (input_line_pointer, &exp);
	  if (exp.X_op == O_constant)
	    {
              offsetT value = exp.X_add_number;
              /* truncate overflows */
	      switch (octets)
		{
		case 1:
                  if ((value > 0 && value > 0xFF)
                      || (value < 0 && value < - 0x100))
                    as_warn ("Overflow in expression, truncated to 8 bits");
		  break;
		case 2:
                  if ((value > 0 && value > 0xFFFF)
                      || (value < 0 && value < - 0x10000))
                    as_warn ("Overflow in expression, truncated to 16 bits");
		  break;
		}
	    }
          if (exp.X_op != O_constant && octets < 2)
            {
              /* Disallow .byte with a non constant expression that will
                 require relocation.  */ 
              as_bad (_("Relocatable values require at least WORD storage"));
              ignore_rest_of_line ();
              return;
            }

          if (exp.X_op != O_constant 
              && amode == c_mode
              && octets == 4)
            {
              /* FIXME -- at one point TI tools used to output REL16
                 relocations, but I don't think the latest tools do at all 
                 The current tools output extended relocations regardless of
                 the addresing mode (I actually think that ".c_mode" is
                 totally ignored in the latest tools) */
              amode = far_mode;
              emitting_long = 1;
              emit_expr (&exp, 4);
              emitting_long = 0;
              amode = c_mode;
            }
          else
            {
              emitting_long = octets == 4;
              emit_expr (&exp, (octets == 1) ? 2 : octets);
              emitting_long = 0;
            }
	}
    }
  while (*input_line_pointer++ == ',');

  input_line_pointer--;		/* Put terminator back into stream.  */
  demand_empty_rest_of_line ();
}

/* .global <symbol>[,...,<symbolN>]
   .def    <symbol>[,...,<symbolN>]
   .ref    <symbol>[,...,<symbolN>]

   These all identify global symbols. 

   .def means the symbol is defined in the current module and can be accessed
   by other files.  The symbol should be placed in the symbol table.

   .ref means the symbol is used in the current module but defined in another
   module.  The linker is to resolve this symbol's definition at link time.

   .global should act as a .ref or .def, as needed.

   global, def and ref all have symbol storage classes of C_EXT.  

   I can't identify any difference in how the "other" c54x assembler treats
   these, so we ignore the type here.
*/
void
tic54x_global (type)
     int type;
{
  char *name;
  int c;
  symbolS *symbolP;

  if (type == 'r')
      as_warn (_("Use of .def/.ref is deprecated.  Use .global instead"));

  ILLEGAL_WITHIN_STRUCT ();

  do
    {
      name = input_line_pointer;
      c = get_symbol_end ();
      symbolP = symbol_find_or_make (name);

      *input_line_pointer = c;
      S_SET_STORAGE_CLASS (symbolP, C_EXT);
      if (c == ',')
	{
	  input_line_pointer++;
	  if (is_end_of_line[(int)*input_line_pointer])
	    c = *input_line_pointer;
	}
    }
  while (c == ',');

  demand_empty_rest_of_line ();
}

/* remove the symbol from the local label hash lookup */
static void
tic54x_remove_local_label (key, value)
  const char *key;
  PTR value ATTRIBUTE_UNUSED;
{
  PTR *elem = hash_delete (local_label_hash[macro_level], key);
  free (elem);
}

/* Reset all local labels */
static void 
tic54x_clear_local_labels (ignored)
  int ignored ATTRIBUTE_UNUSED;
{
  hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label);
}

/* 
   .text
   .data
   .sect "section name"

   Initialized section
   make sure local labels get cleared when changing sections 

   ARG is 't' for text, 'd' for data, or '*' for a named section

   For compatibility, '*' sections have SEC_DATA set instead of SEC_CODE
*/
static void
tic54x_sect (int arg)
{
  ILLEGAL_WITHIN_STRUCT ();

  /* local labels are cleared when changing sections */
  tic54x_clear_local_labels (0);

  if (arg == 't')
    s_text (0);
  else if (arg == 'd')
    s_data (0);
  else
    {
      char *name = NULL;
      int len;
      /* if there are quotes, remove them */
      if (*input_line_pointer == '"')
        {
          name = demand_copy_C_string (&len);
          demand_empty_rest_of_line ();
          name = strcpy (xmalloc (len+10), name);
        }
      else 
        {
          int c;
          name = input_line_pointer;
          c = get_symbol_end ();
          name = strcpy (xmalloc (len+10), name);
          *input_line_pointer = c;
          demand_empty_rest_of_line ();
        }
      /* make sure all named initialized sections are SEC_DATA */
      strcat (name, ",\"w\"\n");
      input_scrub_insert_line (name);
      obj_coff_section (0);

      /* if there was a line label, make sure that it gets assigned the proper
         section.  This is for compatibility, even though the actual behavior
         is not explicitly defined.  For consistency, we make .sect behave
         like .usect, since that is probably what people expect */
      if (line_label != NULL)
        {
          S_SET_SEGMENT (line_label, now_seg);
          symbol_set_frag (line_label, frag_now);
          S_SET_VALUE (line_label, frag_now_fix ());
          if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
              S_SET_STORAGE_CLASS (line_label, C_LABEL);
        }
    }
}

/* [symbol] .space space_in_bits 
   [symbol] .bes space_in_bits
   BES puts the symbol at the *last* word allocated 

   cribbed from s_space
*/
static void
tic54x_space (int arg)
{
  expressionS exp;
  char *p = 0;
  int octets = 0;
  long words;
  int bits_per_byte = (OCTETS_PER_BYTE * 8);
  int bit_offset = 0;
  symbolS *label = line_label;
  int bes = arg;

  ILLEGAL_WITHIN_STRUCT ();

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  /* read the bit count */
  expression (&exp);

  /* some expressions are unresolvable until later in the assembly pass;
     postpone until relaxation/fixup.  we also have to postpone if a previous
     partial allocation has not been completed yet.
  */
  if (exp.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1)
    {
      struct bit_info *bi = xmalloc (sizeof (struct bit_info));
      char *p;

      bi->seg = now_seg;
      bi->type = bes;
      bi->sym = label;
      p = frag_var (rs_machine_dependent, 
                    65536*2, 1, (relax_substateT) 0,
                    make_expr_symbol (&exp), (offsetT) 0, 
                    (char *) bi);
      if (p)
        *p = 0;

      return;
    }

  /* reduce the required size by any bit offsets currently left over
     from a previous .space/.bes/.field directive */
  bit_offset = frag_now->tc_frag_data;
  if (bit_offset != 0 && bit_offset < 16)
    {
      int spare_bits = bits_per_byte - bit_offset;
      if (spare_bits >= exp.X_add_number)
        {
          /* don't have to do anything; sufficient bits have already been
             allocated; just point the label to the right place */ 
          if (label != NULL)
            {
              symbol_set_frag (label, frag_now);
              S_SET_VALUE (label, frag_now_fix () - 1);
              label = NULL;
            }
          frag_now->tc_frag_data += exp.X_add_number;
          goto getout;
        }
      exp.X_add_number -= spare_bits;
      /* set the label to point to the first word allocated, which in this
         case is the previous word, which was only partially filled */
      if (!bes && label != NULL)
        {
          symbol_set_frag (label, frag_now);
          S_SET_VALUE (label, frag_now_fix () - 1);
          label = NULL;
        }
    }
  /* convert bits to bytes/words and octets, rounding up */
  words = ((exp.X_add_number + bits_per_byte - 1) / bits_per_byte);
  /* how many do we have left over? */
  bit_offset = exp.X_add_number % bits_per_byte;
  octets = words * OCTETS_PER_BYTE;
  if (octets < 0)
    {
      as_warn (_(".space/.bes repeat count is negative, ignored"));
      goto getout;
    }
  else if (octets == 0)
    {
      as_warn (_(".space/.bes repeat count is zero, ignored"));
      goto getout;
    }
  
  /* If we are in the absolute section, just bump the offset.  */
  if (now_seg == absolute_section)
    {
      abs_section_offset += words;
      if (bes && label != NULL)
        S_SET_VALUE (label, abs_section_offset - 1);
      frag_now->tc_frag_data = bit_offset;
      goto getout;
    }
  
  if (!need_pass_2)
    p = frag_var (rs_fill, 1, 1, 
                  (relax_substateT) 0, (symbolS *) 0, 
                  (offsetT) octets, (char *) 0);

  /* make note of how many bits of this word we've allocated so far */
  frag_now->tc_frag_data = bit_offset;

  /* .bes puts label at *last* word allocated */
  if (bes && label != NULL)
    {
      symbol_set_frag (label, frag_now);
      S_SET_VALUE (label, frag_now_fix ()-1);
    }
  
  if (p)
    *p = 0;

 getout:

  demand_empty_rest_of_line ();
}

/* [symbol] .usect "section-name", size-in-words 
                   [, [blocking-flag] [, alignment-flag]] 

   Unitialized section.
   Non-zero blocking means that if the section would cross a page (128-word)
   boundary, it will be page-aligned.
   Non-zero alignment aligns on a longword boundary.

   Has no effect on the current section.
*/
static void 
tic54x_usect (x)
  int x ATTRIBUTE_UNUSED;
{
  char c;
  char *name;
  char *section_name;
  char *p;
  segT seg;
  int size, blocking_flag, alignment_flag;
  segT current_seg;
  subsegT current_subseg;
  flagword flags;

  ILLEGAL_WITHIN_STRUCT ();

  current_seg = now_seg;	/* save current seg.  */
  current_subseg = now_subseg;	/* save current subseg.  */

  if (*input_line_pointer == '"')
    input_line_pointer++;
  section_name = input_line_pointer;
  c = get_symbol_end ();	/* Get terminator.  */
  input_line_pointer++;		/* Skip null symbol terminator.  */
  name = xmalloc (input_line_pointer - section_name + 1);
  strcpy (name, section_name);

  if (*input_line_pointer == ',')
    ++input_line_pointer;
  else if (c != ',')
    {
      as_bad (_("Missing size argument"));
      ignore_rest_of_line ();
      return;
    }

  size = get_absolute_expression ();

  /* read a possibly present third argument (blocking flag) */
  if (*input_line_pointer == ',')
    {
      ++input_line_pointer;
      if (*input_line_pointer != ',')
        blocking_flag = get_absolute_expression ();
      else
        blocking_flag = 0;

      /* read a possibly present fourth argument (alignment flag) */
      if (*input_line_pointer == ',')
        {
          ++input_line_pointer;
          alignment_flag = get_absolute_expression ();
        }
      else
        alignment_flag = 0;
    }
  else
    blocking_flag = alignment_flag = 0;

  seg = subseg_new (name, 0);
  flags = bfd_get_section_flags (stdoutput, seg) | SEC_ALLOC;

  if (alignment_flag)
    {
      /* s_align eats end of line; restore it */
      s_align_bytes (4);
      --input_line_pointer;
    }

  if (line_label != NULL)
    {
      S_SET_SEGMENT (line_label, seg);
      symbol_set_frag (line_label, frag_now);
      S_SET_VALUE (line_label, frag_now_fix ());
      /* set scl to label, since that's what TI does */
      if (S_GET_STORAGE_CLASS (line_label) != C_EXT)
        S_SET_STORAGE_CLASS (line_label, C_LABEL);
    }

  seg_info (seg)->bss = 1;	/* Uninitialized data.  */

  p = frag_var (rs_fill, 1, 1, 
                (relax_substateT) 0, (symbolS *) line_label,
                size * OCTETS_PER_BYTE, (char *) 0);
  *p = 0;

  if (blocking_flag)
    flags |= SEC_BLOCK;

  if (!bfd_set_section_flags (stdoutput, seg, flags))
    as_warn ("Error setting flags for \"%s\": %s", name,
	     bfd_errmsg (bfd_get_error ()));

  subseg_set (current_seg, current_subseg);	/* Restore current seg.  */
  demand_empty_rest_of_line ();
} 

static enum cpu_version
lookup_version (const char *ver)
{
  enum cpu_version version = VNONE;
  if (ver[0] == '5' && ver[1] == '4')
    {
      if (strlen (ver) == 3 &&
          (ver[2] == '1' || ver[2] == '2' || ver[2] == '3' ||
           ver[2] == '5' || ver[2] == '8' || ver[2] == '9'))
        version = ver[2] - '0';
      else if (strlen (ver) == 5 &&
               toupper (ver[3]) == 'L' &&
               toupper (ver[4]) == 'P' &&
               (ver[2] == '5' || ver[2] == '6'))
        version = ver[2] - '0' + 10;
    }

  return version;
}

static void
set_cpu (enum cpu_version version)
{
  cpu = version;
  if (version == V545LP || version == V546LP)
    {
      symbolS *symbolP = symbol_new ("__allow_lp", absolute_section,
                                    (valueT)1, &zero_address_frag);
      SF_SET_LOCAL (symbolP);
      symbol_table_insert (symbolP);
    }
}

/* .version cpu-version 
   cpu-version may be one of the following:
   541
   542
   543
   545
   545LP
   546LP
   548
   549

   This is for compatibility only.  It currently has no affect on assembly.

 */
static int cpu_needs_set = 1;
static void 
tic54x_version (x)
  int x ATTRIBUTE_UNUSED;
{
  enum cpu_version version = VNONE;
  enum cpu_version old_version = cpu;
  int c;
  char *ver;

  ILLEGAL_WITHIN_STRUCT ();

  SKIP_WHITESPACE ();
  ver = input_line_pointer;
  while (!is_end_of_line[(int)*input_line_pointer])
    ++input_line_pointer;
  c = *input_line_pointer;
  *input_line_pointer = 0;
  
  version = lookup_version (ver);

  if (cpu != VNONE && cpu != version)
    as_warn (_("CPU version has already been set"));

  if (version == VNONE)
    {
      as_bad (_("Unrecognized version '%s'"), ver);
      ignore_rest_of_line ();
      return;
    }
  else if (assembly_begun && version != old_version)
    {
      as_bad (_("Changing of CPU version on the fly not supported"));
      ignore_rest_of_line ();
      return;
    }

  set_cpu (version);

  *input_line_pointer = c;
  demand_empty_rest_of_line ();
}

/* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble */
static void
tic54x_float_cons (int type)
{
  if (current_stag != 0)
    {
      tic54x_struct_field ('f');
    }

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif
  /* align to long word boundary (4 octets) unless it's ".xfloat" */
  if (type != 'x')
    {
      frag_align (2, 0, 2);
      /* if there's a label, assign it to the first allocated word */
      if (line_label != NULL)
        {
          symbol_set_frag (line_label, frag_now);
          S_SET_VALUE (line_label, frag_now_fix ());
        }
    }

  float_cons ('f');
}

/* The argument is capitalized if it should be zero-terminated 
   's' is normal string with upper 8-bits zero-filled, 'p' is packed.
   Code copied from read.c, and slightly modified so that strings are packed
   and encoded into the correct octets.
*/
static void
tic54x_stringer (int type)
{
  register unsigned int c;
  char *start;
  int append_zero = type == 'S' || type == 'P';
  int packed = type == 'p' || type == 'P';
  int last_char = -1; /* packed strings need two bytes at a time to encode */

  if (current_stag != NULL)
    {
      tic54x_struct_field ('*');
      return;
    }

#ifdef md_flush_pending_output
  md_flush_pending_output ();
#endif

  c = ',';			/* Do loop. */
  while (c == ',')
    {
      SKIP_WHITESPACE ();
      switch (*input_line_pointer)
	{
        default:
          {
            unsigned short value = get_absolute_expression ();
            FRAG_APPEND_1_CHAR (value&0xFF);
            FRAG_APPEND_1_CHAR ((value>>8)&0xFF);
            break;
          }
	case '\"':
	  ++input_line_pointer;	/*->1st char of string. */
	  start = input_line_pointer;
	  while (is_a_char (c = next_char_of_string ()))
	    {
              if (!packed)
                {
                  FRAG_APPEND_1_CHAR (c);
                  FRAG_APPEND_1_CHAR (0);
                }
              else
                {
                  /* packed strings are filled MS octet first */
                  if (last_char == -1)
                    last_char = c;
                  else
                    {
                      FRAG_APPEND_1_CHAR (c);
                      FRAG_APPEND_1_CHAR (last_char);
                      last_char = -1;
                    }
                }
	    }
	  if (append_zero)
            {
              if (packed && last_char != -1)
                {
                  FRAG_APPEND_1_CHAR (0);
                  FRAG_APPEND_1_CHAR (last_char);
                  last_char = -1;
                }
              else
                {
                  FRAG_APPEND_1_CHAR (0);
                  FRAG_APPEND_1_CHAR (0);
                }
            }
	  know (input_line_pointer[-1] == '\"');
	  break;
	}
      SKIP_WHITESPACE ();
      c = *input_line_pointer;
      if (!is_end_of_line[c])
        ++input_line_pointer;
    }

  /* finish up any leftover packed string */
  if (packed && last_char != -1)
    {
      FRAG_APPEND_1_CHAR (0);
      FRAG_APPEND_1_CHAR (last_char);
    }
  demand_empty_rest_of_line ();
}

static void
tic54x_p2align (arg)
  int arg ATTRIBUTE_UNUSED;
{
  as_bad (_("p2align not supported on this target"));
}

static void
tic54x_align_words (int arg)
{
  /* only ".align" with no argument is allowed within .struct/.union */
  int count = arg;

  if (!is_end_of_line[(int)*input_line_pointer])
    {
      if (arg == 2)
        as_warn (_("Argument to .even ignored"));
      else
        count = get_absolute_expression ();
    }

  if (current_stag != NULL && arg == 128)
    {
      if (current_stag->current_bitfield_offset != 0)
        {
          current_stag->current_bitfield_offset = 0;
          ++abs_section_offset;
        }
      demand_empty_rest_of_line ();
      return;
    }

  ILLEGAL_WITHIN_STRUCT ();

  s_align_bytes (count << 1);
}

/* initialize multiple-bit fields withing a single word of memory 
 */
static void
tic54x_field (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  expressionS exp;
  int size = 16;
  char *p;
  valueT value;
  symbolS *label = line_label;

  if (current_stag != NULL)
    {
      tic54x_struct_field ('.');
      return;
    }

  input_line_pointer = parse_expression (input_line_pointer, &exp);

  if (*input_line_pointer == ',')
    {
      ++input_line_pointer;
      size = get_absolute_expression ();
      if (size < 1 || size > 32)
        {
          as_bad (_("Invalid field size, must be from 1 to 32"));
          ignore_rest_of_line ();
          return;
        }
    }

  /* truncate values to the field width */
  if (exp.X_op != O_constant)
    {
      /* if the expression value is relocatable, the field size *must* be 16 */
      if (size != 16)
        {
          as_bad (_("field size must be 16 when value is relocatable"));
          ignore_rest_of_line ();
          return;
        }

      frag_now->tc_frag_data = 0;
      emit_expr (&exp, 2);
    }
  else
    {
      unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1;
      value = exp.X_add_number;
      exp.X_add_number &= fmask;
      if (value != (valueT)exp.X_add_number)
        as_warn (_("field value truncated"));
      value = exp.X_add_number;
      /* bits are stored MS first */
      while (size >= 16)
        {
          frag_now->tc_frag_data = 0;
          p = frag_more (2);
          md_number_to_chars (p, (value >> (size - 16)) & 0xFFFF, 2);
          size -= 16;
        }
      if (size > 0)
        {
          int bit_offset = frag_bit_offset (frag_now, now_seg);
          fragS *alloc_frag = bit_offset_frag (frag_now, now_seg);
          if (bit_offset == -1)
            {
              struct bit_info *bi = xmalloc (sizeof (struct bit_info));
              /* we don't know the previous offset at this time, so store the
                 info we need and figure it out later */
              expressionS size_exp;
              size_exp.X_op = O_constant;
              size_exp.X_add_number = size;
              bi->seg = now_seg;
              bi->type = TYPE_FIELD;
              bi->value = value;
              p = frag_var (rs_machine_dependent,
                            4, 1, (relax_substateT) 0,
                            make_expr_symbol (&size_exp), (offsetT) 0,
                            (char *) bi);
              goto getout;
            }
          else if (bit_offset == 0 || bit_offset + size > 16)
            {
              /* align a new field */
              p = frag_more (2);
              frag_now->tc_frag_data = 0;
              alloc_frag = frag_now;
            }
          else
            {
              /* put the new value entirely within the existing one */
              p = alloc_frag == frag_now ? 
                frag_now->fr_literal + frag_now_fix_octets () - 2 :
                alloc_frag->fr_literal;
              if (label != NULL)
                {
                  symbol_set_frag (label, alloc_frag);
                  if (alloc_frag == frag_now)
                    S_SET_VALUE (label, frag_now_fix () - 1);
                  label = NULL;
                }
            }
          value <<= 16 - alloc_frag->tc_frag_data - size;

          /* OR in existing value */
          if (alloc_frag->tc_frag_data)
            value |= ((unsigned short)p[1]<<8) | p[0];
          md_number_to_chars (p, value, 2);
          alloc_frag->tc_frag_data += size;
          if (alloc_frag->tc_frag_data == 16)
            alloc_frag->tc_frag_data = 0;
        }
    }
 getout:
  demand_empty_rest_of_line ();
}

/* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't
   available yet.  seg_info ()->bss is the next best thing */
static int
tic54x_initialized_section (seg)
  segT seg;
{
  return !seg_info (seg)->bss;
}

/* .clink ["section name"] 

   Marks the section as conditionally linked (link only if contents are
   referenced elsewhere.
   Without a name, refers to the current initialized section.
   Name is required for uninitialized sections.

 */
static void
tic54x_clink (ignored)
  int ignored ATTRIBUTE_UNUSED;
{
  segT seg = now_seg;

  ILLEGAL_WITHIN_STRUCT ();

  if (*input_line_pointer == '\"')
    {
      char *section_name = ++input_line_pointer;
      char *name;
      while (is_a_char (next_char_of_string ()))
        ;
      know (input_line_pointer[-1] == '\"');
      input_line_pointer[-1] = 0;
      name = xmalloc (input_line_pointer - section_name + 1);
      strcpy (name, section_name);

      seg = bfd_get_section_by_name (stdoutput, name);
      if (seg == NULL)
        {
          as_bad (_("Unrecognized section '%s'"), section_name);
          ignore_rest_of_line ();
          return;
        }
    }
  else
    {
      if (!tic54x_initialized_section (seg))
        {
          as_bad (_("Current section is unitialized, "
                    "section name required for .clink"));
          ignore_rest_of_line ();
          return;
        }
    }

  seg->flags |= SEC_CLINK;

  demand_empty_rest_of_line ();
}

/* change the default include directory to be the current source file's
   directory, instead of the current working directory.  If DOT is non-zero,
   set to "." instead  */
static void
tic54x_set_default_include (dot)
  int dot;
{
  char *dir = ".";
  char *tmp = NULL;
  
  if (!dot)
    {
      char *curfile;
      unsigned lineno;
      
      as_where (&curfile, &lineno);
      dir = strcpy (xmalloc (strlen (curfile)+1), curfile);
      tmp = strrchr (dir, '/');
    }
  if (tmp != NULL)
    {
      int len;
      *tmp = '\0';
      len = strlen (dir);
      if (include_dir_count == 0)
        {
          include_dirs = (char **) xmalloc (sizeof (*include_dirs));
          include_dir_count = 1;
        }
      include_dirs[0] = dir;
      if (len > include_dir_maxlen)
        include_dir_maxlen = len;
    }
  else if (include_dirs != NULL)
    include_dirs[0] = ".";
}

/* 
   .include "filename" | filename 
   .copy    "filename" | filename

   FIXME 'include' file should be omitted from any output listing, 
     'copy' should be included in any output listing
   FIXME -- prevent any included files from changing listing (compat only)
   FIXME -- need to include source file directory in search path; what's a
      good way to do this?

   Entering/exiting included/copied file clears all local labels
*/
static void
tic54x_include (ignored)
  int ignored ATTRIBUTE_UNUSED;
{
  char newblock[] = " .newblock\n";
  char *filename;
  char *input;
  int len, c = -1;

  ILLEGAL_WITHIN_STRUCT ();
  
  SKIP_WHITESPACE ();

  if (*input_line_pointer == '"')
    {
      filename = demand_copy_C_string (&len);
      demand_empty_rest_of_line ();
    }
  else
    {
      filename = input_line_pointer;
      while (!is_end_of_line[(int)*input_line_pointer])
        ++input_line_pointer;
      c = *input_line_pointer;
      *input_line_pointer = '\0';
      filename = strcpy (xmalloc (strlen (filename)+1), filename);
      *input_line_pointer = c;
      demand_empty_rest_of_line ();
    }
  /* Insert a partial line with the filename (for the sake of s_include)
     and a .newblock.
     The included file will be inserted before the newblock, so that the
     newblock is executed after the included file is processed */
  input = xmalloc (sizeof (newblock) + strlen (filename) + 4);
  sprintf (input, "\"%s\"\n%s", filename, newblock);
  input_scrub_insert_line (input);

  tic54x_clear_local_labels (0);

  tic54x_set_default_include (0);

  s_include (0);
}

static void
tic54x_message (int type)
{
  char *msg;
  char c;
  int len;

  ILLEGAL_WITHIN_STRUCT ();

  if (*input_line_pointer == '"')
    msg = demand_copy_C_string (&len);
  else
    {
      msg = input_line_pointer;
      while (! is_end_of_line[(int)*input_line_pointer])
        ++input_line_pointer;
      c = *input_line_pointer;
      *input_line_pointer = 0;
      msg = strcpy (xmalloc (strlen (msg) + 1), msg);
      *input_line_pointer = c;
    }

  switch (type)
    {
    case 'm':
      as_tsktsk ("%s", msg);
      break;
    case 'w':
      as_warn ("%s", msg);
      break;
    case 'e':
      as_bad ("%s", msg);
      break;
    }

  demand_empty_rest_of_line ();
}

/* .label <symbol> 
   define a special symbol that refers to the loadtime address rather than the
   runtime address within the current section.

   This symbol gets a special storage class so that when it is resolved, it is
   resolved relative to the load address (lma) of the section rather than the
   run address (vma)
 */
static void
tic54x_label (ignored)
  int ignored ATTRIBUTE_UNUSED;
{
  char *name = input_line_pointer;
  symbolS *symbolP;
  int c;

  ILLEGAL_WITHIN_STRUCT ();

  c = get_symbol_end ();
  symbolP = colon (name);
  S_SET_STORAGE_CLASS (symbolP, C_STATLAB);

  *input_line_pointer = c;
  demand_empty_rest_of_line ();
}

/*
  .mmregs
  install all memory-mapped register names into the symbol table as absolute
  local symbols.
 */
static void
tic54x_mmregs (ignored)
  int ignored ATTRIBUTE_UNUSED;
{
  symbol *sym;

  ILLEGAL_WITHIN_STRUCT ();

  for (sym = (symbol *)mmregs; sym->name; sym++)
    {
      symbolS *symbolP = symbol_new (sym->name, absolute_section,
                                     (valueT) sym->value, &zero_address_frag);
      SF_SET_LOCAL (symbolP);
      symbol_table_insert (symbolP);
    }
}

/*
  .loop [count]
  count defaults to 1024
 */
static void
tic54x_loop (int count)
{
  ILLEGAL_WITHIN_STRUCT ();

  SKIP_WHITESPACE ();
  if (!is_end_of_line[(int)*input_line_pointer])
      count = get_absolute_expression ();

  do_repeat (count, "LOOP", "ENDLOOP");
}

/* normally, endloop gets eaten by the preceding loop */
static void
tic54x_endloop (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  as_bad (_("ENDLOOP without corresponding LOOP"));
  ignore_rest_of_line ();
}

/*
  .break [condition]
*/
static void
tic54x_break (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  int cond = 1;

  ILLEGAL_WITHIN_STRUCT ();

  SKIP_WHITESPACE ();
  if (!is_end_of_line[(int)*input_line_pointer])
    {
      cond = get_absolute_expression ();
    }
  if (cond)
    {
      end_repeat (substitution_line ? 1 : 0);
    }
}

static void
set_address_mode (mode)
  int mode;
{
  amode = mode;
  if (mode == far_mode)
    {
      symbolS *symbolP = symbol_new ("__allow_far", absolute_section, 
                                    (valueT)1, &zero_address_frag);
      SF_SET_LOCAL (symbolP);
      symbol_table_insert (symbolP);
    }
}

static int address_mode_needs_set = 1;
static void
tic54x_address_mode (mode)
  int mode;
{
  if (assembly_begun && amode != (unsigned)mode)
    {
      as_bad (_("Mixing of normal and extended addressing not supported"));
      ignore_rest_of_line ();
      return;
    }
  if (mode == far_mode && cpu != VNONE && cpu != V548 && cpu != V549)
    {
      as_bad (_("Extended addressing not supported on the specified CPU"));
      ignore_rest_of_line ();
      return;
    }

  set_address_mode (mode);
  demand_empty_rest_of_line ();
}

/* .sblock "section"|section [,...,"section"|section]
   designate initialized sections for blocking
 */
static void
tic54x_sblock (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  int c = ',';

  ILLEGAL_WITHIN_STRUCT ();

  while (c == ',')
    {
      segT seg;
      char *name;
      
      if (*input_line_pointer == '"')
        {
          int len;
          name = demand_copy_C_string (&len);
        }
      else
        {
          char *section_name = input_line_pointer;
          c = get_symbol_end ();
          name = xmalloc (strlen (section_name)+1);
          strcpy (name, section_name);
          *input_line_pointer = c;
        }

      seg = bfd_get_section_by_name (stdoutput, name);
      if (seg == NULL)
        {
          as_bad (_("Unrecognized section '%s'"), name);
          ignore_rest_of_line ();
          return;
        }
      else if (!tic54x_initialized_section (seg))
        {
          as_bad (_(".sblock may be used for initialized sections only"));
          ignore_rest_of_line ();
          return;
        }
      seg->flags |= SEC_BLOCK;

      c = *input_line_pointer;
      if (!is_end_of_line[(int)c])
        ++input_line_pointer;
    }

  demand_empty_rest_of_line ();
}

/* symbol .set value
   symbol .equ value 

   value must be defined externals; no forward-referencing allowed
   symbols assigned with .set/.equ may not be redefined
*/
static void
tic54x_set (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  symbolS *symbolP;
  char *name;

  ILLEGAL_WITHIN_STRUCT ();

  if (!line_label)
    {
      as_bad (_("Symbol missing for .set/.equ"));
      ignore_rest_of_line ();
      return;
    }
  name = xstrdup (S_GET_NAME (line_label));
  line_label = NULL;
  if ((symbolP = symbol_find (name)) == NULL
      && (symbolP = md_undefined_symbol (name)) == NULL)
    {
      symbolP = symbol_new (name, absolute_section, 0, &zero_address_frag);
      S_SET_STORAGE_CLASS (symbolP, C_STAT);
    }
  free (name);
  S_SET_DATA_TYPE (symbolP, T_INT);
  S_SET_SEGMENT (symbolP, absolute_section);
  symbol_table_insert (symbolP);
  pseudo_set (symbolP);
  demand_empty_rest_of_line ();
}

/* .fclist
   .fcnolist
   list false conditional blocks
*/
static void
tic54x_fclist (int show)
{
  if (show)
    listing &= ~LISTING_NOCOND;
  else
    listing |= LISTING_NOCOND;
  demand_empty_rest_of_line ();
}

static void
tic54x_sslist (int show)
{
  ILLEGAL_WITHIN_STRUCT ();

  listing_sslist = show;
}

/* .var SYM[,...,SYMN] 
   define a substitution string to be local to a macro
*/
static void
tic54x_var (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  static char empty[] = "";
  char *name;
  int c;

  ILLEGAL_WITHIN_STRUCT ();

  if (macro_level == 0)
    {
      as_bad (_(".var may only be used within a macro definition"));
      ignore_rest_of_line ();
      return;
    }
  do 
    {
      if (!isalpha (*input_line_pointer))
        {
          as_bad (_("Substitution symbols must begin with a letter"));
          ignore_rest_of_line ();
          return;
        }
      name = input_line_pointer;
      c = get_symbol_end ();
      /* .var symbols start out with a null string */
      name = strcpy (xmalloc (strlen (name)+1), name);
      hash_insert (subsym_hash[macro_level], name, empty);
      *input_line_pointer = c;
      if (c == ',')
        {
          ++input_line_pointer;
          if (is_end_of_line[(int)*input_line_pointer])
            c = *input_line_pointer;
        }
    }
  while (c == ',');

  demand_empty_rest_of_line ();
}

/* .mlib <macro library filename> 

   Macro libraries are archived (standard AR-format) text macro definitions
   Expand the file and include it.

   FIXME need to try the source file directory as well
 */
static void
tic54x_mlib (ignore)
  int ignore ATTRIBUTE_UNUSED;
{
  char *filename;
  char *path;
  int len, i;
  bfd *abfd, *mbfd;

  ILLEGAL_WITHIN_STRUCT ();

  /* parse the filename */
  if (*input_line_pointer == '"')
    {
      if ((filename = demand_copy_C_string (&len)) == NULL)
        return;
    }
  else
    {
      SKIP_WHITESPACE ();
      len = 0;
      while (! is_end_of_line[(int)*input_line_pointer]
             && !isspace (*input_line_pointer))
        {
          obstack_1grow (&notes, *input_line_pointer);
          ++input_line_pointer;
          ++len;
        }
      obstack_1grow (&notes, '\0');
      filename = obstack_finish (&notes);
    }
  demand_empty_rest_of_line ();

  tic54x_set_default_include (0);
  path = xmalloc ((unsigned long) len + include_dir_maxlen + 5);
  for (i=0;i < include_dir_count; i++)
    {
      FILE *try;
      strcpy (path, include_dirs[i]);
      strcat (path, "/");
      strcat (path, filename);
      if ((try = fopen (path, "r")) != NULL)
        {
          fclose (try);
          break;
        }
  }
  if (i >= include_dir_count)
    {
      free (path);
      path = filename;
    }

  /* FIXME: if path is found, malloc'd storage is not freed.  Of course, this
     happens all over the place, and since the assembler doesn't usually keep
     running for a very long time, it really doesn't matter... */ 
  register_dependency (path);

  /* expand all archive entries to temporary files and include them */
  abfd = bfd_openr (path, NULL);
  if (!abfd)
    {
      as_bad (_("Can't open macro library file '%s' for reading."), path);
      as_perror ("%s", path);
      ignore_rest_of_line ();
      return;
    }
  if (!bfd_check_format (abfd, bfd_archive))
    {
      as_bad (_("File '%s' not in macro archive format"), path);
      ignore_rest_of_line ();
      return;
    }

  /* open each BFD as binary (it should be straight ASCII text) */
  for (mbfd = bfd_openr_next_archived_file (abfd, NULL);
       mbfd != NULL; mbfd = bfd_openr_next_archived_file (abfd, mbfd))
    {
      /* get a size at least as big as the archive member */
      bfd_size_type size = bfd_get_size (mbfd);
      char *buf = xmalloc (size);
      char *fname = tmpnam (NULL);
      FILE *ftmp;

      /* we're not sure how big it is, but it will be smaller than "size" */
      bfd_read (buf, size, 1, mbfd);

      /* write to a temporary file, then use s_include to include it 
         a bit of a hack...
       */
      ftmp = fopen (fname, "w+b");
      fwrite ((void *)buf, size, 1, ftmp);
      if (buf[size-1] != '\n')
        fwrite ("\n", 1, 1, ftmp);
      fclose (ftmp);
      free (buf);
      input_scrub_insert_file (fname);
      unlink (fname);
    }
}

const pseudo_typeS md_pseudo_table[] = 
{
  { "algebraic", s_ignore, 0 },
  { "align", tic54x_align_words, 128 }, 
  { "even", tic54x_align_words, 2 }, 
  { "asg", tic54x_asg, 0 },
  { "eval", tic54x_eval, 0 },
  { "bss", tic54x_bss, 0 },
  { "byte", tic54x_cons, 'b' },
  { "ubyte", tic54x_cons, 'B' },
  { "char", tic54x_cons, 'c' },
  { "uchar", tic54x_cons, 'C' },
  { "clink", tic54x_clink, 0 },
  { "c_mode", tic54x_address_mode, c_mode },
  { "copy", tic54x_include, 'c' },
  { "include", tic54x_include, 'i' },
  { "data", tic54x_sect, 'd' },
  { "double", tic54x_float_cons, 'd' },
  { "ldouble", tic54x_float_cons, 'l' },
  { "drlist", s_ignore, 0 },
  { "drnolist", s_ignore, 0 },
  { "emsg", tic54x_message, 'e' },
  { "mmsg", tic54x_message, 'm' },
  { "wmsg", tic54x_message, 'w' },
  /*{ "end",     s_end,                   0 }, */
  { "far_mode", tic54x_address_mode, far_mode }, 
  { "fclist",   tic54x_fclist, 1 },
  { "fcnolist", tic54x_fclist, 0 },
  { "field", tic54x_field, -1 },
  { "float", tic54x_float_cons, 'f' },
  { "xfloat",  tic54x_float_cons, 'x' },
  { "global", tic54x_global, 'g' },
  { "def", tic54x_global, 'd' },
  { "ref", tic54x_global, 'r' },
  { "half", tic54x_cons, 'h' },
  { "uhalf", tic54x_cons, 'H' },
  { "short", tic54x_cons, 's' },
  { "ushort", tic54x_cons, 'S' },
  { "if", s_if, (int)O_ne },
  { "elseif", s_elseif, (int)O_ne },
  { "else", s_else, 0 },
  { "endif", s_endif, 0 },
  { "int", tic54x_cons, 'i' },
  { "uint", tic54x_cons, 'I' },
  { "word", tic54x_cons, 'w' },
  { "uword", tic54x_cons, 'W' },
  { "label", tic54x_label, 0 }, /* loadtime address */
  { "length",   s_ignore, 0 }, 
  { "width",    s_ignore, 0 }, 
  /*{ "list",     listing_list,      1 }, */
  /*{ "nolist",   listing_list,      0 }, */
  { "long", tic54x_cons, 'l' }, 
  { "ulong", tic54x_cons, 'L' }, 
  { "xlong", tic54x_cons, 'x' }, 
  { "loop", tic54x_loop, 1024 }, 
  { "break", tic54x_break, 0 }, 
  { "endloop", tic54x_endloop, 0 }, 
  { "mlib", tic54x_mlib, 0 }, 
  { "mlist",     s_ignore, 0 }, 
  { "mnolist",     s_ignore, 0 }, 
  { "mmregs", tic54x_mmregs, 0 }, 
  { "newblock", tic54x_clear_local_labels, 0 }, 
  { "option",     s_ignore, 0 }, 
  { "p2align", tic54x_p2align, 0 },
  /*{ "page",     listing_eject,      0 }, */
  { "sblock", tic54x_sblock, 0 }, 
  { "sect", tic54x_sect, '*' }, 
  { "set", tic54x_set, 0 }, 
  { "equ", tic54x_set, 0 }, 
  { "space", tic54x_space, 0 }, 
  { "bes", tic54x_space, 1 }, 
  { "sslist", tic54x_sslist, 1 }, 
  { "ssnolist", tic54x_sslist, 0 }, 
  { "string", tic54x_stringer, 's' },
  { "pstring", tic54x_stringer, 'p' },
  { "struct", tic54x_struct, 0 }, 
  { "tag", tic54x_tag, 0 }, 
  { "endstruct", tic54x_endstruct, 0 }, 
  { "tab",     s_ignore, 0 }, 
  { "text", tic54x_sect, 't' }, 
  /*{ "title",     listing_title,      0 }, */
  { "union", tic54x_struct, 1 }, 
  { "endunion", tic54x_endstruct, 1 }, 
  { "usect", tic54x_usect, 0 }, 
  { "var", tic54x_var, 0 }, 
  { "version", tic54x_version, 0 }, 
  {0, 0, 0}
};

/* for debugging, strings for each operand type */
#if 0
static const char *optypes[] = 
{
  "none", "Xmem", "Ymem", "pmad", "dmad", "Smem", "Lmem", "MMR", "PA",
  "Sind", "xpmad", "xpmad+", "MMRX", "MMRY", 
  "SRC1", "SRC", "RND", "DST", 
  "ARX", 
  "SHIFT", "SHFT",
  "B", "A", "lk", "TS", "k8", "16", "BITC", "CC", "CC2", "CC3", "123", "031", 
  "k5", "k8u", "ASM", "T", "DP", "ARP", "k3", "lku", "N", "SBIT", "12",
  "k9", "TRN",
};
#endif

int
md_parse_option (c, arg)
  int c;
  char *arg;
{
  switch (c)
    {
    default:
      return 0;
    case OPTION_COFF_VERSION:
      {
        int version = atoi (arg);
        if (version != 0 && version != 1 && version != 2)
          as_fatal (_("Bad COFF version '%s'"), arg);
        /* FIXME -- not yet implemented */
        break;
      }
    case OPTION_CPU_VERSION:
      {
        cpu = lookup_version (arg);
        cpu_needs_set = 1;
        if (cpu == VNONE)
          as_fatal (_("Bad CPU version '%s'"), arg);
        break;
      }
    case OPTION_ADDRESS_MODE:
      amode = far_mode;
      address_mode_needs_set = 1;
      break;
    case OPTION_STDERR_TO_FILE:
      {
        char *filename = arg;
        FILE *fp = fopen (filename, "w+");
        if (fp == NULL)
          as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
        fclose (fp);
        if ((fp = freopen (filename, "w+", stderr)) == NULL)
          as_fatal (_("Can't redirect stderr to the file '%s'"), filename);
        break;
      }
    }

  return 1;
}

/* create a "local" substitution string hash table for a new macro level 
   Some docs imply that macros have to use .newblock in order to be able
   to re-use a local label.  We effectively do an automatic .newblock by
   deleting the local label hash between macro invocations.
 */
void 
tic54x_macro_start ()
{
  ++macro_level;
  subsym_hash[macro_level] = hash_new ();
  local_label_hash[macro_level] = hash_new ();
}

void
tic54x_macro_info (void *info)
{
  struct formal_struct
  {
    struct formal_struct *next;	/* next formal in list */
    sb name;			/* name of the formal */
    sb def;			/* the default value */
    sb actual;			/* the actual argument (changed on each expansion) */
    int index;			/* the index of the formal 0..formal_count-1 */
  } *entry;
  struct macro_struct
  {
    sb sub;			/* substitution text. */
    int formal_count;		/* number of formal args. */
    struct formal_struct *formals;	/* pointer to list of formal_structs */
    struct hash_control *formal_hash; /* hash table of formals. */
  } *macro;

  macro = (struct macro_struct *)info;

  /* put the formal args into the substitution symbol table */
  for (entry = macro->formals; entry; entry = entry->next)
    {
      char *name = strncpy (xmalloc (entry->name.len + 1),
                            entry->name.ptr, entry->name.len);
      char *value = strncpy (xmalloc (entry->actual.len + 1),
                             entry->actual.ptr, entry->actual.len);
      name[entry->name.len] = '\0';
      value[entry->actual.len] = '\0';
      hash_insert (subsym_hash[macro_level], name, value);
    }
}

/* get rid of this macro's .var's, arguments, and local labels */
void
tic54x_macro_end ()
{
  hash_die (subsym_hash[macro_level]);
  subsym_hash[macro_level] = NULL;
  hash_die (local_label_hash[macro_level]);
  local_label_hash[macro_level] = NULL;
  --macro_level;
}

static int
subsym_symlen (a, ignore)
  char *a;
  char *ignore ATTRIBUTE_UNUSED;
{
  return strlen (a);
}

/* compare symbol A to string B */
static int
subsym_symcmp (char *a, char *b)
{
  return strcmp (a, b);
}

/* return the index of the first occurence of B in A, or zero if none 
   assumes b is an integer char value as a string.  index is one-based */
static int
subsym_firstch (char *a, char *b)
{
  int val = atoi (b);
  char *tmp = strchr (a, val);
  
  return tmp ? tmp - a + 1 : 0;
}

/* similar to firstch, but returns index of last occurrence of B in A */
static int
subsym_lastch (a, b)
  char *a;
  char *b;
{
  int val = atoi (b);
  char *tmp = strrchr (a, val);

  return tmp ? tmp - a + 1 : 0;
}

/* returns 1 if string A is defined in the symbol table (NOT the substitution
   symbol table) */
static int
subsym_isdefed (a, ignore)
  char *a;
  char *ignore ATTRIBUTE_UNUSED;
{
  symbolS *symbolP = symbol_find (a);

  return symbolP != NULL;
}

/* assign first member of comma-separated list B (e.g. "1,2,3") to the symbol
   A, or zero if B is a null string.  Both arguments *must* be substitution
   symbols, unsubstituted  */
static int
subsym_ismember (char *symbol, char *list)
{
  char *elem, *ptr, *listv;

  if (!list)
    return 0;

  listv = subsym_lookup (list, macro_level);
  if (!listv)
    {
      as_bad (_("Undefined substitution symbol '%s'"), list);
      ignore_rest_of_line ();
      return 0;
    }

  ptr = elem = xmalloc (strlen (listv)+1);
  strcpy (elem, listv);
  while (*ptr && *ptr != ',')
    ++ptr;
  *ptr++ = 0;

  subsym_create_or_replace (symbol, elem);

  /* reassign the list */
  subsym_create_or_replace (list, ptr);
  
  /* assume this value, docs aren't clear */
  return *list != 0;
}

/* return zero if not a constant; otherwise:
   1 if binary
   2 if octal
   3 if hexadecimal
   4 if character
   5 if decimal
*/
static int
subsym_iscons (a, ignore)
  char *a;
  char *ignore ATTRIBUTE_UNUSED;
{
  expressionS exp;

  parse_expression (a, &exp);

  if (exp.X_op == O_constant)
    {
      int len = strlen (a);

      switch (toupper (a[len-1]))
        {
        case 'B':
          return 1;
        case 'Q':
          return 2;
        case 'H':
          return 3;
        case '\'':
          return 4;
        default:
          break;
        }
      /* no suffix; either octal, hex, or decimal */
      if (*a == '0' && len > 1)
        {
          if (toupper (a[1]) == 'X')
            return 3;
          return 2;
        }
      return 5;
    }

  return 0;
}

/* return 1 if A is a valid symbol name.  Expects string input   */
static int
subsym_isname (a, ignore)
  char *a;
  char *ignore ATTRIBUTE_UNUSED;
{
  if (!is_name_beginner (*a))
    return 0;
  while (*a)
    {
      if (!is_part_of_name (*a))
        return 0;
      ++a;
    }
  return 1;
}

/* return whether the string is a register; accepts ar0-7, unless .mmregs has
   been seen; if so, recognize any memory-mapped register.
   Note this does not recognize "A" or "B" accumulators */
static int
subsym_isreg (a, ignore)
  char *a;
  char *ignore ATTRIBUTE_UNUSED;
{
  if (hash_find (reg_hash, a))
    return 1;
  if (hash_find (mmreg_hash, a))
    return 1;
  return 0;
}

/* Return the structrure size, given the stag */
static int
subsym_structsz (name, ignore)
  char *name;
  char *ignore ATTRIBUTE_UNUSED;
{
  struct stag *stag = (struct stag *)hash_find (stag_hash, name);
  if (stag)
    return stag->size;

  return 0;
}

/* If anybody actually uses this, they can fix it :)
   FIXME I'm not sure what the "reference point" of a structure is.  It might
   be either the initial offset given .struct, or it may be the offset of the
   structure within another structure, or it might be something else
   altogether.  since the TI assembler doesn't seem to ever do anything but
   return zero, we punt and return zero.
 */
static int
subsym_structacc (stag_name, ignore)
  char *stag_name ATTRIBUTE_UNUSED;
  char *ignore ATTRIBUTE_UNUSED;
{
  return 0;
}

static float
math_ceil (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)ceil (arg1);
}
static float
math_cvi (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (int)arg1;
}
static float
math_floor (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)floor (arg1);
}
static float
math_fmod (float arg1, float arg2)
{
  return (int)arg1 % (int)arg2;
}
static float
math_int (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return ((float)((int)arg1)) == arg1;
}
static float
math_round (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return arg1 > 0 ? (int)(arg1 + 0.5) : (int)(arg1 - 0.5);
}
static float
math_sgn (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (arg1 < 0) ? -1 : (arg1 ? 1 : 0);
}
static float
math_trunc (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (int)arg1;
}

static float
math_acos (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)acos (arg1);
}
static float
math_asin (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)asin (arg1);
}
static float
math_atan (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)atan (arg1);
}
static float
math_atan2(float arg1, float arg2)
{
  return (float)atan2 (arg1, arg2);
}
static float
math_cosh (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)cosh (arg1);
}
static float
math_cos (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)cos (arg1);
}
static float
math_cvf (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)arg1;
}
static float
math_exp (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)exp (arg1);
}
static float
math_fabs (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)fabs (arg1);
}
/* expr1 * 2^expr2 */
static float
math_ldexp (float arg1, float arg2)
{
  return arg1 * (float)pow (2.0, arg2);
}
static float
math_log10 (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)log10 (arg1);
}
static float
math_log (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)log (arg1);
}
static float
math_max (float arg1, float arg2)
{
  return (arg1 > arg2) ? arg1 : arg2;
}
static float
math_min (float arg1, float arg2)
{
  return (arg1 < arg2) ? arg1 : arg2;
}
static float
math_pow (float arg1, float arg2)
{
  return (float)pow (arg1, arg2);
}
static float
math_sin (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)sin (arg1);
}
static float
math_sinh (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)sinh (arg1);
}
static float
math_sqrt (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)sqrt (arg1);
}
static float
math_tan (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)tan (arg1);
}
static float
math_tanh (arg1, ignore)
  float arg1;
  float ignore ATTRIBUTE_UNUSED;
{
  return (float)tanh (arg1);
}

/* built-in substitution symbol functions and math functions */
typedef struct 
{
  char *name;
  int (*proc)(char *, char *);
  int nargs;
} subsym_proc_entry;

static const subsym_proc_entry subsym_procs[] = {
  /* assembler built-in string substitution functions */
  { "$symlen", subsym_symlen, 1,  },
  { "$symcmp", subsym_symcmp, 2,  },
  { "$firstch", subsym_firstch, 2,  },
  { "$lastch", subsym_lastch, 2,  },
  { "$isdefed", subsym_isdefed, 1,  },
  { "$ismember", subsym_ismember, 2,  },
  { "$iscons", subsym_iscons, 1,  },
  { "$isname", subsym_isname, 1,  },
  { "$isreg", subsym_isreg, 1,  },
  { "$structsz", subsym_structsz, 1,  },
  { "$structacc", subsym_structacc, 1,  },
  { NULL, NULL, 0 },
};

typedef struct
{
  char *name;
  float (*proc)(float, float);
  int nargs;
  int int_return;
} math_proc_entry;

static const math_proc_entry math_procs[] = {
  /* integer-returning built-in math functions */
  { "$cvi", math_cvi, 1, 1 },
  { "$int", math_int, 1, 1 },
  { "$sgn", math_sgn, 1, 1 },

  /* float-returning built-in math functions */
  { "$acos", math_acos, 1, 0 },
  { "$asin", math_asin, 1, 0 },
  { "$atan", math_atan, 1, 0 },
  { "$atan2", math_atan2, 2, 0 }, 
  { "$ceil", math_ceil, 1, 0 },
  { "$cosh", math_cosh, 1, 0 },
  { "$cos", math_cos, 1, 0 },
  { "$cvf", math_cvf, 1, 0 },
  { "$exp", math_exp, 1, 0 },
  { "$fabs", math_fabs, 1, 0 },
  { "$floor", math_floor, 1, 0 },
  { "$fmod", math_fmod, 2, 0 },
  { "$ldexp", math_ldexp, 2, 0 },
  { "$log10", math_log10, 1, 0 },
  { "$log", math_log, 1, 0 },
  { "$max", math_max, 2, 0 },
  { "$min", math_min, 2, 0 },
  { "$pow", math_pow, 2, 0 },
  { "$round", math_round, 1, 0 },
  { "$sin", math_sin, 1, 0 },
  { "$sinh", math_sinh, 1, 0 },
  { "$sqrt", math_sqrt, 1, 0 },
  { "$tan", math_tan, 1, 0 },
  { "$tanh", math_tanh, 1, 0 },
  { "$trunc", math_trunc, 1, 0 },
  { NULL, NULL, 0, 0 },
};

void
md_begin ()
{
  template *opcode;
  partemplate *paropcode;
  symbol *sym;
  const subsym_proc_entry *subsym_proc;
  const math_proc_entry *math_proc;
  const char *hash_err;
  char **symname;
  char *TIC54X_DIR = getenv ("TIC54X_DIR");
  char *A_DIR = TIC54X_DIR ? TIC54X_DIR : getenv ("A_DIR");

  local_label_id = 0;

  /* look for A_DIR and add it to the include list */
  if (A_DIR != NULL)
    {
      char *tmp = xstrdup (A_DIR);
      do {
        char *next = strchr (tmp, ';');
        if (next)
          *next++ = '\0';
        add_include_dir (tmp);
        tmp = next;
      } while (tmp != NULL);
    }

  op_hash = hash_new ();
  for (opcode=(template *)tic54x_optab; opcode->name; opcode++)
    {
      if (hash_find (op_hash, opcode->name))
        continue;
      hash_err = hash_insert (op_hash, opcode->name, (char *)opcode);
      if (hash_err)
        as_fatal ("Internal Error: Can't hash %s: %s", 
                  opcode->name, hash_err);
    }
  parop_hash = hash_new ();
  for (paropcode=(partemplate *)tic54x_paroptab; paropcode->name; paropcode++)
    {
      if (hash_find (parop_hash, paropcode->name))
        continue;
      hash_err = hash_insert (parop_hash, paropcode->name, (char *)paropcode);
      if (hash_err)
        as_fatal ("Internal Error: Can't hash %s: %s", 
                  paropcode->name, hash_err);
    }
  reg_hash = hash_new ();
  for (sym = (symbol *)regs; sym->name; sym++)
    {
      /* add basic registers to the symbol table */
      symbolS *symbolP = symbol_new (sym->name, absolute_section,
                                     (valueT)sym->value, &zero_address_frag);
      SF_SET_LOCAL (symbolP);
      symbol_table_insert (symbolP);
      hash_err = hash_insert (reg_hash, sym->name, (char *)sym);
    }
  for (sym = (symbol *)mmregs; sym->name; sym++)
    hash_err = hash_insert (reg_hash, sym->name, (char *)sym);
  mmreg_hash = hash_new ();
  for (sym = (symbol *)mmregs; sym->name; sym++)
    {
      hash_err = hash_insert (mmreg_hash, sym->name, (char *)sym);
    }
  cc_hash = hash_new ();
  for (sym = (symbol *)condition_codes; sym->name; sym++)
    {
      hash_err = hash_insert (cc_hash, sym->name, (char *)sym);
    }
  cc2_hash = hash_new ();
  for (sym = (symbol *)cc2_codes; sym->name; sym++)
    {
      hash_err = hash_insert (cc2_hash, sym->name, (char *)sym);
    }
  cc3_hash = hash_new ();
  for (sym = (symbol *)cc3_codes; sym->name; sym++)
    {
      hash_err = hash_insert (cc3_hash, sym->name, (char *)sym);
    }
  sbit_hash = hash_new ();
  for (sym = (symbol *)status_bits; sym->name; sym++)
    {
      hash_err = hash_insert (sbit_hash, sym->name, (char *)sym);
    }
  misc_symbol_hash = hash_new ();
  for (symname = (char **)misc_symbols; *symname; symname++)
    {
      hash_err = hash_insert (misc_symbol_hash, *symname, *symname);
    }
  /* only the base substitution table and local label table are initialized;
     the others (for local macro substitution) get instantiated as needed */
  local_label_hash[0] = hash_new ();
  subsym_hash[0] = hash_new ();
  for (subsym_proc = subsym_procs; subsym_proc->name; subsym_proc++)
    {
      hash_err = hash_insert (subsym_hash[0], subsym_proc->name, 
                              (char *)subsym_proc);
    }
  math_hash = hash_new ();
  for (math_proc = math_procs; math_proc->name; math_proc++)
    {
      /* insert into the main subsym hash for recognition; insert into
         the math hash to actually store information */
      hash_err = hash_insert (subsym_hash[0], math_proc->name,
                              (char *)math_proc);
      hash_err = hash_insert (math_hash, math_proc->name,
                              (char *)math_proc);
    }
  subsym_recurse_hash = hash_new ();
  stag_hash = hash_new ();
}

typedef struct _tic54x_insn {
  const template *tm;               /* opcode template */
  const partemplate *ptm;           /* parallel opcode template */

  char mnemonic[MAX_LINE];          /* opcode name/mnemonic */
  char parmnemonic[MAX_LINE];       /* 2nd mnemonic of parallel insn */

  int opcount;
  struct opstruct {
    char buf[MAX_LINE];
    enum optype type;
    expressionS exp;
  } operands[MAX_OPERANDS];

  int paropcount;
  struct opstruct paroperands[MAX_OPERANDS];

  int is_lkaddr;
  int lkoperand;
  int words;                        /* size of insn in 16-bit words */
  int using_default_dst;            /* do we need to explicitly set an 
                                       omitted OP_DST operand? */
  struct {
    unsigned short word;            /* final encoded opcode data */
    int unresolved;
    int r_nchars;                     /* relocation size */
    bfd_reloc_code_real_type r_type; /* relocation type */
    expressionS addr_expr;          /* storage for unresolved expressions */
  } opcode[3];
} tic54x_insn;

static int encode_operand (tic54x_insn *, enum optype, struct opstruct *);
static int encode_dmad (tic54x_insn *, struct opstruct *, int);
static int operands_match (tic54x_insn *, struct opstruct *, int, 
                           const enum optype *, int, int);
static int encode_address (tic54x_insn *, struct opstruct *);

static int
is_accumulator (struct opstruct *operand)
{
  return strcasecmp (operand->buf, "a") == 0 
    || strcasecmp (operand->buf, "b") == 0;
}

/* return the number of operands found, or -1 on error, copying the operands
   into the given array and the accompanying expressions into the next array */
static int
get_operands (operands, line)
  struct opstruct operands[];
  char *line;
{
  char *lptr = line;
  int numexp = 0;
  int expecting_operand = 0;
  int i;

  while (numexp < MAX_OPERANDS && !is_end_of_line[(int)*lptr])
    {
      int paren_not_balanced = 0;
      char *op_start, *op_end;
      while (*lptr && isspace (*lptr))
        ++lptr;
      op_start = lptr;
      while (paren_not_balanced || *lptr != ',')
        {
          if (*lptr == '\0')
            {
              if (paren_not_balanced)
                {
                  as_bad ("Unbalanced parenthesis in operand %d", numexp);
                  return -1;
                }
              else
                break;
            }
          if (*lptr == '(')
            ++paren_not_balanced;
          else if (*lptr == ')')
            --paren_not_balanced;
          ++lptr;
        }
      op_end = lptr;
      if (op_end != op_start)
        {
          int len = op_end - op_start;
          strncpy (operands[numexp].buf, op_start, len);
          operands[numexp].buf[len] = 0;
          /* trim trailing spaces; while the preprocessor gets rid of most,
             there are weird usage patterns that can introduce them
             (i.e. using strings for macro args) */
          while (len > 0 && isspace (operands[numexp].buf[len-1]))
            operands[numexp].buf[--len] = 0;
          lptr = op_end;
          ++numexp;
        }
      else 
        {
          if (expecting_operand || *lptr == ',')
            {
              as_bad ("Expecting operand after ','");
              return -1;
            }
        }
      if (*lptr == ',')
        {
          if (*++lptr == '\0')
            {
              as_bad ("Expecting operand after ','");
              return -1;
            }
          expecting_operand = 1;
        }
    }

  while (*lptr && isspace (*lptr++))
    ;
  if (!is_end_of_line[(int)*lptr])
    {
      as_bad ("Extra junk on line");
      return -1;
    }

  /* ok, now parse them into expressions */
  for (i=0;i < numexp;i++)
    {
      memset (&operands[i].exp, 0, sizeof (operands[i].exp));
      if (operands[i].buf[0] == '#')
        {
          /* immediate */
          parse_expression (operands[i].buf + 1, &operands[i].exp);
        }
      else if (operands[i].buf[0] == '@')
        {
          /* direct notation */
          parse_expression (operands[i].buf + 1, &operands[i].exp);
        }
      else if (operands[i].buf[0] == '*')
        {
          /* indirect */
          char *paren = strchr (operands[i].buf, '(');
          /* allow immediate syntax in the inner expression */
          if (paren && paren[1] == '#')
              *++paren = '(';

          /* pull out the lk expression or SP offset, if present */
          if (paren != NULL)
            {
              int len = strlen (paren);
              char *end = paren + len;
              int c;
              while (end[-1] != ')')
                if (--end <= paren)
                  {
                    as_bad (_("Badly formed address expression"));
                    return -1;
                  }
              c = *end;
              *end = '\0';
              parse_expression (paren, &operands[i].exp);
              *end = c;
            }
          else
            operands[i].exp.X_op = O_absent;
        }
      else
        {
          parse_expression (operands[i].buf, &operands[i].exp);
        }
    }

  return numexp;
}

/*
 * Predicates for different operand types
 */
static int
is_immediate (struct opstruct *operand)
{
  return  *operand->buf == '#';
}

/* This is distinguished from immediate because some numbers must be constants
   and must *not* have the '#' prefix */
static int
is_absolute (struct opstruct *operand)
{
  return operand->exp.X_op == O_constant && !is_immediate (operand);
}

/* is this an indirect operand? */
static int
is_indirect (struct opstruct *operand)
{
  return operand->buf[0] == '*';
}

/* is this a valid dual-memory operand? */
static int
is_dual (struct opstruct *operand)
{
  if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0)
    {
      char *tmp = operand->buf + 3;
      int arf;
      int valid_mod;
      arf = *tmp++ - '0';
      /* only allow *ARx, *ARx-, *ARx+, or *ARx+0% */
      valid_mod = *tmp == '\0' ||
        strcasecmp (tmp, "-") == 0 ||
        strcasecmp (tmp, "+") == 0 || 
        strcasecmp (tmp, "+0%") == 0;
      return arf >= 2 && arf <= 5 && valid_mod;
    }
  return 0;
}

static int
is_mmreg (struct opstruct *operand)
{
  return is_absolute (operand) || is_immediate (operand)
    || hash_find (mmreg_hash, operand->buf) != 0;
}

static int
is_type (operand, type)
  struct opstruct *operand;
  enum optype type;
{
  switch (type)
    {
    case OP_None:
      return operand->buf[0] == 0;
    case OP_Xmem:
    case OP_Ymem:
      return is_dual (operand);
    case OP_Sind:
      return is_indirect (operand);
    case OP_xpmad_ms7:
      /* this one *must* be immediate */
      return is_immediate (operand);
    case OP_xpmad:
    case OP_pmad:
    case OP_PA:
    case OP_dmad:
    case OP_Lmem:
    case OP_MMR:
      return 1;
    case OP_Smem:
      /* address may be a numeric, indirect, or an expression */
      return !is_immediate (operand);
    case OP_MMRY:
    case OP_MMRX:
      return is_mmreg (operand);
    case OP_SRC:
    case OP_SRC1:
    case OP_RND:
    case OP_DST:
      return is_accumulator (operand);
    case OP_B:
      return is_accumulator (operand) && toupper (operand->buf[0]) == 'B';
    case OP_A:
      return is_accumulator (operand) && toupper (operand->buf[0]) == 'A';
    case OP_ARX:
      return strncasecmp ("ar", operand->buf, 2) == 0 
        && isdigit (operand->buf[2]);
    case OP_SBIT:
      return hash_find (sbit_hash, operand->buf) != 0 || is_absolute (operand);
    case OP_CC:
      return hash_find (cc_hash, operand->buf) != 0;
    case OP_CC2:
      return hash_find (cc2_hash, operand->buf) != 0;
    case OP_CC3:
      return hash_find (cc3_hash, operand->buf) != 0 
        || is_immediate (operand) || is_absolute (operand);
    case OP_16:
      return (is_immediate (operand) || is_absolute (operand))
        && operand->exp.X_add_number == 16;
    case OP_N:
      /* allow st0 or st1 instead of a numeric */
      return is_absolute (operand) || is_immediate (operand) ||
        strcasecmp ("st0", operand->buf) == 0 ||
        strcasecmp ("st1", operand->buf) == 0;
    case OP_12:
    case OP_123:
      return is_absolute (operand) || is_immediate (operand);
    case OP_SHFT:
      return (is_immediate (operand) || is_absolute (operand))
        && operand->exp.X_add_number >= 0 && operand->exp.X_add_number < 16;
    case OP_SHIFT:
      /* let this one catch out-of-range values */
      return (is_immediate (operand) || is_absolute (operand))
        && operand->exp.X_add_number != 16;
    case OP_BITC:
    case OP_031:
    case OP_k8:
      return is_absolute (operand) || is_immediate (operand);
    case OP_k8u:
      return is_immediate (operand) 
        && operand->exp.X_op == O_constant 
        && operand->exp.X_add_number >= 0
        && operand->exp.X_add_number < 256;
    case OP_lk:
    case OP_lku:
      /* allow anything; assumes opcodes are ordered with Smem operands 
         versions first */
      return 1;
    case OP_k5:
    case OP_k3:
    case OP_k9:
      /* just make sure it's an integer; check range later */
      return is_immediate (operand);
    case OP_T:
      return strcasecmp ("t", operand->buf) == 0 || 
        strcasecmp ("treg", operand->buf) == 0;
    case OP_TS:
      return strcasecmp ("ts", operand->buf) == 0;
    case OP_ASM:
      return strcasecmp ("asm", operand->buf) == 0;
    case OP_TRN:
      return strcasecmp ("trn", operand->buf) == 0;
    case OP_DP:
      return strcasecmp ("dp", operand->buf) == 0;
    case OP_ARP:
      return strcasecmp ("arp", operand->buf) == 0;
    default:
      return 0;
    }
}

static int
operands_match (insn, operands, opcount, refoptype, minops, maxops)
  tic54x_insn *insn;
  struct opstruct *operands;
  int opcount;
  const enum optype *refoptype;
  int minops, maxops;
{
  int op = 0, refop = 0;

  if (opcount == 0 && minops == 0)
    {
      return 1;
    }

  while (op <= maxops && refop <= maxops)
    {
      while (!is_type (&operands[op], OPTYPE (refoptype[refop])))
        {
          /* skip an optional template operand if it doesn't agree
             with the current operand
           */
          if (refoptype[refop] & OPT)
            {
              ++refop;
              --maxops;
              if (refop > maxops)
                return 0;
            }
          else
            return 0;
        }

      /* save the actual operand type for later use */
      operands[op].type = OPTYPE (refoptype[refop]);
      ++refop;
      ++op;
      /* have we matched them all yet? */
      if (op == opcount)
        {
          while (op < maxops)
            {
              /* if a later operand is *not* optional, no match */
              if ((refoptype[refop] & OPT) == 0)
                return 0;
              /* flag any implicit default OP_DST operands so we know to add
                 them explicitly when encoding the operand later */
              if (OPTYPE (refoptype[refop]) == OP_DST)
                insn->using_default_dst = 1;
              ++refop;
              ++op;
            }

          return 1;
        }
    }

  return 0;
}

/* 16-bit direct memory address 
   Explicit dmad operands are always in last word of insn (usually second
   word, but bumped to third if lk addressing is used)

   We allow *(dmad) notation because the TI assembler allows it.

   XPC_CODE: 
   0 for 16-bit addresses
   1 for full 23-bit addresses
   2 for the upper 7 bits of a 23-bit address (LDX)
*/
static int
encode_dmad (insn, operand, xpc_code)
  tic54x_insn *insn;
  struct opstruct *operand;
  int xpc_code;
{
  int op = 1 + insn->is_lkaddr;

  /* only allow *(dmad) expressions; all others are invalid */
  if (is_indirect (operand) && operand->buf[strlen (operand->buf)-1] != ')')
    {
      as_bad (_("Invalid dmad syntax '%s'"), operand->buf);
      return 0;
    }

  insn->opcode[op].addr_expr = operand->exp;

  if (insn->opcode[op].addr_expr.X_op == O_constant)
    {
      valueT value = insn->opcode[op].addr_expr.X_add_number;
      if (xpc_code == 1)
        {
          insn->opcode[0].word &= 0xFF80;
          insn->opcode[0].word |= (value >> 16) & 0x7F;
          insn->opcode[1].word = value & 0xFFFF;
        }
      else if (xpc_code == 2)
        insn->opcode[op].word = (value >> 16) & 0xFFFF;
      else
        insn->opcode[op].word = value;
    }
  else
    {
      /* do the fixup later; just store the expression */
      insn->opcode[op].word = 0;
      insn->opcode[op].r_nchars = 2;

      if (amode == c_mode)
        insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;
      else if (xpc_code == 1)
        {
          /* this relocation spans two words, so adjust accordingly */
          insn->opcode[0].addr_expr = operand->exp;
          insn->opcode[0].r_type = BFD_RELOC_TIC54X_23;
          insn->opcode[0].r_nchars = 4;
          insn->opcode[0].unresolved = 1;
          /* it's really 2 words, but we want to stop encoding after the
             first, since we must encode both words at once */
          insn->words = 1;
        }
      else if (xpc_code == 2)
        insn->opcode[op].r_type = BFD_RELOC_TIC54X_MS7_OF_23;
      else
        insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23;

      insn->opcode[op].unresolved = 1;
    }

  return 1;
}


/* 7-bit direct address encoding */
static int
encode_address (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  /* Assumes that dma addresses are *always* in word 0 of the opcode */
  insn->opcode[0].addr_expr = operand->exp;

  if (operand->exp.X_op == O_constant)
    insn->opcode[0].word |= (operand->exp.X_add_number & 0x7F);
  else
    {
      /* do the fixup later; just store the expression */
      insn->opcode[0].r_nchars = 1;
      insn->opcode[0].r_type = BFD_RELOC_TIC54X_PARTLS7;
      insn->opcode[0].unresolved = 1;
    }

  return 1;
}

static int
encode_indirect (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  int arf;
  int mod;

  if (insn->is_lkaddr)
    {
      /* lk addresses always go in the second insn word */
      mod = ((toupper (operand->buf[1]) == 'A') ? 12 :
             (operand->buf[1] == '(') ? 15 :
             (strchr (operand->buf, '%') != NULL) ? 14 : 13);
      arf = ((mod == 12) ? operand->buf[3] - '0' :
             (mod == 15) ? 0 : operand->buf[4] - '0');
      
      insn->opcode[1].addr_expr = operand->exp;

      if (operand->exp.X_op == O_constant)
        insn->opcode[1].word = operand->exp.X_add_number;
      else
        {
          insn->opcode[1].word = 0;
          insn->opcode[1].r_nchars = 2;
          insn->opcode[1].r_type = BFD_RELOC_TIC54X_16_OF_23;
          insn->opcode[1].unresolved = 1;
        }
    }
  else if (strncasecmp (operand->buf, "*sp (", 4) == 0)
    {
      /* stack offsets look the same as 7-bit direct addressing */
      return encode_address (insn, operand);
    }
  else
    {
      arf = (toupper (operand->buf[1]) == 'A' ? 
             operand->buf[3] : operand->buf[4]) - '0';
      
      if (operand->buf[1] == '+') 
        {
          mod = 3;                    /* *+ARx */
          if (insn->tm->flags & FL_SMR)
            as_warn (_("Address mode *+ARx is write-only. "
                       "Results of reading are undefined."));
        }
      else if (operand->buf[4] == '\0') 
        mod = 0;                    /* *ARx */
      else if (operand->buf[5] == '\0')
        mod = (operand->buf[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */
      else if (operand->buf[6] == '\0')
        {
          if (operand->buf[5] == '0')
            mod = (operand->buf[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */
          else
            mod = (operand->buf[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */
        }
      else if (toupper (operand->buf[6]) == 'B')
        mod = (operand->buf[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */
      else if (toupper (operand->buf[6]) == '%')
        mod = (operand->buf[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */
      else
        {
          as_bad (_("Unrecognized indirect address format \"%s\""), 
                  operand->buf);
          return 0;
        }
    }      

  insn->opcode[0].word |= 0x80 | (mod<<3) | arf;

  return 1;
}

static int
encode_integer (insn, operand, which, min, max, mask)
  tic54x_insn *insn;
  struct opstruct *operand;
  int which, min, max;
  unsigned short mask;
{
  long parse, integer;

  insn->opcode[which].addr_expr = operand->exp;

  if (operand->exp.X_op == O_constant)
    {
      parse = operand->exp.X_add_number;
      /* hack -- fixup for 16-bit hex quantities that get converted positive
         instead of negative */
      if ((parse & 0x8000) && min == -32768 && max == 32767)
        integer = (short)parse;
      else
        integer = parse;

      if (integer >= min && integer <= max)
        {
          insn->opcode[which].word |= (integer & mask);
          return 1;
        }
      as_bad (_("Operand '%s' out of range (%d <= x <= %d)"), 
              operand->buf, min, max);
    }
  else
    {
      if (insn->opcode[which].addr_expr.X_op == O_constant)
        {
          insn->opcode[which].word |= 
            insn->opcode[which].addr_expr.X_add_number & mask;
        }
      else
        {
          /* do the fixup later; just store the expression */
          bfd_reloc_code_real_type rtype = 
            (mask == 0x1FF ? BFD_RELOC_TIC54X_PARTMS9 : 
             mask == 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23 :
             mask == 0x7F ? BFD_RELOC_TIC54X_PARTLS7 : BFD_RELOC_8);
          int size = (mask == 0x1FF || mask == 0xFFFF) ? 2 : 1;

          if (rtype == BFD_RELOC_8)
            as_bad (_("Error in relocation handling"));

          insn->opcode[which].r_nchars = size;
          insn->opcode[which].r_type = rtype;
          insn->opcode[which].unresolved = 1;
        }

      return 1;
    }

  return 0;
}

static int
encode_condition (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  symbol *cc = (symbol *)hash_find (cc_hash, operand->buf);
  if (!cc)
    {
      as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
      return 0;
    }
#define CC_GROUP 0x40
#define CC_ACC   0x08
#define CATG_A1  0x07
#define CATG_B1  0x30
#define CATG_A2  0x30
#define CATG_B2  0x0C
#define CATG_C2  0x03
  /* disallow group 1 conditions mixed with group 2 conditions
     if group 1, allow only one category A and one category B
     if group 2, allow only one each of category A, B, and C
   */
  if (((insn->opcode[0].word & 0xFF) != 0))
    {
      if ((insn->opcode[0].word & CC_GROUP) != (cc->value & CC_GROUP))
        {
          as_bad (_("Condition \"%s\" does not match preceding group"), 
                  operand->buf);
          return 0;
        }
      if (insn->opcode[0].word & CC_GROUP)
        {
          if ((insn->opcode[0].word & CC_ACC) != (cc->value & CC_ACC))
            {
              as_bad (_("Condition \"%s\" uses a different accumulator from "
                        "a preceding condition"), 
                      operand->buf);
              return 0;
            }
          if ((insn->opcode[0].word & CATG_A1) && (cc->value & CATG_A1))
            {
              as_bad (_("Only one comparison conditional allowed"));
              return 0;
            }
          if ((insn->opcode[0].word & CATG_B1) && (cc->value & CATG_B1))
            {
              as_bad (_("Only one overflow conditional allowed"));
              return 0;
            }
        }
      else if (((insn->opcode[0].word & CATG_A2) && (cc->value & CATG_A2)) ||
               ((insn->opcode[0].word & CATG_B2) && (cc->value & CATG_B2)) ||
               ((insn->opcode[0].word & CATG_C2) && (cc->value & CATG_C2)))
        {
          as_bad (_("Duplicate %s conditional"), operand->buf);
          return 0;
        }
    }

  insn->opcode[0].word |= cc->value;
  return 1;
}

static int
encode_cc3 (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  symbol *cc3 = (symbol *)hash_find (cc3_hash, operand->buf);
  int value = cc3 ? cc3->value : operand->exp.X_add_number << 8;

  if ((value & 0x0300) != value)
    {
      as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
      return 0;
    }
  insn->opcode[0].word |= value;
  return 1;
}

static int
encode_arx (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1;
  if (strncasecmp ("ar", operand->buf, 2) || arf < 0 || arf > 7)
    {
      as_bad (_("Invalid auxiliary register (use AR0-AR7)"));
      return 0;
    }
  insn->opcode[0].word |= arf;
  return 1;
}

static int
encode_cc2 (insn, operand)
  tic54x_insn *insn;
  struct opstruct *operand;
{
  symbol *cc2 = (symbol *)hash_find (cc2_hash, operand->buf);
  if (!cc2)
    {
      as_bad (_("Unrecognized condition code \"%s\""), operand->buf);
      return 0;
    }
  insn->opcode[0].word |= cc2->value;
  return 1;
}

static int
encode_operand (insn, type, operand)
  tic54x_insn *insn;
  enum optype type;
  struct opstruct *operand;
{
  int ext = insn->tm && ((insn->tm->flags & FL_EXT) != 0);

  if (type == OP_MMR && operand->exp.X_op != O_constant)
    {
      /* disallow long-constant addressing for memory-mapped addressing */
      if (insn->is_lkaddr)
        {
          as_bad (_("lk addressing modes are invalid for memory-mapped "
                    "register addressing"));
          return 0;
        }
      type = OP_Smem;
      /* warn about *+ARx when used with MMR operands */
      if (strncasecmp (operand->buf, "*+ar", 4) == 0)
        {
          as_warn (_("Address mode *+ARx is not allowed in memory-mapped "
                     "register addressing.  Resulting behavior is "
                     "undefined."));
        }
    }

  switch (type)
    {
    case OP_None:
      return 1;
    case OP_dmad:
      /* 16-bit immediate value */
      return encode_dmad (insn, operand, 0);
    case OP_SRC:
      if (toupper (*operand->buf) == 'B')
        {
          insn->opcode[ext ?  (1 + insn->is_lkaddr) : 0].word |= (1<<9);
          if (insn->using_default_dst)
            insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1<<8);
        }
      return 1;
    case OP_RND:
      /* make sure this agrees with with the OP_DST operand */
      if (!((toupper (operand->buf[0]) == 'B') ^
            ((insn->opcode[0].word & (1<<8)) != 0)))
        {
          as_bad (_("Destination accumulator for each part of this parallel "
                    "instruction must be different"));
          return 0;
        }
      return 1;
    case OP_SRC1:
    case OP_DST:
      if (toupper (operand->buf[0]) == 'B')
        insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1<<8);
      return 1;
    case OP_Xmem:
    case OP_Ymem:
    {
      int mod = (operand->buf[4] == '\0' ? 0 : /* *arx */
                 operand->buf[4] == '-' ? 1 : /* *arx- */
                 operand->buf[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */
      int arf = operand->buf[3] - '0' - 2;
      int code = (mod << 2)|arf;
      insn->opcode[0].word |= (code << (type == OP_Xmem ? 4 : 0));
      return 1;
    }
    case OP_Lmem:
    case OP_Smem:
      if (!is_indirect (operand))
        return encode_address (insn, operand);
      /* fall through */
    case OP_Sind:
      return encode_indirect (insn, operand);
    case OP_xpmad_ms7:
      return encode_dmad (insn, operand, 2);
    case OP_xpmad:
      return encode_dmad (insn, operand, 1);
    case OP_PA:
    case OP_pmad:
      return encode_dmad (insn, operand, 0);
    case OP_ARX:
      return encode_arx (insn, operand);
    case OP_MMRX:
    case OP_MMRY:
    case OP_MMR:
    {
      int value = operand->exp.X_add_number;
      if (type == OP_MMR)
        insn->opcode[0].word |= value;
      else {
        if (value < 16 || value > 24)
          {
            as_bad (_("Memory mapped register \"%s\" out of range"), 
                    operand->buf);
            return 0;
          }
        if (type == OP_MMRX)
          insn->opcode[0].word |= (value - 16) << 4;
        else
          insn->opcode[0].word |= (value - 16);
      }
      return 1;
    }
    case OP_B:
    case OP_A:
      return 1;
    case OP_SHFT:
      return encode_integer (insn, operand, ext + insn->is_lkaddr, 
                             0, 15, 0xF);
    case OP_SHIFT:
      return encode_integer (insn, operand, ext + insn->is_lkaddr, 
                             -16, 15, 0x1F);
    case OP_lk:
      return encode_integer (insn, operand, 1 + insn->is_lkaddr,
                             -32768, 32767, 0xFFFF);
    case OP_CC:
      return encode_condition (insn, operand);
    case OP_CC2:
      return encode_cc2 (insn, operand);
    case OP_CC3:
      return encode_cc3 (insn, operand);
    case OP_BITC:
      return encode_integer (insn, operand, 0, 0, 15, 0xF);
    case OP_k8:
      return encode_integer (insn, operand, 0, -128, 127, 0xFF);
    case OP_123:
    {
      int value = operand->exp.X_add_number;
      int code;
      if (value < 1 || value > 3)
        {
          as_bad (_("Invalid operand (use 1, 2, or 3)"));
          return 0;
        }
      code = value == 1 ? 0 : value == 2 ? 0x2 : 0x1;
      insn->opcode[0].word |= (code << 8);
      return 1;
    }
    case OP_031:
      return encode_integer (insn, operand, 0, 0, 31, 0x1F);
    case OP_k8u:
      return encode_integer (insn, operand, 0, 0, 255, 0xFF);
    case OP_lku:
      return encode_integer (insn, operand, 1 + insn->is_lkaddr, 
                             0, 65535, 0xFFFF);
    case OP_SBIT:
    {
      symbol *sbit = (symbol *)hash_find (sbit_hash, operand->buf);
      int value = is_absolute (operand) ? 
        operand->exp.X_add_number : (sbit ? sbit->value : -1);
      int reg = 0;
      
      if (insn->opcount == 1)
        {
          if (!sbit)
            {
              as_bad (_("A status register or status bit name is required"));
              return 0;
            }
          /* guess the register based on the status bit; "ovb" is the last
             status bit defined for st0 */
          if (sbit > (symbol *)hash_find (sbit_hash, "ovb"))
            reg = 1;
        }
      if (value == -1)
        {
          as_bad (_("Unrecognized status bit \"%s\""), operand->buf);
          return 0;
        }
      insn->opcode[0].word |= value;
      insn->opcode[0].word |= (reg << 9);
      return 1;
    }
    case OP_N:
      if (strcasecmp (operand->buf, "st0") == 0
          || strcasecmp (operand->buf, "st1") == 0)
        {
          insn->opcode[0].word |= ((unsigned short)(operand->buf[2] - '0'))<<9;
          return 1;
        }
      else if (operand->exp.X_op == O_constant
               && (operand->exp.X_add_number == 0 
                   || operand->exp.X_add_number == 1))
        {
          insn->opcode[0].word |= ((unsigned short)
                                   (operand->exp.X_add_number))<<9;
          return 1;
        }
      as_bad (_("Invalid status register \"%s\""), operand->buf);
      return 0;
    case OP_k5:
      return encode_integer (insn, operand, 0, -16, 15, 0x1F);
    case OP_k3:
      return encode_integer (insn, operand, 0, 0, 7, 0x7);
    case OP_k9:
      return encode_integer (insn, operand, 0, 0, 0x1FF, 0x1FF);
    case OP_12:
      if (operand->exp.X_add_number != 1 
          && operand->exp.X_add_number != 2)
        {
          as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand->buf);
          return 0;
        }
      insn->opcode[0].word |= (operand->exp.X_add_number - 1) << 9;
      return 1;
    case OP_16:
    case OP_T:
    case OP_TS:
    case OP_ASM:
    case OP_TRN:
    case OP_DP:
    case OP_ARP:
      /* no encoding necessary */
      return 1;
    default:
      return 0;
    }

  return 1;
}

static void
emit_insn (insn)
  tic54x_insn *insn;
{
  int i;
  for (i=0;i < insn->words;i++)
    {
      int size = (insn->opcode[i].unresolved 
                  && insn->opcode[i].r_type == BFD_RELOC_TIC54X_23) ? 4 : 2;
      char *p = frag_more (size);

      if (size == 2)
        md_number_to_chars (p, (valueT)insn->opcode[i].word, 2);
      else
        md_number_to_chars (p, (valueT)insn->opcode[i].word << 16, 4);
        
      if (insn->opcode[i].unresolved)
        fix_new_exp (frag_now, p - frag_now->fr_literal,
                     insn->opcode[i].r_nchars, &insn->opcode[i].addr_expr,
                     false, insn->opcode[i].r_type);
    }
}

/* convert the operand strings into appropriate opcode values 
   return the total number of words used by the instruction
 */
static int
build_insn (insn)
  tic54x_insn *insn;
{
  int i;

  /* only non-parallel instructions support lk addressing */
  if (insn->tm)
    {
      for (i=0; i < insn->opcount; i++)
        {
          if ((OPTYPE (insn->operands[i].type) == OP_Smem ||
               OPTYPE (insn->operands[i].type) == OP_Lmem ||
               OPTYPE (insn->operands[i].type) == OP_Sind) &&
              strchr (insn->operands[i].buf, '(') &&
              /* don't mistake stack-relative addressing for lk addressing */
              strncasecmp (insn->operands[i].buf, "*sp (", 4) != 0)
            {
              insn->is_lkaddr = 1;
              insn->lkoperand = i;
              break;
            }
        }
    }
  insn->words = 
    (insn->tm ? insn->tm->words : insn->ptm->words) + insn->is_lkaddr;

  insn->opcode[0].word = insn->tm ? insn->tm->opcode : insn->ptm->opcode;
  if (insn->tm && (insn->tm->flags & FL_EXT))
      insn->opcode[1 + insn->is_lkaddr].word = insn->tm->opcode2;

  for (i=0; i < insn->opcount; i++)
    {
      enum optype type = insn->operands[i].type;
      if (!encode_operand (insn, type, &insn->operands[i]))
        return 0;
    }
  if (insn->ptm) for (i=0; i < insn->paropcount; i++)
    {
      enum optype partype = insn->paroperands[i].type;
      if (!encode_operand (insn, partype, &insn->paroperands[i]))
        return 0;
    }

  emit_insn (insn);

  return insn->words;
}

static int
optimize_insn (insn)
  tic54x_insn *insn;
{
  /* optimize some instructions, helping out the brain-dead programmer
   */ 
#define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0)
  if (strcasecmp (insn->tm->name, "add") == 0)
    {
      if (insn->opcount > 1 &&
          is_accumulator (&insn->operands[insn->opcount-2]) &&
          is_accumulator (&insn->operands[insn->opcount-1]) &&
          strcasecmp (insn->operands[insn->opcount-2].buf,
                     insn->operands[insn->opcount-1].buf) == 0)
        {
          --insn->opcount;
          insn->using_default_dst = 1;
          return 1;
        }
      
      /* try to collapse if Xmem and shift count is zero */
      if ((OPTYPE (insn->tm->operand_types[0]) == OP_Xmem &&
           OPTYPE (insn->tm->operand_types[1]) == OP_SHFT &&
           is_zero (insn->operands[1])) ||
          /* Or if Smem, shift is zero or absent, and SRC == DST */
          (OPTYPE (insn->tm->operand_types[0]) == OP_Smem &&
           OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT &&
           is_type (&insn->operands[1], OP_SHIFT) && 
           is_zero (insn->operands[1]) && insn->opcount == 3))
        {
          insn->operands[1] = insn->operands[2];
          insn->opcount = 2;
          return 1;
        }
    }
  else if (strcasecmp (insn->tm->name, "ld") == 0)
    {
      if (insn->opcount == 3 && insn->operands[0].type != OP_SRC)
        {
          if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT ||
               OPTYPE (insn->tm->operand_types[1]) == OP_SHFT) &&
              is_zero (insn->operands[1]) &&
              (OPTYPE (insn->tm->operand_types[0]) != OP_lk ||
               (insn->operands[0].exp.X_op == O_constant &&
                insn->operands[0].exp.X_add_number <= 255 &&
                insn->operands[0].exp.X_add_number >= 0)))
            {
              insn->operands[1] = insn->operands[2];
              insn->opcount = 2;
              return 1;
            }
        }
    }
  else if (strcasecmp (insn->tm->name, "sth") == 0 ||
           strcasecmp (insn->tm->name, "stl") == 0)
    {
      if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT ||
           OPTYPE (insn->tm->operand_types[1]) == OP_SHFT) &&
          is_zero (insn->operands[1]))
        {
          insn->operands[1] = insn->operands[2];
          insn->opcount = 2;
          return 1;
        }
    }
  else if (strcasecmp (insn->tm->name, "sub") == 0)
    {
      if (insn->opcount > 1 &&
          is_accumulator (&insn->operands[insn->opcount-2]) &&
          is_accumulator (&insn->operands[insn->opcount-1]) &&
          strcasecmp (insn->operands[insn->opcount-2].buf,
                     insn->operands[insn->opcount-1].buf) == 0)
        {
          --insn->opcount;
          insn->using_default_dst = 1;
          return 1;
        }
      
      if (((OPTYPE (insn->tm->operand_types[0]) == OP_Smem &&
            OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT) ||
           (OPTYPE (insn->tm->operand_types[0]) == OP_Xmem &&
            OPTYPE (insn->tm->operand_types[1]) == OP_SHFT)) &&
          is_zero (insn->operands[1]) &&
          insn->opcount == 3)
        {
          insn->operands[1] = insn->operands[2];
          insn->opcount = 2;
          return 1;
        }
    }
  return 0;
}

/* Find a matching template if possible, and get the operand strings */
static int
tic54x_parse_insn (insn, line)
  tic54x_insn *insn;
  char *line;
{
  insn->tm = (template *)hash_find (op_hash, insn->mnemonic);
  if (!insn->tm)
    {
      as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic);
      return 0;
    }

  insn->opcount = get_operands (insn->operands, line);
  if (insn->opcount < 0)
      return 0;

  /* check each variation of operands for this mnemonic */
  while (insn->tm->name && strcasecmp (insn->tm->name, insn->mnemonic) == 0)
    {
      if (insn->opcount >= insn->tm->minops &&
          insn->opcount <= insn->tm->maxops &&
          operands_match (insn, &insn->operands[0], insn->opcount,
                          insn->tm->operand_types, 
                          insn->tm->minops, insn->tm->maxops))
        {
          /* SUCCESS! now try some optimizations */
          if (optimize_insn (insn))
            {
              insn->tm = (template *)hash_find (op_hash, 
                                                insn->mnemonic);
              continue;
            }

          return 1;
        }
      ++(insn->tm);
    }
  as_bad (_("Unrecognized operand list '%s' for instruction '%s'"), 
            line, insn->mnemonic);
  return 0;
}

/* we set this in start_line_hook, 'cause if we do a line replacement, we
   won't be able to see the next line */
static int parallel_on_next_line_hint = 0;
/* See if this is part of a parallel instruction
   Look for a subsequent line starting with "||"
*/
static int
next_line_shows_parallel (next_line)
  char *next_line;
{
  /* look for the second half */
  while (isspace (*next_line))
    ++next_line;

  return (next_line[0] == PARALLEL_SEPARATOR &&
          next_line[1] == PARALLEL_SEPARATOR);
}

static int
tic54x_parse_parallel_insn_firstline (insn, line)
  tic54x_insn *insn;
  char *line;
{
  insn->ptm = (partemplate *)hash_find (parop_hash, insn->mnemonic);
  if (!insn->ptm)
    {
      as_bad (_("Unrecognized parallel instruction \"%s\""), 
              insn->mnemonic);
      return 0;
    }

  while (insn->ptm->name && strcasecmp (insn->ptm->name,
                                       insn->mnemonic) == 0)
    {
      insn->opcount = get_operands (insn->operands, line);
      if (insn->opcount < 0)
        return 0;
      if (insn->opcount == 2 && 
          operands_match (insn, &insn->operands[0], insn->opcount,
                          insn->ptm->operand_types, 2, 2))
        {
          return 1;
        }
      ++(insn->ptm);
    }
  /* didn't find a matching parallel; try for a normal insn */
  return 0;
}

/* parse the second line of a two-line parallel instruction */
static int
tic54x_parse_parallel_insn_lastline (insn, line)
  tic54x_insn *insn;
  char *line;
{
  int valid_mnemonic = 0;
  
  insn->paropcount = get_operands (insn->paroperands, line);
  while (insn->ptm->name && strcasecmp (insn->ptm->name,
                                       insn->mnemonic) == 0)
    {
      if (strcasecmp (insn->ptm->parname, insn->parmnemonic) == 0)
        {
          valid_mnemonic = 1;
          if (insn->paropcount >= insn->ptm->minops &&
              insn->paropcount <= insn->ptm->maxops &&
              operands_match (insn, insn->paroperands, 
                              insn->paropcount,
                              insn->ptm->paroperand_types,
                              insn->ptm->minops, insn->ptm->maxops))
            {
              return 1;
            }
        }
      ++(insn->ptm);
    }
  if (valid_mnemonic)
    as_bad (_("Invalid operand (s) for parallel instruction \"%s\""),
            insn->parmnemonic);
  else
    as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""),
            insn->mnemonic, insn->parmnemonic);

  return 0;
}

/* if quotes found, return copy of line up to closing quote;
   otherwise up until terminator 
   if it's a string, pass as-is; otherwise attempt substitution symbol
   replacement on the value
*/
static char *
subsym_get_arg (char *line, char *terminators, char **str, int nosub)
{
  char *ptr = line;
  char *endp;
  int is_string = *line == '"';
  int is_char = isdigit (*line);

  if (is_char)
    {
      while (isdigit (*ptr))
        ++ptr;
      endp = ptr;
      *str = xmalloc (ptr - line + 1);
      strncpy (*str, line, ptr - line);
      (*str)[ptr - line] = 0;
    }
  else if (is_string)
    {
      char *savedp = input_line_pointer;
      int len;
      input_line_pointer = ptr;
      *str = demand_copy_C_string (&len);
      endp = input_line_pointer;
      input_line_pointer = savedp;

      /* do forced substitutions if requested */
      if (!nosub && **str == ':')
        *str = subsym_substitute (*str, 1);
    }
  else
    {
      char *term = terminators;
      char *value = NULL;

      while (*ptr && *ptr != *term)
        {
          if (!*term)
            {
              term = terminators;
              ++ptr;
            }
          else
            ++term;
        }
      endp = ptr;
      *str = xmalloc (ptr - line + 1);
      strncpy (*str, line, ptr - line);
      (*str)[ptr - line] = 0;
      /* do simple substitution, if available */
      if (!nosub && (value = subsym_lookup (*str, macro_level)) != NULL)
          *str = value;
    }

  return endp;
}

/* replace the given substitution string.
   We start at the innermost macro level, so that existing locals remain local
   Note: we're treating macro args identically to .var's; I don't know if
   that's compatible w/TI's assembler.
*/
static void
subsym_create_or_replace (char *name, char *value)
{
  int i;

  for (i=macro_level;i > 0;i--)
    {
      if (hash_find (subsym_hash[i], name))
        {
          hash_replace (subsym_hash[i], name, value);
          return;
        }
    }
  if (hash_find (subsym_hash[0], name))
    hash_replace (subsym_hash[0], name, value);
  else
    hash_insert (subsym_hash[0], name, value);
}

/* look up the substitution string replacement for the given symbol 
   start with the innermost macro substituion table given and work outwards */
static char *
subsym_lookup (char *name, int nest_level)
{
  char *value = hash_find (subsym_hash[nest_level], name);

  if (value || nest_level == 0)
    return value;

  return subsym_lookup (name, nest_level-1);
}

/* do substitution-symbol replacement on the given line (recursively).
   return the argument if no substitution was done 

   Also look for built-in functions ($func (arg)) and local labels.

   if FORCED is set, look for forced substitutions of the form ':SYMBOL:'.
*/
static char *
subsym_substitute (char *line, int forced)
{
  /* for each apparent symbol, see if it's a substitution symbol, and if so,
     replace it in the input */
  char *replacement; /* current replacement for LINE */
  char *head; /* start of line */
  char *ptr; /* current examination point */
  int changed = 0; /* did we make a substitution? */
  int eval_line = 0; /* is this line a .eval/.asg statement? */
  int eval_symbol = 0; /* are we in the middle of the symbol for .eval/.asg? */
  char *eval_end = NULL;
  int recurse = 1;
  int line_conditional = 0;
  char *tmp;

  /* work with a copy of the input line */
  replacement = xmalloc (strlen (line) + 1);
  strcpy (replacement, line);

  ptr = head = replacement;

  /* flag lines where we might need to replace a single '=' with two;
     GAS uses single '=' to assign macro args values, and possibly other
     places, so limit what we replace */
  if (strstr (line, ".if") 
      || strstr (line, ".elseif") 
      || strstr (line, ".break"))
    {
      line_conditional = 1;
    }

  /* watch out for .eval, so that we avoid doing substitution on the
     symbol being assigned a value */
  if (strstr (line, ".eval") || strstr (line, ".asg"))
      eval_line = 1;

  /* if it's a macro definition, don't do substitution on the argument names */
  if (strstr (line, ".macro"))
    return line;

  while (!is_end_of_line[(int)*ptr])
    {
      int current_char = *ptr;

      /* need to update this since LINE may have been modified */
      if (eval_line)
          eval_end = strrchr (ptr, ',');

      /* replace triple double quotes with bounding quote/escapes */
      if (current_char == '"' && ptr[1] == '"' && ptr[2] == '"')
        {
          ptr[1] = '\\';
          tmp = strstr (ptr+2, "\"\"\"");
          if (tmp)
            tmp[0] = '\\';
          changed = 1;
        }

      /* replace a single '=' with a '==';
         for compatibility with older code only */
      if (line_conditional && current_char == '=') 
        {
          if (ptr[1] == '=')
            {
              ptr += 2; 
              continue;
            }
          *ptr++ = '\0';
          tmp = xmalloc (strlen (head) + 2 + strlen (ptr) + 1);
          sprintf (tmp, "%s==%s", head, ptr);
          /* continue examining after the '==' */
          ptr = tmp + strlen (head) + 2;
          free (replacement);
          head = replacement = tmp;
          changed = 1;
        }

      /* flag when we've reached the symbol part of .eval/.asg */
      if (eval_line && ptr >= eval_end)
        eval_symbol = 1;

      /* for each apparent symbol, see if it's a substitution symbol, and if
         so, replace it in the input 
      */
      if ((forced && current_char == ':')
          || (!forced && is_name_beginner (current_char)))
        {
          char *name; /* symbol to be replaced */
          char *savedp = input_line_pointer;
          int c;
          char *value = NULL;
          char *tail; /* rest of line after symbol */
          
          /* skip the colon */
          if (forced)
            ++ptr;

          name = input_line_pointer = ptr;
          c = get_symbol_end ();
          /* '?' is not normally part of a symbol, but it IS part of a local
             label 
           */ 
          if (c == '?')
            {
              *input_line_pointer++ = c;
              c = *input_line_pointer;
              *input_line_pointer = '\0';
            }
          /* avoid infinite recursion; if a symbol shows up a second time for
             substitution, leave it as is */
          if (hash_find (subsym_recurse_hash, name) == NULL)
            value = subsym_lookup (name, macro_level);
          else
            as_warn (_("%s symbol recursion stopped at "
                       "second appearance of '%s'"), 
                     forced ? "Forced substitution": "Substitution", name);
          ptr = tail = input_line_pointer;
          input_line_pointer = savedp;

          /* check for local labels; replace them with the appropriate
             substitution */
          if ((*name == '$' && isdigit (name[1]) && name[2] == '\0') 
              || name[strlen (name)-1] == '?')
            {
              /* use an existing identifier for that label if, available, or
                 create a new, unique identifier */
              value = hash_find (local_label_hash[macro_level], name);
              if (value == NULL)
                {
                  char digit[11];
                  char *namecopy = strcpy (xmalloc (strlen (name) + 1), name);
                  value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1),
                                  name);
                  if (*value != '$')
                    value[strlen (value)-1] = '\0';
                  sprintf (digit, ".%d", local_label_id++);
                  strcat (value, digit);
                  hash_insert (local_label_hash[macro_level], namecopy, value);
                }
              /* indicate where to continue looking for substitutions */
              ptr = tail;
            }
          /* check for built-in subsym and math functions */
          else if (value != NULL && *name == '$')
            {
              subsym_proc_entry *entry = (subsym_proc_entry *)value;
              math_proc_entry *math_entry = hash_find (math_hash, name);
              char *arg1, *arg2 = NULL;

              *ptr = c;
              if (entry == NULL)
                {
                  as_bad (_("Unrecognized substitution symbol function"));
                  break;
                }
              else if (*ptr != '(')
                {
                  as_bad (_("Missing '(' after substitution symbol function"));
                  break;
                }
              ++ptr;
              if (math_entry != NULL)
                {
                  float arg1, arg2 = 0;
                  volatile float fresult;

                  arg1 = (float)strtod (ptr, &ptr);
                  if (math_entry->nargs == 2)
                    {
                      if (*ptr++ != ',')
                        {
                          as_bad (_("Expecting second argument"));
                          break;
                        }
                      arg2 = (float)strtod (ptr, &ptr);
                    }
                  fresult = (*math_entry->proc)(arg1, arg2);
                  value = xmalloc (128);
                  if (math_entry->int_return)
                    sprintf (value, "%d", (int)fresult);
                  else
                    sprintf (value, "%f", fresult);
                  if (*ptr++ != ')')
                    {
                      as_bad (_("Extra junk in function call, expecting ')'"));
                      break;
                    }
                  /* don't bother recursing; the replacement isn't a symbol */
                  recurse = 0;
                }
              else
                {
                  int val;
                  int arg_type[2] = {*ptr == '"',0};
                  int ismember = !strcmp (entry->name, "$ismember");
                  /* parse one or two args, which must be a substitution
                     symbol, string or a character-string constant */
                  /* for all functions, a string or substitution symbol may be
                     used, with the following exceptions:
                     firstch/lastch: 2nd arg must be character constant
                     ismember: both args must be substitution symbols
                  */
                  ptr = subsym_get_arg (ptr, ",)", &arg1, ismember);
                  if (!arg1)
                    break;
                  if (entry->nargs == 2)
                    {
                      if (*ptr++ != ',')
                        {
                          as_bad (_("Function expects two arguments"));
                          break;
                        }
                      /* character constants are converted to numerics
                         by the preprocessor */
                      arg_type[1] = (isdigit (*ptr)) ? 2 : (*ptr == '"');
                      ptr = subsym_get_arg (ptr, ")", &arg2, ismember);
                    }
                  /* args checking */
                  if ((!strcmp (entry->name, "$firstch")
                       || !strcmp (entry->name, "$lastch")) 
                      && arg_type[1] != 2)
                    {
                      as_bad (_("Expecting character constant argument"));
                      break;
                    }
                  if (ismember
                      && (arg_type[0] != 0 || arg_type[1] != 0))
                    {
                      as_bad (_("Both arguments must be substitution symbols"));
                      break;
                    }
                  if (*ptr++ != ')')
                    {
                      as_bad (_("Extra junk in function call, expecting ')'"));
                      break;
                    }
                  val = (*entry->proc)(arg1, arg2);
                  value = xmalloc (64);
                  sprintf (value, "%d", val);
                }
              /* fix things up to replace the entire expression, not just the
                 function name  */
              tail = ptr;
              c = *tail;
            }

          if (value != NULL && !eval_symbol)
            {
              /* Replace the symbol with its string replacement and
                 continue.  Recursively replace VALUE until either no
                 substitutions are performed, or a substitution that has been
                 previously made is encountered again.

                 put the symbol into the recursion hash table so we only
                 try to replace a symbol once
              */
              if (recurse)
                {
                  hash_insert (subsym_recurse_hash, name, name);
                  value = subsym_substitute (value, macro_level > 0);
                  hash_delete (subsym_recurse_hash, name);
                }

              /* temporarily zero-terminate where the symbol started */
              *name = 0; 
              if (forced)
                {
                  if (c == '(')
                    {
                      /* subscripted substitution symbol -- use just the
                         indicated portion of the string; the description
                         kinda indicates that forced substituion is not
                         supposed to be recursive, but I'm not sure. 
                      */
                      unsigned beg, len = 1; /* default to a single char */
                      char *newval = strcpy (xmalloc (strlen (value)+1), value);

                      savedp = input_line_pointer;
                      input_line_pointer = tail + 1;
                      beg = get_absolute_expression ();
                      if (beg < 1)
                        {
                          as_bad (_("Invalid subscript (use 1 to %d)"), 
                                  strlen (value));
                          break;
                        }
                      if (*input_line_pointer == ',')
                        {
                          ++input_line_pointer;
                          len = get_absolute_expression ();
                          if (beg + len > strlen (value))
                            {
                              as_bad (_("Invalid length (use 0 to %d"),
                                     strlen (value) - beg);
                              break;
                            }
                        }
                      newval += beg - 1;
                      newval[len] = 0;
                      tail = input_line_pointer;
                      if (*tail++ != ')')
                        {
                          as_bad (_("Missing ')' in subscripted substitution "
                                    "symbol expression"));
                          break;
                        }
                      c = *tail;
                      input_line_pointer = savedp;

                      value = newval;
                    }
                  name[-1] = 0;
                }
              tmp = xmalloc (strlen (head) + strlen (value) + 
                             strlen (tail+1) + 2);
              strcpy (tmp, head);
              strcat (tmp, value);
              /* Make sure forced substitutions are properly terminated */
              if (forced)
                {
                  if (c != ':')
                    {
                      as_bad (_("Missing forced substitution terminator ':'"));
                      break;
                    }
                  ++tail;
#if 0
                  /* Try to replace required whitespace 
                     eliminated by the preprocessor; technically, a forced
                     substitution could come anywhere, even mid-symbol,
                     e.g. if x is "0", 'sym:x:end' should result in 'sym0end',
                     but 'sym:x: end' should result in 'sym0 end'.
                     FIXME -- this should really be fixed in the preprocessor,
                     but would require several new states;
                     KEEP_WHITE_AROUND_COLON does part of the job, but isn't
                     complete 
                  */
                  if ((is_part_of_name (tail[1])
                       && tail[1] != '.'
                       && tail[1] != '$') 
                      || tail[1] == '\0' || tail[1] == ',' || tail[1] == '"')
                    ++tail;
                  else
                    *tail = ' ';
#endif
                }
              else
                /* restore the character after the symbol end */
                *tail = c;
              strcat (tmp, tail);
              /* continue examining after the replacement value */
              ptr = tmp + strlen (head) + strlen (value);
              free (replacement);
              head = replacement = tmp;
              changed = 1;
            }
          else
            *ptr = c;
        }
      else
        {
          ++ptr;
        }
    }

  if (changed)
    return replacement;
  else
    return line;
}

/* we use this to handle substitution symbols 
   hijack input_line_pointer, replacing it with our substituted string.

   .sslist should enable listing the line after replacements are made...

   returns the new buffer limit
*/
void
tic54x_start_line_hook ()
{
  char *line, *endp;
  char *replacement = NULL;

  /* work with a copy of the input line, including EOL char */
  endp = input_line_pointer;
  while (!is_end_of_line[(int)*endp++])
    ;
  line = xmalloc (endp - input_line_pointer + 1);
  strncpy (line, input_line_pointer, endp - input_line_pointer + 1);
  line[endp - input_line_pointer] = 0;

  /* scan ahead for parallel insns */
  parallel_on_next_line_hint = next_line_shows_parallel (endp + 1);

  /* if within a macro, first process forced replacements */
  if (macro_level > 0)
    replacement = subsym_substitute (line, 1);
  else
    replacement = line;
  replacement = subsym_substitute (replacement, 0);

  if (replacement != line)
    {
      char *tmp = replacement;
      char *comment = strchr (replacement,';');
      char endc = replacement[strlen (replacement)-1];

      /* clean up the replacement; we'd prefer to have this done by the
         standard preprocessing equipment (maybe do_scrub_chars?)
         but for now, do a quick-and-dirty
      */
      if (comment != NULL)
        {
          comment[0] = endc;
          comment[1] = 0;
          --comment;
        }
      else 
        comment = replacement + strlen (replacement) - 1;

      /* trim trailing whitespace */
      while (isspace (*comment))
        {
          comment[0] = endc;
          comment[1] = 0;
          --comment;
        }

      /* compact leading whitespace */
      while (isspace (tmp[0]) && isspace (tmp[1]))
        ++tmp;

      input_line_pointer = endp;
      input_scrub_insert_line (tmp);
      free (replacement);
      free (line);
      /* keep track of whether we've done a substitution */
      substitution_line = 1;
    }
  else
    {
      /* no change */
      free (line);
      substitution_line = 0;
    }
}

/* This is the guts of the machine-dependent assembler.  STR points to a
   machine dependent instruction.  This function is supposed to emit
   the frags/bytes it assembles to.
 */
void
md_assemble (line)
  char *line;
{
  static int repeat_slot = 0;
  static int delay_slots = 0; /* how many delay slots left to fill? */
  static int is_parallel = 0;
  static tic54x_insn insn;
  char *lptr;
  char *savedp = input_line_pointer;
  int c;

  input_line_pointer = line;
  c = get_symbol_end ();

  if (cpu == VNONE)
    cpu = V542;
  if (address_mode_needs_set)
    {
      set_address_mode (amode);
      address_mode_needs_set = 0;
    }
  if (cpu_needs_set)
    {
      set_cpu (cpu);
      cpu_needs_set = 0;
    }
  assembly_begun = 1;

  if (is_parallel)
    {
      is_parallel = 0;

      strcpy (insn.parmnemonic, line);
      lptr = input_line_pointer;
      *lptr = c;
      input_line_pointer = savedp;

      if (tic54x_parse_parallel_insn_lastline (&insn, lptr))
        {
          int words = build_insn (&insn);

          if (delay_slots != 0)
            {
              if (words > delay_slots)
                {
                  as_bad (_("Instruction does not fit in available delay "
                            "slots (%d-word insn, %d slots left)"), 
                            words, delay_slots);
                  delay_slots = 0;
                  return;
                }
              delay_slots -= words;
            }
        }
      return;
    }

  memset (&insn, 0, sizeof (insn));
  strcpy (insn.mnemonic, line);
  lptr = input_line_pointer;
  *lptr = c;
  input_line_pointer = savedp;
  
  /* See if this line is part of a parallel instruction; if so, either this
     line or the next line will have the "||" specifier preceding the
     mnemonic, and we look for it in the parallel insn hash table */
  if (strstr (line, "||") != NULL || parallel_on_next_line_hint)
    {
      char *tmp = strstr (line, "||");
      if (tmp != NULL)
        *tmp = '\0';

      if (tic54x_parse_parallel_insn_firstline (&insn, lptr))
        {
          is_parallel = 1;
          /* if the parallel part is on the same line, process it now,
             otherwise let the assembler pick up the next line for us */
          if (tmp != NULL)
            {
              while (isspace (tmp[2]))
                ++tmp;
              md_assemble (tmp+2);
            }
        }
      else
        {
          as_bad (_("Unrecognized parallel instruction '%s'"), line);
        }
      return;
    }

  if (tic54x_parse_insn (&insn, lptr))
    {
      int words;

      if ((insn.tm->flags & FL_LP) 
          && cpu != V545LP && cpu != V546LP)
        {
          as_bad (_("Instruction '%s' requires an LP cpu version"),
                  insn.tm->name);
          return;
        }
      if ((insn.tm->flags & FL_FAR) 
          && amode != far_mode)
        {
          as_bad (_("Instruction '%s' requires far mode addressing"),
                  insn.tm->name);
          return;
        }

      words = build_insn (&insn);

      /* Is this instruction in a delay slot? */
      if (delay_slots)
        {
          if (words > delay_slots)
            {
              as_warn (_("Instruction does not fit in available delay "
                         "slots (%d-word insn, %d slots left). "
                         "Resulting behavior is undefined."), 
                       words, delay_slots);
              delay_slots = 0;
              return;
            }
          /* branches in delay slots are not allowed */
          if (insn.tm->flags & FL_BMASK)
            {
              as_warn (_("Instructions which cause PC discontinuity are not "
                         "allowed in a delay slot. "
                         "Resulting behavior is undefined."));
            }
          delay_slots -= words;
        }
      /* Is this instruction the target of a repeat? */
      if (repeat_slot)
        {
          if (insn.tm->flags & FL_NR)
            as_warn (_("'%s' is not repeatable. "
                       "Resulting behavior is undefined."), 
                     insn.tm->name);
          else if (insn.is_lkaddr)
            as_warn (_("Instructions using long offset modifiers or absolute "
                       "addresses are not repeatable. "
                       "Resulting behavior is undefined."));
          repeat_slot = 0;
        }
      
      /* make sure we check the target of a repeat instruction */
      if (insn.tm->flags & B_REPEAT)
        {
          repeat_slot = 1;
          /* FIXME -- warn if repeat_slot == 1 at EOF */
        }
      /* make sure we check our delay slots for validity */
      if (insn.tm->flags & FL_DELAY)
        {
          delay_slots = 2;
          /* FIXME -- warn if delay_slots != 0 at EOF */
        }
    }
}

/* Do a final adjustment on the symbol table; in this case, make sure we have
   a ".file" symbol */
void
tic54x_adjust_symtab ()
{
  if (symbol_rootP == NULL
      || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
    {
      char *filename;
      unsigned lineno;
      as_where (&filename, &lineno);
      c_dot_file_symbol (filename);
    }
}

/* In order to get gas to ignore any | chars at the start of a line,
   this function returns true if a | is found in a line. 
   This lets us process parallel instructions, which span two lines
*/
int
tic54x_unrecognized_line (int c)
{
  return c == PARALLEL_SEPARATOR;
}

/* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*?
   Encode their names so that only we see them and can map them to the
   appropriate places.
   FIXME -- obviously this isn't done yet.  These locals still show up in the
   symbol table.
 */
void
tic54x_define_label (symbolS *sym)
{
  /*static int local_label_count = 0;*/
  /*const char *name = S_GET_NAME (sym);*/

  /* just in case we need this later; note that this is not necessarily the
     same thing as line_label... 
     When aligning or assigning labels to fields, sometimes the label is
     assigned other than the address at which the label appears.
     FIXME -- is this really needed? I think all the proper label assignment
     is done in tic54x_cons.
  */
  last_label_seen = sym;
}

/* Try to parse something that normal parsing failed at. */
symbolS *
tic54x_undefined_symbol (name)
     char *name;
{
  symbol *sym;

  /* not sure how to handle predefined symbols */
  if ((sym = (symbol *)hash_find (cc_hash, name)) != NULL ||
      (sym = (symbol *)hash_find (cc2_hash, name)) != NULL ||
      (sym = (symbol *)hash_find (cc3_hash, name)) != NULL ||
      (sym = (symbol *)hash_find (misc_symbol_hash, name)) != NULL ||
      (sym = (symbol *)hash_find (sbit_hash, name)) != NULL)
    {
      return symbol_new (name, reg_section, 
                         (valueT) sym->value,
                         &zero_address_frag);
    }

  if ((sym = (symbol *)hash_find (reg_hash, name)) != NULL ||
      (sym = (symbol *)hash_find (mmreg_hash, name)) != NULL ||
      !strcasecmp (name, "a") || !strcasecmp (name, "b"))
    {
      return symbol_new (name, reg_section, 
                         (valueT) sym ? sym->value : 0,
                         &zero_address_frag);
    }

  return NULL;
}

/* parse a name in an expression before the expression parser takes a stab at
   it */
int
tic54x_parse_name (name, exp)
     char *name ATTRIBUTE_UNUSED;
     expressionS *exp ATTRIBUTE_UNUSED;
{
#if 0
  symbol *sym = (symbol *)hash_find (mmreg_hash, name);
  /* if it's a MMREG, replace it with its constant value */
  if (sym)
    {
      exp->X_op = O_constant;
      exp->X_add_number = sym->value;
      return 1;
    }
#endif
  return 0;
}

char *
md_atof (type, literalP, sizeP)
     int type;
     char *literalP;
     int *sizeP;
{
#define MAX_LITTLENUMS 2
  LITTLENUM_TYPE words[MAX_LITTLENUMS];
  LITTLENUM_TYPE *word;
  /* only one precision on the c54x */
  int prec = 2;
  char *t = atof_ieee (input_line_pointer, type, words);
  if (t)
    input_line_pointer = t;
  *sizeP = 4;

  /* target data is little-endian, but floats are stored big-"word"ian.  ugh */
  for (word = words; prec--;)
    {
      md_number_to_chars (literalP, (long)(*word++), sizeof (LITTLENUM_TYPE));
      literalP += sizeof (LITTLENUM_TYPE);
    }

  return 0;
}

arelent *
tc_gen_reloc (section, fixP)
     asection *section;
     fixS *fixP;
{
  arelent *rel;
  bfd_reloc_code_real_type code = fixP->fx_r_type;
  asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy);

  rel = (arelent *) xmalloc (sizeof (arelent));
  rel->sym_ptr_ptr = (asymbol **)xmalloc (sizeof (asymbol *));
  *rel->sym_ptr_ptr = sym;
  /* We assume that all rel->address are host byte offsets */
  rel->address = fixP->fx_frag->fr_address + fixP->fx_where;
  rel->address /= OCTETS_PER_BYTE;
  rel->howto = bfd_reloc_type_lookup (stdoutput, code);
  if (!strcmp (sym->name, section->name))
    rel->howto += HOWTO_BANK;

  if (!rel->howto)
    {
      const char *name = S_GET_NAME (fixP->fx_addsy);
      if (name == NULL)
	name = "<unknown>";
      as_fatal ("Cannot generate relocation type for symbol %s, code %s", 
                name, bfd_get_reloc_code_name (code));
      return NULL;
    }
  return rel;
}

/* handle cons expressions */
void
tic54x_cons_fix_new (fragS *frag, int where, int octets, expressionS *exp)
{
  bfd_reloc_code_real_type r;
  switch (octets)
    {
    default:
      as_bad (_("Unsupported relocation size %d"), octets);
      r = BFD_RELOC_TIC54X_16_OF_23;
      break;
    case 2:
      r = BFD_RELOC_TIC54X_16_OF_23;
      break;
    case 4:
      /* TI assembler always uses this, regardless of addressing mode */
      if (emitting_long)
        r = BFD_RELOC_TIC54X_23;
      else
        /* we never want to directly generate this; this is provided for 
           stabs support only */
        r = BFD_RELOC_32;
      break;
    }
  fix_new_exp (frag, where, octets, exp, 0, r);
}

/* Attempt to simplify or even eliminate a fixup.  
   To indicate that a fixup has been eliminated, set fixP->fx_done.

   If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry.
   */
int
md_apply_fix (fixP, valP)
     fixS *fixP;
     valueT *valP;
{
  char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  valueT val = *valP;

  switch (fixP->fx_r_type)
    {
    default:
      as_fatal ("Bad relocation type: 0x%02x", fixP->fx_r_type);
      return 0;
    case BFD_RELOC_TIC54X_MS7_OF_23:
      val = (val >> 16) & 0x7F;
      /* fall through */
    case BFD_RELOC_TIC54X_16_OF_23:
    case BFD_RELOC_16:
      bfd_put_16 (stdoutput, val, buf);
      /* indicate what we're actually writing, so that we don't get warnings
         about exceeding available space */
      *valP = val & 0xFFFF;
      break;
    case BFD_RELOC_TIC54X_PARTLS7:
      bfd_put_16 (stdoutput,
                  (bfd_get_16 (stdoutput, buf) & 0xFF80) | (val & 0x7F),
                  buf);
      /* indicate what we're actually writing, so that we don't get warnings
         about exceeding available space */
      *valP = val & 0x7F;
      break;
    case BFD_RELOC_TIC54X_PARTMS9:
      /* TI assembler doesn't shift its encoding for relocatable files, and is
         thus incompatible with this implementation's relocatable files */ 
      bfd_put_16 (stdoutput, 
                  (bfd_get_16 (stdoutput, buf) & 0xFE00) | (val >> 7), 
                  buf);
      break;
    case BFD_RELOC_32:
    case BFD_RELOC_TIC54X_23:
      bfd_put_32 (stdoutput,
                  (bfd_get_32 (stdoutput, buf) & 0xFF800000) | val,
                  buf);
      break;
    }

  return 0; /* return value is ignored */
}

/* this is our chance to record section alignment 
   don't need to do anything here, since BFD does the proper encoding
 */
valueT
md_section_align (segment, section_size)
     segT segment ATTRIBUTE_UNUSED;
     valueT section_size;
{
  return section_size;
}

long
md_pcrel_from (fixP)
     fixS *fixP ATTRIBUTE_UNUSED;
{
  return 0;
}

#if defined OBJ_COFF

short
tc_coff_fix2rtype (fixP)
     fixS *fixP;
{
  return (fixP->fx_r_type);
}

#endif	/* OBJ_COFF */

/* mostly little-endian, but longwords (4 octets) get MS word stored first */
void
tic54x_number_to_chars (buf, val, n)
  char *buf;
  valueT val;
  int n;
{
  if (n != 4)
      number_to_chars_littleendian (buf, val, n);
  else
    {
      number_to_chars_littleendian (buf, val>>16, 2);
      number_to_chars_littleendian (buf+2, val&0xFFFF, 2);
    }
}

int 
tic54x_estimate_size_before_relax (frag, seg)
  fragS *frag ATTRIBUTE_UNUSED;
  segT seg ATTRIBUTE_UNUSED;
{
  return 0;
}

/* we use this to handle bit allocations which we couldn't handle before due
   to symbols being in different frags.  return number of octets added. */
int 
tic54x_relax_frag (frag, stretch)
  fragS *frag;
  long stretch ATTRIBUTE_UNUSED;
{
  symbolS *sym = frag->fr_symbol;
  int growth = 0;
  int i;

  if (sym != NULL)
    {
      struct bit_info *bi = (struct bit_info *)frag->fr_opcode;
      int bit_offset = frag_bit_offset (frag_prev (frag, bi->seg), bi->seg);
      int size = S_GET_VALUE (sym);
      fragS *prev_frag = bit_offset_frag (frag_prev (frag, bi->seg), bi->seg);
      int available = 16 - bit_offset;

      if (symbol_get_frag (sym) != &zero_address_frag
          || S_IS_COMMON (sym)
          || !S_IS_DEFINED (sym))
        as_bad_where (frag->fr_file, frag->fr_line,
                      _("non-absolute value used with .space/.bes"));

      if (size < 0)
        {
          as_warn (_("negative value ignored in %s"),
                   bi->type == TYPE_SPACE ? ".space" :
                   bi->type == TYPE_BES ? ".bes" : ".field");
          growth = 0;
          frag->tc_frag_data = frag->fr_fix = 0;
          return 0;
        }

      if (bi->type == TYPE_FIELD)
        {
          /* bit fields of 16 or larger will have already been handled */
          if (bit_offset != 0 && available >= size)
            {
              char *p = prev_frag->fr_literal;
              valueT value = bi->value;
              value <<= available - size;
              value |= ((unsigned short)p[1]<<8) | p[0];
              md_number_to_chars (p, value, 2);
              if ((prev_frag->tc_frag_data += size) == 16)
                prev_frag->tc_frag_data = 0;
              if (bi->sym)
                symbol_set_frag (bi->sym, prev_frag);
              /* this frag is no longer used */
              growth = -frag->fr_fix;
              frag->fr_fix = 0;
              frag->tc_frag_data = 0;
            }
          else
            {
              char *p = frag->fr_literal;
              valueT value = bi->value << (16 - size);
              md_number_to_chars (p, value, 2);
              if ((frag->tc_frag_data = size) == 16)
                frag->tc_frag_data = 0;
              growth = 0;
            }
        }
      else
        {
          if (bit_offset != 0 && bit_offset < 16)
            {
              if (available >= size)
                {
                  if ((prev_frag->tc_frag_data += size) == 16)
                    prev_frag->tc_frag_data = 0;
                  if (bi->sym)
                    symbol_set_frag (bi->sym, prev_frag);
                  /* this frag is no longer used */
                  growth = -frag->fr_fix;
                  frag->fr_fix = 0;
                  frag->tc_frag_data = 0;
                  goto getout;
                }
              if (bi->type == TYPE_SPACE && bi->sym)
                symbol_set_frag (bi->sym, prev_frag);
              size -= available;
            }
          growth = (size + 15) / 16 * OCTETS_PER_BYTE - frag->fr_fix;
          for (i=0;i < growth;i++)
            frag->fr_literal[i] = 0;
          frag->fr_fix = growth;
          frag->tc_frag_data = size % 16;
          /* make sure any BES label points to the LAST word allocated */
          if (bi->type == TYPE_BES && bi->sym)
            S_SET_VALUE (bi->sym, frag->fr_fix / OCTETS_PER_BYTE - 1);
        }
    getout:
      frag->fr_symbol = 0;
      frag->fr_opcode = 0;
      free ((void *)bi);
    }
  return growth;
}

void
tic54x_convert_frag (abfd, seg, frag)
  bfd *abfd ATTRIBUTE_UNUSED;
  segT seg ATTRIBUTE_UNUSED;
  fragS *frag;
{
  /* offset is in bytes */
  frag->fr_offset = (frag->fr_next->fr_address 
                     - frag->fr_address
                     - frag->fr_fix) / frag->fr_var;
  if (frag->fr_offset < 0)
    {
      as_bad_where (frag->fr_file, frag->fr_line,
                    _("attempt to .space/.bes backwards? (%ld)"),
                    (long) frag->fr_offset);
    }
  frag->fr_type = rs_space;
}

/* we need to avoid having labels defined for certain directives/pseudo-ops
   since once the label is defined, it's in the symbol table for good.  TI
   syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax,
   I guess, except I've never seen a definition of MRI syntax).

   C is the character that used to be at *REST, which points to the end of the
   label. 

   Don't allow labels to start with '.'
*/
int
tic54x_start_label (c, rest)
  int c;
  char *rest;
{
  /* if within .struct/.union, no auto line labels, please */
  if (current_stag != NULL)
    return 0;

  /* disallow labels starting with "." */
  if (c != ':')
    {
      char *label = rest;
      while (!is_end_of_line[(int)label[-1]])
        --label;
      if (*label == '.')
        {
          as_bad (_("Invalid label '%s'"), label);
          return 0;
        }
    }

  if (is_end_of_line[(int)c])
    return 1;

  if (isspace (c))
    while (isspace (c = *++rest))
      ;
  if (c == '.')
    {
      /* don't let colon () define a label for any of these... */
      return (strncasecmp (rest, ".tag", 4) != 0 || !isspace (rest[4]))
        && (strncasecmp (rest, ".struct", 7) != 0 || !isspace (rest[7]))
        && (strncasecmp (rest, ".union", 6) != 0 || !isspace (rest[6]))
        && (strncasecmp (rest, ".macro", 6) != 0 || !isspace (rest[6]))
        && (strncasecmp (rest, ".set", 4) != 0 || !isspace (rest[4]))
        && (strncasecmp (rest, ".equ", 4) != 0 || !isspace (rest[4]));
    }

  return 1;
}