Subversion Repositories open8_urisc

/* tc-tic4x.c -- Assemble for the Texas Instruments TMS320C[34]x.

   Copyright (C) 1997,1998, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010

   Free Software Foundation. Inc.

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

   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 3, 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, 51 Franklin Street - Fifth Floor,

   Boston, MA 02110-1301, USA.  */

/*

  TODOs:

  ------

  o .align cannot handle fill-data-width larger than 0xFF/8-bits. It

    should be possible to define a 32-bits pattern.

  o .align fills all section with NOP's when used regardless if has

    been used in .text or .data. (However the .align is primarily

    intended used in .text sections. If you require something else,

    use .align <size>,0x00)

  o .align: Implement a 'bu' insn if the number of nop's exceeds 4

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

    first.

  o .usect if has symbol on previous line not implemented

  o .sym, .eos, .stag, .etag, .member not implemented

  o Evaluation of constant floating point expressions (expr.c needs

    work!)

  o Support 'abc' constants (that is 0x616263)

*/

#include "safe-ctype.h"

#include "as.h"

#include "opcode/tic4x.h"

#include "subsegs.h"

#include "obstack.h"

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

   assembly tools.  With TIC4X_ALT_SYNTAX defined we are more

   flexible, allowing a more Unix-like syntax:  `%' in front of

   register names, `#' in front of immediate constants, and

   not requiring `@' in front of direct addresses.  */

#define TIC4X_ALT_SYNTAX

/* Equal to MAX_PRECISION in atof-ieee.c.  */

#define MAX_LITTLENUMS 6        /* (12 bytes) */

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

static struct hash_control *tic4x_op_hash = NULL;

/* Handle asg pseudo.  */

static struct hash_control *tic4x_asg_hash = NULL;

static unsigned int tic4x_cpu = 0;        /* Default to TMS320C40.  */

static unsigned int tic4x_revision = 0;   /* CPU revision */

static unsigned int tic4x_idle2 = 0;      /* Idle2 support */

static unsigned int tic4x_lowpower = 0;   /* Lowpower support */

static unsigned int tic4x_enhanced = 0;   /* Enhanced opcode support */

static unsigned int tic4x_big_model = 0;  /* Default to small memory model.  */

static unsigned int tic4x_reg_args = 0;   /* Default to args passed on stack.  */

static unsigned long tic4x_oplevel = 0;   /* Opcode level */

#define OPTION_CPU      'm'

#define OPTION_BIG      (OPTION_MD_BASE + 1)

#define OPTION_SMALL    (OPTION_MD_BASE + 2)

#define OPTION_MEMPARM  (OPTION_MD_BASE + 3)

#define OPTION_REGPARM  (OPTION_MD_BASE + 4)

#define OPTION_IDLE2    (OPTION_MD_BASE + 5)

#define OPTION_LOWPOWER (OPTION_MD_BASE + 6)

#define OPTION_ENHANCED (OPTION_MD_BASE + 7)

#define OPTION_REV      (OPTION_MD_BASE + 8)

CONST char *md_shortopts = "bm:prs";

struct option md_longopts[] =

{

  { "mcpu",   required_argument, NULL, OPTION_CPU },

  { "mdsp",   required_argument, NULL, OPTION_CPU },

  { "mbig",         no_argument, NULL, OPTION_BIG },

  { "msmall",       no_argument, NULL, OPTION_SMALL },

  { "mmemparm",     no_argument, NULL, OPTION_MEMPARM },

  { "mregparm",     no_argument, NULL, OPTION_REGPARM },

  { "midle2",       no_argument, NULL, OPTION_IDLE2 },

  { "mlowpower",    no_argument, NULL, OPTION_LOWPOWER },

  { "menhanced",    no_argument, NULL, OPTION_ENHANCED },

  { "mrev",   required_argument, NULL, OPTION_REV },

  { NULL, no_argument, NULL, 0 }

};

size_t md_longopts_size = sizeof (md_longopts);

typedef enum

  {

    M_UNKNOWN, M_IMMED, M_DIRECT, M_REGISTER, M_INDIRECT,

    M_IMMED_F, M_PARALLEL, M_HI

  }

tic4x_addr_mode_t;

typedef struct tic4x_operand

  {

    tic4x_addr_mode_t mode;     /* Addressing mode.  */

    expressionS expr;           /* Expression.  */

    int disp;                   /* Displacement for indirect addressing.  */

    int aregno;                 /* Aux. register number.  */

    LITTLENUM_TYPE fwords[MAX_LITTLENUMS];      /* Float immed. number.  */

  }

tic4x_operand_t;

typedef struct tic4x_insn

  {

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

    unsigned int in_use;        /* True if in_use.  */

    unsigned int parallel;      /* True if parallel instruction.  */

    unsigned int nchars;        /* This is always 4 for the C30.  */

    unsigned long opcode;       /* Opcode number.  */

    expressionS exp;            /* Expression required for relocation.  */

    int reloc;                  /* Relocation type required.  */

    int pcrel;                  /* True if relocation PC relative.  */

    char *pname;                /* Name of instruction in parallel.  */

    unsigned int num_operands;  /* Number of operands in total.  */

    tic4x_inst_t *inst;         /* Pointer to first template.  */

    tic4x_operand_t operands[TIC4X_OPERANDS_MAX];

  }

tic4x_insn_t;

static tic4x_insn_t the_insn;   /* Info about our instruction.  */

static tic4x_insn_t *insn = &the_insn;

static void tic4x_asg (int);

static void tic4x_bss (int);

static void tic4x_globl (int);

static void tic4x_cons (int);

static void tic4x_stringer (int);

static void tic4x_eval (int);

static void tic4x_newblock (int);

static void tic4x_sect (int);

static void tic4x_set (int);

static void tic4x_usect (int);

static void tic4x_version (int);

const pseudo_typeS

  md_pseudo_table[] =

{

  {"align", s_align_bytes, 32},

  {"ascii", tic4x_stringer, 1},

  {"asciz", tic4x_stringer, 0},

  {"asg", tic4x_asg, 0},

  {"block", s_space, 4},

  {"byte", tic4x_cons, 1},

  {"bss", tic4x_bss, 0},

  {"copy", s_include, 0},

  {"def", tic4x_globl, 0},

  {"equ", tic4x_set, 0},

  {"eval", tic4x_eval, 0},

  {"global", tic4x_globl, 0},

  {"globl", tic4x_globl, 0},

  {"hword", tic4x_cons, 2},

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

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

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

  {"newblock", tic4x_newblock, 0},

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

  {"set", tic4x_set, 0},

  {"sect", tic4x_sect, 1},       /* Define named section.  */

  {"space", s_space, 4},

  {"string", tic4x_stringer, 0},

  {"usect", tic4x_usect, 0},       /* Reserve space in uninit. named sect.  */

  {"version", tic4x_version, 0},

  {"word", tic4x_cons, 4},       /* .word allocates 4 bytes.  */

  {"xdef", tic4x_globl, 0},

  {NULL, 0, 0},

};

int md_short_jump_size = 4;

int md_long_jump_size = 4;

/* This array holds the chars that always start a comment.  If the

   pre-processor is disabled, these aren't very useful.  */

#ifdef TIC4X_ALT_SYNTAX

const char comment_chars[] = ";!";

#else

const char comment_chars[] = ";";

#endif

/* This array holds the chars that only start a comment at the beginning of

   a line.  If the line seems to have the form '# 123 filename'

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

   Note that input_file.c hand checks for '#' at the beginning of the

   first line of the input file.  This is because the compiler outputs

   #NO_APP at the beginning of its output.

   Also note that comments like this one will always work.  */

const char line_comment_chars[] = "#*";

/* We needed an unused char for line separation to work around the

   lack of macros, using sed and such.  */

const char line_separator_chars[] = "&";

/* Chars that can be used to separate mant from exp in floating point nums.  */

const char EXP_CHARS[] = "eE";

/* Chars that mean this number is a floating point constant.  */

/* As in 0f12.456 */

/* or    0d1.2345e12 */

const char FLT_CHARS[] = "fFilsS";

/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be

   changed in read.c.  Ideally it shouldn't have to know about it at

   all, but nothing is ideal around here.  */

/* Flonums returned here.  */

extern FLONUM_TYPE generic_floating_point_number;

/* Precision in LittleNums.  */

#define MAX_PRECISION (4)       /* Its a bit overkill for us, but the code

                                   requires it... */

#define S_PRECISION (1)         /* Short float constants 16-bit.  */

#define F_PRECISION (2)         /* Float and double types 32-bit.  */

#define E_PRECISION (4)         /* Extended precision, 64-bit (real 40-bit). */

#define GUARD (2)

/* Turn generic_floating_point_number into a real short/float/double.  */

static int

tic4x_gen_to_words (FLONUM_TYPE flonum, LITTLENUM_TYPE *words, int precision)

{

  int return_value = 0;

  LITTLENUM_TYPE *p;            /* Littlenum pointer.  */

  int mantissa_bits;            /* Bits in mantissa field.  */

  int exponent_bits;            /* Bits in exponent field.  */

  int exponent;

  unsigned int sone;            /* Scaled one.  */

  unsigned int sfract;          /* Scaled fraction.  */

  unsigned int smant;           /* Scaled mantissa.  */

  unsigned int tmp;

  unsigned int mover;           /* Mantissa overflow bits */

  unsigned int rbit;            /* Round bit. */

  int shift;                    /* Shift count.  */

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

     The code in this function is altered slightly to support floats

     with 31-bits mantissas, thus the documentation below may be a

     little bit inaccurate.

     By Michael P. Hayes <m.hayes@elec.canterbury.ac.nz>

     Here is how a generic floating point number is stored using

     flonums (an extension of bignums) where p is a pointer to an

     array of LITTLENUMs.

     For example 2e-3 is stored with exp = -4 and

     bits[0] = 0x0000

     bits[1] = 0x0000

     bits[2] = 0x4fde

     bits[3] = 0x978d

     bits[4] = 0x126e

     bits[5] = 0x0083

     with low = &bits[2], high = &bits[5], and leader = &bits[5].

     This number can be written as

     0x0083126e978d4fde.00000000 * 65536**-4  or

     0x0.0083126e978d4fde        * 65536**0   or

     0x0.83126e978d4fde          * 2**-8   = 2e-3

     Note that low points to the 65536**0 littlenum (bits[2]) and

     leader points to the most significant non-zero littlenum

     (bits[5]).

     TMS320C3X floating point numbers are a bit of a strange beast.

     The 32-bit flavour has the 8 MSBs representing the exponent in

     twos complement format (-128 to +127).  There is then a sign bit

     followed by 23 bits of mantissa.  The mantissa is expressed in

     twos complement format with the binary point after the most

     significant non sign bit.  The bit after the binary point is

     suppressed since it is the complement of the sign bit.  The

     effective mantissa is thus 24 bits.  Zero is represented by an

     exponent of -128.

     The 16-bit flavour has the 4 MSBs representing the exponent in

     twos complement format (-8 to +7).  There is then a sign bit

     followed by 11 bits of mantissa.  The mantissa is expressed in

     twos complement format with the binary point after the most

     significant non sign bit.  The bit after the binary point is

     suppressed since it is the complement of the sign bit.  The

     effective mantissa is thus 12 bits.  Zero is represented by an

     exponent of -8.  For example,

     number       norm mant m  x  e  s  i    fraction f

     +0.500 =>  1.00000000000 -1 -1  0  1  .00000000000   (1 + 0) * 2^(-1)

     +0.999 =>  1.11111111111 -1 -1  0  1  .11111111111   (1 + 0.99) * 2^(-1)

     +1.000 =>  1.00000000000  0  0  0  1  .00000000000   (1 + 0) * 2^(0)

     +1.500 =>  1.10000000000  0  0  0  1  .10000000000   (1 + 0.5) * 2^(0)

     +1.999 =>  1.11111111111  0  0  0  1  .11111111111   (1 + 0.9) * 2^(0)

     +2.000 =>  1.00000000000  1  1  0  1  .00000000000   (1 + 0) * 2^(1)

     +4.000 =>  1.00000000000  2  2  0  1  .00000000000   (1 + 0) * 2^(2)

     -0.500 =>  1.00000000000 -1 -1  1  0  .10000000000   (-2 + 0) * 2^(-2)

     -1.000 =>  1.00000000000  0 -1  1  0  .00000000000   (-2 + 0) * 2^(-1)

     -1.500 =>  1.10000000000  0  0  1  0  .10000000000   (-2 + 0.5) * 2^(0)

     -1.999 =>  1.11111111111  0  0  1  0  .00000000001   (-2 + 0.11) * 2^(0)

     -2.000 =>  1.00000000000  1  1  1  0  .00000000000   (-2 + 0) * 2^(0)

     -4.000 =>  1.00000000000  2  1  1  0  .00000000000   (-2 + 0) * 2^(1)

     where e is the exponent, s is the sign bit, i is the implied bit,

     and f is the fraction stored in the mantissa field.

     num = (1 + f) * 2^x   =  m * 2^e if s = 0

     num = (-2 + f) * 2^x  = -m * 2^e if s = 1

     where 0 <= f < 1.0  and 1.0 <= m < 2.0

     The fraction (f) and exponent (e) fields for the TMS320C3X format

     can be derived from the normalised mantissa (m) and exponent (x) using:

     f = m - 1, e = x       if s = 0

     f = 2 - m, e = x       if s = 1 and m != 1.0

     f = 0,     e = x - 1   if s = 1 and m = 1.0

     f = 0,     e = -8      if m = 0

     OK, the other issue we have to consider is rounding since the

     mantissa has a much higher potential precision than what we can

     represent.  To do this we add half the smallest storable fraction.

     We then have to renormalise the number to allow for overflow.

     To convert a generic flonum into a TMS320C3X floating point

     number, here's what we try to do....

     The first thing is to generate a normalised mantissa (m) where

     1.0 <= m < 2 and to convert the exponent from base 16 to base 2.

     We desire the binary point to be placed after the most significant

     non zero bit.  This process is done in two steps: firstly, the

     littlenum with the most significant non zero bit is located (this

     is done for us since leader points to this littlenum) and the

     binary point (which is currently after the LSB of the littlenum

     pointed to by low) is moved to before the MSB of the littlenum

     pointed to by leader.  This requires the exponent to be adjusted

     by leader - low + 1.  In the earlier example, the new exponent is

     thus -4 + (5 - 2 + 1) = 0 (base 65536).  We now need to convert

     the exponent to base 2 by multiplying the exponent by 16 (log2

     65536).  The exponent base 2 is thus also zero.

     The second step is to hunt for the most significant non zero bit

     in the leader littlenum.  We do this by left shifting a copy of

     the leader littlenum until bit 16 is set (0x10000) and counting

     the number of shifts, S, required.  The number of shifts then has to

     be added to correct the exponent (base 2).  For our example, this

     will require 9 shifts and thus our normalised exponent (base 2) is

     littlenum is 1, thus requiring 16 shifts.

     We now have to left shift the other littlenums by the same amount,

     propagating the shifted bits into the more significant littlenums.

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

     two or three littlenums, since the greatest number of mantissa

     bits required is 24 + 1 rounding bit.  While two littlenums

     provide 32 bits of precision, the most significant littlenum

     may only contain a single significant bit  and thus an extra

     littlenum is required.

     Denoting the number of bits in the fraction field as F, we require

     G = F + 2 bits (one extra bit is for rounding, the other gets

     suppressed).  Say we required S shifts to find the most

     significant bit in the leader littlenum, the number of left shifts

     required to move this bit into bit position G - 1 is L = G + S - 17.

     Note that this shift count may be negative for the short floating

     point flavour (where F = 11 and thus G = 13 and potentially S < 3).

     If L > 0 we have to shunt the next littlenum into position.  Bit

     15 (the MSB) of the next littlenum needs to get moved into position

     L - 1 (If L > 15 we need all the bits of this littlenum and

     some more from the next one.).  We subtract 16 from L and use this

     as the left shift count;  the resultant value we or with the

     previous result.  If L > 0, we repeat this operation.   */

  if (precision != S_PRECISION)

    words[1] = 0x0000;

  if (precision == E_PRECISION)

    words[2] = words[3] = 0x0000;

  /* 0.0e0 or NaN seen.  */

  if (flonum.low > flonum.leader  /* = 0.0e0 */

      || flonum.sign == 0) /* = NaN */

    {

      if(flonum.sign == 0)

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

      words[0] = 0x8000;

      return return_value;

    }

  if (flonum.sign == 'P')

    {

      /* +INF:  Replace with maximum float.  */

      if (precision == S_PRECISION)

        words[0] = 0x77ff;

      else

        {

          words[0] = 0x7f7f;

          words[1] = 0xffff;

        }

      if (precision == E_PRECISION)

        {

          words[2] = 0x7fff;

          words[3] = 0xffff;

        }

      return return_value;

    }

  else if (flonum.sign == 'N')

    {

      /* -INF:  Replace with maximum float.  */

      if (precision == S_PRECISION)

        words[0] = 0x7800;

      else

        words[0] = 0x7f80;

      if (precision == E_PRECISION)

        words[2] = 0x8000;

      return return_value;

    }

  exponent = (flonum.exponent + flonum.leader - flonum.low + 1) * 16;

  if (!(tmp = *flonum.leader))

    abort ();                   /* Hmmm.  */

  shift = 0;                     /* Find position of first sig. bit.  */

  while (tmp >>= 1)

    shift++;

  exponent -= (16 - shift);     /* Adjust exponent.  */

  if (precision == S_PRECISION) /* Allow 1 rounding bit.  */

    {

      exponent_bits = 4;

      mantissa_bits = 11;

    }

  else if(precision == F_PRECISION)

    {

      exponent_bits = 8;

      mantissa_bits = 23;

    }

  else /* E_PRECISION */

    {

      exponent_bits = 8;

      mantissa_bits = 31;

    }

  shift = mantissa_bits - shift;

  smant = 0;

  mover = 0;

  rbit = 0;

  /* Store the mantissa data into smant and the roundbit into rbit */

  for (p = flonum.leader; p >= flonum.low && shift > -16; p--)

    {

      tmp = shift >= 0 ? *p << shift : *p >> -shift;

      rbit = shift < 0 ? ((*p >> (-shift-1)) & 0x1) : 0;

      smant |= tmp;

      shift -= 16;

    }

  /* OK, we've got our scaled mantissa so let's round it up */

  if(rbit)

    {

      /* If the mantissa is going to overflow when added, lets store

         the extra bit in mover. -- A special case exists when

         mantissa_bits is 31 (E_PRECISION). Then the first test cannot

         be trusted, as result is host-dependent, thus the second

         test. */

      if( smant == ((unsigned)(1<<(mantissa_bits+1))-1)

          || smant == (unsigned)-1 )  /* This is to catch E_PRECISION cases */

        mover=1;

      smant++;

    }

  /* Get the scaled one value */

  sone = (1 << (mantissa_bits));

  /* The number may be unnormalised so renormalise it...  */

  if(mover)

    {

      smant >>= 1;

      smant |= sone; /* Insert the bit from mover into smant */

      exponent++;

    }

  /* The binary point is now between bit positions 11 and 10 or 23 and 22,

     i.e., between mantissa_bits - 1 and mantissa_bits - 2 and the

     bit at mantissa_bits - 1 should be set.  */

  if (!(sone&smant))

    abort ();                   /* Ooops.  */

  if (flonum.sign == '+')

    sfract = smant - sone;      /* smant - 1.0.  */

  else

    {

      /* This seems to work.  */

      if (smant == sone)

        {

          exponent--;

          sfract = 0;

        }

      else

        {

          sfract = -smant & (sone-1);   /* 2.0 - smant.  */

        }

      sfract |= sone;           /* Insert sign bit.  */

    }

  if (abs (exponent) >= (1 << (exponent_bits - 1)))

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

  /* Force exponent to fit in desired field width.  */

  exponent &= (1 << (exponent_bits)) - 1;

  if (precision == E_PRECISION)

    {

      /* Map the float part first (100% equal format as F_PRECISION) */

      words[0]  = exponent << (mantissa_bits+1-24);

      words[0] |= sfract >> 24;

      words[1]  = sfract >> 8;

      /* Map the mantissa in the next */

      words[2]  = sfract >> 16;

      words[3]  = sfract & 0xffff;

    }

  else

    {

      /* Insert the exponent data into the word */

      sfract |= exponent << (mantissa_bits+1);

      if (precision == S_PRECISION)

        words[0] = sfract;

      else

        {

          words[0] = sfract >> 16;

          words[1] = sfract & 0xffff;

        }

    }

  return return_value;

}

/* Returns pointer past text consumed.  */

static char *

tic4x_atof (char *str, char what_kind, LITTLENUM_TYPE *words)

{

  /* Extra bits for zeroed low-order bits.  The 1st MAX_PRECISION are

     zeroed, the last contain flonum bits.  */

  static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD];

  char *return_value;

  /* Number of 16-bit words in the format.  */

  int precision;

  FLONUM_TYPE save_gen_flonum;

  /* We have to save the generic_floating_point_number because it

     contains storage allocation about the array of LITTLENUMs where

     the value is actually stored.  We will allocate our own array of

     littlenums below, but have to restore the global one on exit.  */

  save_gen_flonum = generic_floating_point_number;

  return_value = str;

  generic_floating_point_number.low = bits + MAX_PRECISION;

  generic_floating_point_number.high = NULL;

  generic_floating_point_number.leader = NULL;

  generic_floating_point_number.exponent = 0;

  generic_floating_point_number.sign = '\0';

  /* Use more LittleNums than seems necessary: the highest flonum may

     have 15 leading 0 bits, so could be useless.  */

  memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION);

  switch (what_kind)

    {

    case 's':

    case 'S':

      precision = S_PRECISION;

      break;

    case 'd':

    case 'D':

    case 'f':

    case 'F':

      precision = F_PRECISION;

      break;

    case 'E':

    case 'e':

      precision = E_PRECISION;

      break;

    default:

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

      return (NULL);

    }

  generic_floating_point_number.high

    = generic_floating_point_number.low + precision - 1 + GUARD;

  if (atof_generic (&return_value, ".", EXP_CHARS,

                    &generic_floating_point_number))

    {

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

      return (NULL);

    }

  tic4x_gen_to_words (generic_floating_point_number,

                    words, precision);

  /* Restore the generic_floating_point_number's storage alloc (and

     everything else).  */

  generic_floating_point_number = save_gen_flonum;

  return return_value;

}

static void

tic4x_insert_reg (char *regname, int regnum)

{

  char buf[32];

  int i;

  symbol_table_insert (symbol_new (regname, reg_section, (valueT) regnum,

                                   &zero_address_frag));

  for (i = 0; regname[i]; i++)

    buf[i] = ISLOWER (regname[i]) ? TOUPPER (regname[i]) : regname[i];

  buf[i] = '\0';

  symbol_table_insert (symbol_new (buf, reg_section, (valueT) regnum,

                                   &zero_address_frag));

}

static void

tic4x_insert_sym (char *symname, int value)

{

  symbolS *symbolP;

  symbolP = symbol_new (symname, absolute_section,

                        (valueT) value, &zero_address_frag);

  SF_SET_LOCAL (symbolP);

  symbol_table_insert (symbolP);

}

static char *

tic4x_expression (char *str, expressionS *exp)

{

  char *s;

  char *t;

  t = input_line_pointer;       /* Save line pointer.  */

  input_line_pointer = str;

  expression (exp);

  s = input_line_pointer;

  input_line_pointer = t;       /* Restore line pointer.  */

  return s;                     /* Return pointer to where parsing stopped.  */

}

static char *

tic4x_expression_abs (char *str, offsetT *value)

{

  char *s;

  char *t;

  t = input_line_pointer;       /* Save line pointer.  */

  input_line_pointer = str;

  *value = get_absolute_expression ();

  s = input_line_pointer;

  input_line_pointer = t;       /* Restore line pointer.  */

  return s;

}

static void

tic4x_emit_char (char c, int b)

{

  expressionS exp;

  exp.X_op = O_constant;

  exp.X_add_number = c;

  emit_expr (&exp, b);

}

static void

tic4x_seg_alloc (char *name ATTRIBUTE_UNUSED,

                 segT seg ATTRIBUTE_UNUSED,

                 int size,

                 symbolS *symbolP)

{

  /* Note that the size is in words

     so we multiply it by 4 to get the number of bytes to allocate.  */

  /* If we have symbol:  .usect  ".fred", size etc.,

     the symbol needs to point to the first location reserved

     by the pseudo op.  */

  if (size)

    {

      char *p;

      p = frag_var (rs_fill, 1, 1, (relax_substateT) 0,

                    (symbolS *) symbolP,