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

/* tc-ft32.c -- Assemble code for ft32
   Copyright (C) 2008-2016 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

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

/* Contributed by Anthony Green <green@spindazzle.org>.  */

#include "as.h"
#include "safe-ctype.h"
#include "opcode/ft32.h"

extern const ft32_opc_info_t ft32_opc_info[128];

const char comment_chars[]        = "#";
const char line_separator_chars[] = ";";
const char line_comment_chars[]   = "#";

static int pending_reloc;
static struct hash_control *opcode_hash_control;

static valueT md_chars_to_number (char * buf, int n);

const pseudo_typeS md_pseudo_table[] =
{
  {0, 0, 0}
};

const char FLT_CHARS[] = "rRsSfFdDxXpP";
const char EXP_CHARS[] = "eE";

/* This function is called once, at assembler startup time.  It sets
   up the hash table with all the opcodes in it, and also initializes
   some aliases for compatibility with other assemblers.  */

void
md_begin (void)
{
  const ft32_opc_info_t *opcode;
  opcode_hash_control = hash_new ();

  /* Insert names into hash table.  */
  for (opcode = ft32_opc_info; opcode->name; opcode++)
    hash_insert (opcode_hash_control, opcode->name, (char *) opcode);

  bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
}

/* Parse an expression and then restore the input line pointer.  */

static char *
parse_exp_save_ilp (char *s, expressionS *op)
{
  char *save = input_line_pointer;

  input_line_pointer = s;
  expression (op);
  s = input_line_pointer;
  input_line_pointer = save;
  return s;
}

static int
parse_condition (char **ptr)
{
  char *s = *ptr;
  static const struct {
    const char *name;
    int bits;
  } ccs[] = {
    { "gt,"   , (2 << FT32_FLD_CR_BIT) | (5 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "gte,"  , (2 << FT32_FLD_CR_BIT) | (4 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "lt,"   , (2 << FT32_FLD_CR_BIT) | (4 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "lte,"  , (2 << FT32_FLD_CR_BIT) | (5 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "a,"    , (2 << FT32_FLD_CR_BIT) | (6 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "ae,"   , (2 << FT32_FLD_CR_BIT) | (1 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "be,"   , (2 << FT32_FLD_CR_BIT) | (6 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "b,"    , (2 << FT32_FLD_CR_BIT) | (1 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "nz,"   , (2 << FT32_FLD_CR_BIT) | (0 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "z,"    , (2 << FT32_FLD_CR_BIT) | (0 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "nc,"   , (2 << FT32_FLD_CR_BIT) | (1 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "c,"    , (2 << FT32_FLD_CR_BIT) | (1 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "no,"   , (2 << FT32_FLD_CR_BIT) | (2 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "o,"    , (2 << FT32_FLD_CR_BIT) | (2 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { "ns,"   , (2 << FT32_FLD_CR_BIT) | (3 << FT32_FLD_CB_BIT) | (0 << FT32_FLD_CV_BIT)},
    { "s,"    , (2 << FT32_FLD_CR_BIT) | (3 << FT32_FLD_CB_BIT) | (1 << FT32_FLD_CV_BIT)},
    { NULL, 0}
  }, *pc;

  for (pc = ccs; pc->name; pc++)
    {
      if (memcmp(pc->name, s, strlen(pc->name)) == 0)
        {
          *ptr += strlen(pc->name) - 1;
          return pc->bits;
        }
    }
  return -1;
}

static int
parse_decimal (char **ptr)
{
  int r = 0;
  char *s = *ptr;

  while (('0' <= *s) && (*s <= '9'))
    {
      r *= 10;
      r += (*s++ - '0');
    }
  *ptr = s;
  return r;
}

static int
parse_register_operand (char **ptr)
{
  int reg;
  char *s = *ptr;

  if (*s != '$')
    {
      as_bad (_("expecting register"));
      ignore_rest_of_line ();
      return -1;
    }
  if ((s[1] == 's') && (s[2] == 'p'))
    {
      reg = 31;
    }
  else if ((s[1] == 'c') && (s[2] == 'c'))
    {
      reg = 30;
    }
  else if ((s[1] == 'f') && (s[2] == 'p'))
    {
      reg = 29;
    }
  else if (s[1] == 'r')
    {
      reg = s[2] - '0';
      if ((reg < 0) || (reg > 9))
	{
	  as_bad (_("illegal register number"));
	  ignore_rest_of_line ();
	  return -1;
	}
      if ((reg == 1) || (reg == 2) || (reg == 3))
	{
	  int r2 = s[3] - '0';
	  if ((r2 >= 0) && (r2 <= 9))
	    {
	      reg = (reg * 10) + r2;
	      *ptr += 1;
	    }
	}
    }
  else
    {
      as_bad (_("illegal register number"));
      ignore_rest_of_line ();
      return -1;
    }

  *ptr += 3;

  return reg;
}

/* 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 (char *str)
{
  char *op_start;
  char *op_end;

  ft32_opc_info_t *opcode;
  char *output;
  int idx = 0;
  char pend;

  int nlen = 0;

  unsigned int b;
  int f;

  expressionS arg;

  /* Drop leading whitespace.  */
  while (*str == ' ')
    str++;

  /* Find the op code end.  */
  op_start = str;
  for (op_end = str;
       *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' ' && *op_end != '.';
       op_end++)
    nlen++;

  pend = *op_end;
  *op_end = 0;

  if (nlen == 0)
    as_bad (_("can't find opcode "));

  opcode = (ft32_opc_info_t *) hash_find (opcode_hash_control, op_start);
  *op_end = pend;

  if (opcode == NULL)
    {
      as_bad (_("unknown opcode %s"), op_start);
      return;
    }

  b = opcode->bits;
  f = opcode->fields;

  if (opcode->dw)
    {
      int dw;
      if (*op_end == '.')
        {
          switch (op_end[1])
            {
              case 'b':
                dw = 0;
                break;
              case 's':
                dw = 1;
                break;
              case 'l':
                dw = 2;
                break;
              default:
                as_bad (_("unknown width specifier '.%c'"), op_end[1]);
                return;
            }
          op_end += 2;
        }
      else
        {
          dw = 2; /* default is ".l" */
        }
      b |= dw << FT32_FLD_DW_BIT;
    }

  while (ISSPACE (*op_end))
    op_end++;

  output = frag_more (4);

  while (f)
    {
      int lobit = f & -f;
      if (f & lobit)
        {
          switch (lobit)
          {
          case  FT32_FLD_CBCRCV:
            b |= parse_condition( &op_end);
            break;
          case  FT32_FLD_CB:
            b |= parse_decimal (&op_end) << FT32_FLD_CB_BIT;
            break;
          case  FT32_FLD_R_D:
            b |= parse_register_operand (&op_end) << FT32_FLD_R_D_BIT;
            break;
          case  FT32_FLD_CR:
            b |= (parse_register_operand (&op_end) - 28) << FT32_FLD_CR_BIT;
            break;
          case  FT32_FLD_CV:
            b |= parse_decimal (&op_end) << FT32_FLD_CV_BIT;
            break;
          case  FT32_FLD_R_1:
            b |= parse_register_operand (&op_end) << FT32_FLD_R_1_BIT;
            break;
          case  FT32_FLD_RIMM:
            if (*op_end == '$')
              {
                b |= parse_register_operand (&op_end) << FT32_FLD_RIMM_BIT;
              }
            else
              {
                b |= 0x400 << FT32_FLD_RIMM_BIT;
                op_end = parse_exp_save_ilp (op_end, &arg);
                fix_new_exp (frag_now,
                             (output - frag_now->fr_literal),
                             2,
                             &arg,
                             0,
                             BFD_RELOC_FT32_10);
              }
            break;
          case  FT32_FLD_R_2:
            b |= parse_register_operand (&op_end) << FT32_FLD_R_2_BIT;
            break;
          case  FT32_FLD_K20:
            op_end = parse_exp_save_ilp (op_end, &arg);
            fix_new_exp (frag_now,
                         (output - frag_now->fr_literal),
                         3,
                         &arg,
                         0,
                         BFD_RELOC_FT32_20);
            break;
          case  FT32_FLD_PA:
            op_end = parse_exp_save_ilp (op_end, &arg);
            fix_new_exp (frag_now,
                         (output - frag_now->fr_literal),
                         3,
                         &arg,
                         0,
                         BFD_RELOC_FT32_18);
            break;
          case  FT32_FLD_AA:
            op_end = parse_exp_save_ilp (op_end, &arg);
            fix_new_exp (frag_now,
                         (output - frag_now->fr_literal),
                         3,
                         &arg,
                         0,
                         BFD_RELOC_FT32_17);
            break;
          case  FT32_FLD_K16:
            op_end = parse_exp_save_ilp (op_end, &arg);
            fix_new_exp (frag_now,
                         (output - frag_now->fr_literal),
                         2,
                         &arg,
                         0,
                         BFD_RELOC_16);
            break;
          case  FT32_FLD_K8:
            op_end = parse_exp_save_ilp (op_end, &arg);
            fix_new_exp (frag_now,
                         (output - frag_now->fr_literal),
                         1,
                         &arg,
                         0,
                         BFD_RELOC_8);
            break;
          case  FT32_FLD_R_D_POST:
            b |= parse_register_operand (&op_end) << FT32_FLD_R_D_BIT;
            break;
          case  FT32_FLD_R_1_POST:
            b |= parse_register_operand (&op_end) << FT32_FLD_R_1_BIT;
            break;
          default:
            as_bad (_("internal error in argument parsing"));
            break;
          }
          f &= ~lobit;
          if (f)
            {
              while (ISSPACE (*op_end))
                op_end++;

              if (*op_end != ',')
                {
                  as_bad (_("expected comma separator"));
                  ignore_rest_of_line ();
                }

              op_end++;
              while (ISSPACE (*op_end))
                op_end++;
            }
        }
    }
  if (*op_end != 0)
    as_warn (_("extra stuff on line ignored"));

  output[idx++] = 0xff & (b >> 0);
  output[idx++] = 0xff & (b >> 8);
  output[idx++] = 0xff & (b >> 16);
  output[idx++] = 0xff & (b >> 24);

  dwarf2_emit_insn (4);

  while (ISSPACE (*op_end))
    op_end++;

  if (*op_end != 0)
    as_warn ("extra stuff on line ignored");

  if (pending_reloc)
    as_bad ("Something forgot to clean up\n");
}

/* Turn a string in input_line_pointer into a floating point constant
   of type type, and store the appropriate bytes in *LITP.  The number
   of LITTLENUMS emitted is stored in *SIZEP .  An error message is
   returned, or NULL on OK.  */

const char *
md_atof (int type, char *litP, int *sizeP)
{
  int prec;
  LITTLENUM_TYPE words[4];
  char *t;
  int i;

  switch (type)
    {
    case 'f':
      prec = 2;
      break;

    case 'd':
      prec = 4;
      break;

    default:
      *sizeP = 0;
      return _("bad call to md_atof");
    }

  t = atof_ieee (input_line_pointer, type, words);
  if (t)
    input_line_pointer = t;

  *sizeP = prec * 2;

  for (i = prec - 1; i >= 0; i--)
    {
      md_number_to_chars (litP, (valueT) words[i], 2);
      litP += 2;
    }

  return NULL;
}
\f
const char *md_shortopts = "";

struct option md_longopts[] =
{
  {NULL, no_argument, NULL, 0}
};
size_t md_longopts_size = sizeof (md_longopts);

/* We have no target specific options yet, so these next
   two functions are empty.  */
int
md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED)
{
  return 0;
}

void
md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
{
}

/* Convert from target byte order to host byte order.  */

static valueT
md_chars_to_number (char * buf, int n)
{
  valueT result = 0;
  unsigned char * where = (unsigned char *) buf;

  while (n--)
    {
      result <<= 8;
      result |= (where[n] & 255);
    }

  return result;
}
/* Apply a fixup to the object file.  */

void
md_apply_fix (fixS *fixP ATTRIBUTE_UNUSED,
	      valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
{
  char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  long val = *valP;
  long newval;

  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_32:
      buf[3] = val >> 24;
      buf[2] = val >> 16;
      buf[1] = val >> 8;
      buf[0] = val >> 0;
      break;

    case BFD_RELOC_16:
      buf[1] = val >> 8;
      buf[0] = val >> 0;
      break;

    case BFD_RELOC_8:
      *buf = val;
      break;

    case BFD_RELOC_FT32_10:
      if (!val)
	break;
      newval = md_chars_to_number (buf, 2);
      newval |= (val & ((1 << 10) - 1)) << FT32_FLD_RIMM_BIT;
      md_number_to_chars (buf, newval, 2);
      break;

    case BFD_RELOC_FT32_20:
      if (!val)
	break;
      newval = md_chars_to_number (buf, 3);
      newval |= val & ((1 << 20) - 1);
      md_number_to_chars (buf, newval, 3);
      break;

    case BFD_RELOC_FT32_17:
      if (!val)
	break;
      newval = md_chars_to_number (buf, 3);
      newval |= val & ((1 << 17) - 1);
      md_number_to_chars (buf, newval, 3);
      break;

    case BFD_RELOC_FT32_18:
      if (!val)
	break;
      newval = md_chars_to_number (buf, 4);
      newval |= (val >> 2) & ((1 << 18) - 1);
      md_number_to_chars (buf, newval, 4);
      break;

    default:
      abort ();
    }

  if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
    fixP->fx_done = 1;
  // printf("fx_addsy=%p fixP->fx_pcrel=%d fx_done=%d\n", fixP->fx_addsy, fixP->fx_pcrel, fixP->fx_done);
}

void
md_number_to_chars (char *ptr, valueT use, int nbytes)
{
  number_to_chars_littleendian (ptr, use, nbytes);
}

/* Generate a machine-dependent relocation.  */
arelent *
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
{
  arelent *relP;
  bfd_reloc_code_real_type code;

  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_32:
    case BFD_RELOC_16:
    case BFD_RELOC_8:
    case BFD_RELOC_FT32_10:
    case BFD_RELOC_FT32_20:
    case BFD_RELOC_FT32_17:
    case BFD_RELOC_FT32_18:
      code = fixP->fx_r_type;
      break;
    default:
      as_bad_where (fixP->fx_file, fixP->fx_line,
		    _("Semantics error.  This type of operand can not be relocated, it must be an assembly-time constant"));
      return 0;
    }

  relP = XNEW (arelent);
  gas_assert (relP != 0);
  relP->sym_ptr_ptr = XNEW (asymbol *);
  *relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
  relP->address = fixP->fx_frag->fr_address + fixP->fx_where;

  relP->addend = fixP->fx_offset;

  relP->howto = bfd_reloc_type_lookup (stdoutput, code);
  if (! relP->howto)
    {
      const char *name;

      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 relP;
}
Commit	Line	Data
3f8107ab	1	/* tc-ft32.c -- Assemble code for ft32
6f2750fe	2	Copyright (C) 2008-2016 Free Software Foundation, Inc.
3f8107ab AM	3
	4	This file is part of GAS, the GNU Assembler.
	5
	6	GAS is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3, or (at your option)
	9	any later version.
	10
	11	GAS is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GAS; see the file COPYING. If not, write to
	18	the Free Software Foundation, 51 Franklin Street - Fifth Floor,
	19	Boston, MA 02110-1301, USA. */
	20
	21	/* Contributed by Anthony Green <green@spindazzle.org>. */
	22
	23	#include "as.h"
	24	#include "safe-ctype.h"
	25	#include "opcode/ft32.h"
	26
	27	extern const ft32_opc_info_t ft32_opc_info[128];
	28
	29	const char comment_chars[] = "#";
	30	const char line_separator_chars[] = ";";
	31	const char line_comment_chars[] = "#";
	32
	33	static int pending_reloc;
	34	static struct hash_control *opcode_hash_control;
	35
	36	static valueT md_chars_to_number (char * buf, int n);
	37
	38	const pseudo_typeS md_pseudo_table[] =
	39	{
	40	{0, 0, 0}
	41	};
	42
	43	const char FLT_CHARS[] = "rRsSfFdDxXpP";
	44	const char EXP_CHARS[] = "eE";
	45
	46	/* This function is called once, at assembler startup time. It sets
	47	up the hash table with all the opcodes in it, and also initializes
	48	some aliases for compatibility with other assemblers. */
	49
	50	void
	51	md_begin (void)
	52	{
	53	const ft32_opc_info_t *opcode;
	54	opcode_hash_control = hash_new ();
	55
	56	/* Insert names into hash table. */
	57	for (opcode = ft32_opc_info; opcode->name; opcode++)
	58	hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
	59
	60	bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
	61	}
	62
	63	/* Parse an expression and then restore the input line pointer. */
	64
	65	static char *
	66	parse_exp_save_ilp (char s, expressionS op)
67	{
68	char *save = input_line_pointer;
69
70	input_line_pointer = s;
71	expression (op);
72	s = input_line_pointer;
73	input_line_pointer = save;
74	return s;
75	}
76
77	static int
78	parse_condition (char **ptr)
79	{
80	char s = ptr;
81	static const struct {
e0471c16	82	const char *name;
3f8107ab AM	83	int bits;
	84	} ccs[] = {
	85	{ "gt," , (2 << FT32_FLD_CR_BIT) \| (5 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	86	{ "gte," , (2 << FT32_FLD_CR_BIT) \| (4 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	87	{ "lt," , (2 << FT32_FLD_CR_BIT) \| (4 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	88	{ "lte," , (2 << FT32_FLD_CR_BIT) \| (5 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	89	{ "a," , (2 << FT32_FLD_CR_BIT) \| (6 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	90	{ "ae," , (2 << FT32_FLD_CR_BIT) \| (1 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	91	{ "be," , (2 << FT32_FLD_CR_BIT) \| (6 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	92	{ "b," , (2 << FT32_FLD_CR_BIT) \| (1 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	93	{ "nz," , (2 << FT32_FLD_CR_BIT) \| (0 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	94	{ "z," , (2 << FT32_FLD_CR_BIT) \| (0 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	95	{ "nc," , (2 << FT32_FLD_CR_BIT) \| (1 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	96	{ "c," , (2 << FT32_FLD_CR_BIT) \| (1 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	97	{ "no," , (2 << FT32_FLD_CR_BIT) \| (2 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	98	{ "o," , (2 << FT32_FLD_CR_BIT) \| (2 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	99	{ "ns," , (2 << FT32_FLD_CR_BIT) \| (3 << FT32_FLD_CB_BIT) \| (0 << FT32_FLD_CV_BIT)},
	100	{ "s," , (2 << FT32_FLD_CR_BIT) \| (3 << FT32_FLD_CB_BIT) \| (1 << FT32_FLD_CV_BIT)},
	101	{ NULL, 0}
	102	}, *pc;
	103
	104	for (pc = ccs; pc->name; pc++)
	105	{
	106	if (memcmp(pc->name, s, strlen(pc->name)) == 0)
	107	{
	108	*ptr += strlen(pc->name) - 1;
	109	return pc->bits;
	110	}
	111	}
	112	return -1;
	113	}
	114
	115	static int
	116	parse_decimal (char **ptr)
	117	{
	118	int r = 0;
	119	char s = ptr;
	120
	121	while (('0' <= s) && (s <= '9'))
	122	{
	123	r *= 10;
	124	r += (*s++ - '0');
	125	}
	126	*ptr = s;
	127	return r;
	128	}
	129
	130	static int
	131	parse_register_operand (char **ptr)
	132	{
	133	int reg;
	134	char s = ptr;
	135
	136	if (*s != '$')
	137	{
	138	as_bad (_("expecting register"));
	139	ignore_rest_of_line ();
	140	return -1;
	141	}
	142	if ((s[1] == 's') && (s[2] == 'p'))
	143	{
	144	reg = 31;
	145	}
	146	else if ((s[1] == 'c') && (s[2] == 'c'))
147	{
148	reg = 30;
149	}
150	else if ((s[1] == 'f') && (s[2] == 'p'))
151	{
152	reg = 29;
153	}
154	else if (s[1] == 'r')
155	{
156	reg = s[2] - '0';
157	if ((reg < 0) \|\| (reg > 9))
158	{
159	as_bad (_("illegal register number"));
160	ignore_rest_of_line ();
161	return -1;
162	}
163	if ((reg == 1) \|\| (reg == 2) \|\| (reg == 3))
164	{
165	int r2 = s[3] - '0';
166	if ((r2 >= 0) && (r2 <= 9))
167	{
168	reg = (reg * 10) + r2;
169	*ptr += 1;
170	}
171	}
172	}
173	else
174	{
175	as_bad (_("illegal register number"));
176	ignore_rest_of_line ();
177	return -1;
178	}
179
180	*ptr += 3;
181
182	return reg;
183	}
184
185	/* This is the guts of the machine-dependent assembler. STR points to
186	a machine dependent instruction. This function is supposed to emit
187	the frags/bytes it assembles to. */
188
189	void
190	md_assemble (char *str)
191	{
192	char *op_start;
193	char *op_end;
194
195	ft32_opc_info_t *opcode;
196	char *output;
197	int idx = 0;
198	char pend;
199
200	int nlen = 0;
201
202	unsigned int b;
203	int f;
204
205	expressionS arg;
206
207	/* Drop leading whitespace. */
208	while (*str == ' ')
209	str++;
210
211	/* Find the op code end. */
212	op_start = str;
213	for (op_end = str;
214	op_end && !is_end_of_line[op_end & 0xff] && op_end != ' ' && op_end != '.';
215	op_end++)
216	nlen++;
217
218	pend = *op_end;
219	*op_end = 0;
220
221	if (nlen == 0)
222	as_bad (_("can't find opcode "));
223
224	opcode = (ft32_opc_info_t *) hash_find (opcode_hash_control, op_start);
225	*op_end = pend;
226
227	if (opcode == NULL)
228	{
229	as_bad (_("unknown opcode %s"), op_start);
230	return;
231	}
232
233	b = opcode->bits;
234	f = opcode->fields;
235
236	if (opcode->dw)
237	{
238	int dw;
239	if (*op_end == '.')
240	{
241	switch (op_end[1])
242	{
243	case 'b':
244	dw = 0;
245	break;
246	case 's':
247	dw = 1;
248	break;
249	case 'l':
250	dw = 2;
251	break;
252	default:
253	as_bad (_("unknown width specifier '.%c'"), op_end[1]);
254	return;
255	}
256	op_end += 2;
257	}
258	else
259	{
260	dw = 2; /* default is ".l" */
261	}
262	b \|= dw << FT32_FLD_DW_BIT;
263	}
264
265	while (ISSPACE (*op_end))
266	op_end++;
267
268	output = frag_more (4);
269
270	while (f)
271	{
272	int lobit = f & -f;
273	if (f & lobit)
274	{
275	switch (lobit)
276	{
277	case FT32_FLD_CBCRCV:
278	b \|= parse_condition( &op_end);
279	break;
280	case FT32_FLD_CB:
281	b \|= parse_decimal (&op_end) << FT32_FLD_CB_BIT;
282	break;
283	case FT32_FLD_R_D:
284	b \|= parse_register_operand (&op_end) << FT32_FLD_R_D_BIT;
285	break;
286	case FT32_FLD_CR:
287	b \|= (parse_register_operand (&op_end) - 28) << FT32_FLD_CR_BIT;
288	break;
289	case FT32_FLD_CV:
290	b \|= parse_decimal (&op_end) << FT32_FLD_CV_BIT;
291	break;
292	case FT32_FLD_R_1:
293	b \|= parse_register_operand (&op_end) << FT32_FLD_R_1_BIT;
294	break;
295	case FT32_FLD_RIMM:
296	if (*op_end == '$')
297	{
298	b \|= parse_register_operand (&op_end) << FT32_FLD_RIMM_BIT;
299	}
300	else
301	{
302	b \|= 0x400 << FT32_FLD_RIMM_BIT;
303	op_end = parse_exp_save_ilp (op_end, &arg);
304	fix_new_exp (frag_now,
305	(output - frag_now->fr_literal),
306	2,
307	&arg,
308	0,
309	BFD_RELOC_FT32_10);
310	}
311	break;
312	case FT32_FLD_R_2:
313	b \|= parse_register_operand (&op_end) << FT32_FLD_R_2_BIT;
314	break;
315	case FT32_FLD_K20:
316	op_end = parse_exp_save_ilp (op_end, &arg);
317	fix_new_exp (frag_now,
318	(output - frag_now->fr_literal),
319	3,
320	&arg,
321	0,
322	BFD_RELOC_FT32_20);
323	break;
324	case FT32_FLD_PA:
325	op_end = parse_exp_save_ilp (op_end, &arg);
326	fix_new_exp (frag_now,
327	(output - frag_now->fr_literal),
328	3,
329	&arg,
330	0,
331	BFD_RELOC_FT32_18);
332	break;
333	case FT32_FLD_AA:
334	op_end = parse_exp_save_ilp (op_end, &arg);
335	fix_new_exp (frag_now,
336	(output - frag_now->fr_literal),
337	3,
338	&arg,
339	0,
340	BFD_RELOC_FT32_17);
341	break;
342	case FT32_FLD_K16:
343	op_end = parse_exp_save_ilp (op_end, &arg);
344	fix_new_exp (frag_now,
345	(output - frag_now->fr_literal),
346	2,
347	&arg,
348	0,
349	BFD_RELOC_16);
350	break;
351	case FT32_FLD_K8:
352	op_end = parse_exp_save_ilp (op_end, &arg);
353	fix_new_exp (frag_now,
354	(output - frag_now->fr_literal),
355	1,
356	&arg,
357	0,
358	BFD_RELOC_8);
359	break;
360	case FT32_FLD_R_D_POST:
361	b \|= parse_register_operand (&op_end) << FT32_FLD_R_D_BIT;
362	break;
363	case FT32_FLD_R_1_POST:
364	b \|= parse_register_operand (&op_end) << FT32_FLD_R_1_BIT;
365	break;
366	default:
367	as_bad (_("internal error in argument parsing"));
368	break;
369	}
370	f &= ~lobit;
371	if (f)
372	{
373	while (ISSPACE (*op_end))
374	op_end++;
375
376	if (*op_end != ',')
377	{
378	as_bad (_("expected comma separator"));
379	ignore_rest_of_line ();
380	}
381
382	op_end++;
383	while (ISSPACE (*op_end))
384	op_end++;
385	}
386	}
387	}
388	if (*op_end != 0)
389	as_warn (_("extra stuff on line ignored"));
390
391	output[idx++] = 0xff & (b >> 0);
392	output[idx++] = 0xff & (b >> 8);
393	output[idx++] = 0xff & (b >> 16);
394	output[idx++] = 0xff & (b >> 24);
395
3ee6e4fb NC	396	dwarf2_emit_insn (4);
3ee6e4fb NC	397
3f8107ab AM	398	while (ISSPACE (*op_end))
	399	op_end++;
	400
	401	if (*op_end != 0)
	402	as_warn ("extra stuff on line ignored");
	403
	404	if (pending_reloc)
	405	as_bad ("Something forgot to clean up\n");
	406	}
	407
	408	/* Turn a string in input_line_pointer into a floating point constant
	409	of type type, and store the appropriate bytes in *LITP. The number
	410	of LITTLENUMS emitted is stored in *SIZEP . An error message is
	411	returned, or NULL on OK. */
	412
6d4af3c2	413	const char *
3f8107ab AM	414	md_atof (int type, char litP, int sizeP)
	415	{
	416	int prec;
	417	LITTLENUM_TYPE words[4];
	418	char *t;
	419	int i;
	420
	421	switch (type)
	422	{
	423	case 'f':
	424	prec = 2;
	425	break;
	426
	427	case 'd':
	428	prec = 4;
	429	break;
	430
	431	default:
	432	*sizeP = 0;
	433	return _("bad call to md_atof");
	434	}
	435
	436	t = atof_ieee (input_line_pointer, type, words);
	437	if (t)
	438	input_line_pointer = t;
	439
	440	sizeP = prec 2;
	441
	442	for (i = prec - 1; i >= 0; i--)
	443	{
	444	md_number_to_chars (litP, (valueT) words[i], 2);
	445	litP += 2;
	446	}
	447
	448	return NULL;
	449	}
	450	\f
	451	const char *md_shortopts = "";
	452
	453	struct option md_longopts[] =
	454	{
	455	{NULL, no_argument, NULL, 0}
	456	};
	457	size_t md_longopts_size = sizeof (md_longopts);
	458
	459	/* We have no target specific options yet, so these next
	460	two functions are empty. */
	461	int
17b9d67d	462	md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED)
3f8107ab AM	463	{
	464	return 0;
	465	}
	466
	467	void
	468	md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
	469	{
	470	}
	471
	472	/* Convert from target byte order to host byte order. */
	473
	474	static valueT
	475	md_chars_to_number (char * buf, int n)
	476	{
	477	valueT result = 0;
	478	unsigned char * where = (unsigned char *) buf;
	479
	480	while (n--)
	481	{
	482	result <<= 8;
	483	result \|= (where[n] & 255);
	484	}
	485
	486	return result;
	487	}
	488	/* Apply a fixup to the object file. */
	489
	490	void
	491	md_apply_fix (fixS *fixP ATTRIBUTE_UNUSED,
	492	valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
	493	{
	494	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
	495	long val = *valP;
	496	long newval;
	497
	498	switch (fixP->fx_r_type)
	499	{
	500	case BFD_RELOC_32:
	501	buf[3] = val >> 24;
	502	buf[2] = val >> 16;
	503	buf[1] = val >> 8;
	504	buf[0] = val >> 0;
	505	break;
	506
	507	case BFD_RELOC_16:
	508	buf[1] = val >> 8;
	509	buf[0] = val >> 0;
	510	break;
	511
	512	case BFD_RELOC_8:
	513	*buf = val;
	514	break;
	515
	516	case BFD_RELOC_FT32_10:
	517	if (!val)
	518	break;
	519	newval = md_chars_to_number (buf, 2);
	520	newval \|= (val & ((1 << 10) - 1)) << FT32_FLD_RIMM_BIT;
	521	md_number_to_chars (buf, newval, 2);
	522	break;
	523
	524	case BFD_RELOC_FT32_20:
	525	if (!val)
	526	break;
527	newval = md_chars_to_number (buf, 3);
528	newval \|= val & ((1 << 20) - 1);
529	md_number_to_chars (buf, newval, 3);
530	break;
531
532	case BFD_RELOC_FT32_17:
533	if (!val)
534	break;
535	newval = md_chars_to_number (buf, 3);
536	newval \|= val & ((1 << 17) - 1);
537	md_number_to_chars (buf, newval, 3);
538	break;
539
540	case BFD_RELOC_FT32_18:
541	if (!val)
542	break;
543	newval = md_chars_to_number (buf, 4);
544	newval \|= (val >> 2) & ((1 << 18) - 1);
545	md_number_to_chars (buf, newval, 4);
546	break;
547
548	default:
549	abort ();
550	}
551
552	if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
553	fixP->fx_done = 1;
554	// printf("fx_addsy=%p fixP->fx_pcrel=%d fx_done=%d\n", fixP->fx_addsy, fixP->fx_pcrel, fixP->fx_done);
555	}
556
557	void
558	md_number_to_chars (char *ptr, valueT use, int nbytes)
559	{
560	number_to_chars_littleendian (ptr, use, nbytes);
561	}
562
563	/* Generate a machine-dependent relocation. */
564	arelent *
565	tc_gen_reloc (asection section ATTRIBUTE_UNUSED, fixS fixP)
566	{
567	arelent *relP;
568	bfd_reloc_code_real_type code;
569
570	switch (fixP->fx_r_type)
571	{
572	case BFD_RELOC_32:
573	case BFD_RELOC_16:
574	case BFD_RELOC_8:
575	case BFD_RELOC_FT32_10:
576	case BFD_RELOC_FT32_20:
577	case BFD_RELOC_FT32_17:
578	case BFD_RELOC_FT32_18:
579	code = fixP->fx_r_type;
580	break;
581	default:
582	as_bad_where (fixP->fx_file, fixP->fx_line,
583	_("Semantics error. This type of operand can not be relocated, it must be an assembly-time constant"));
584	return 0;
585	}
586
325801bd	587	relP = XNEW (arelent);
3f8107ab	588	gas_assert (relP != 0);
325801bd	589	relP->sym_ptr_ptr = XNEW (asymbol *);
3f8107ab AM	590	*relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
	591	relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
	592
	593	relP->addend = fixP->fx_offset;
	594
	595	relP->howto = bfd_reloc_type_lookup (stdoutput, code);
	596	if (! relP->howto)
	597	{
	598	const char *name;
	599
	600	name = S_GET_NAME (fixP->fx_addsy);
	601	if (name == NULL)
	602	name = _("<unknown>");
	603	as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
	604	name, bfd_get_reloc_code_name (code));
	605	}
	606
	607	return relP;
	608	}