[thirdparty/binutils-gdb.git] / gas / config / tc-moxie.c

/* tc-moxie.c -- Assemble code for moxie
   Copyright (C) 2009-2021 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@moxielogic.com>.  */

#include "as.h"
#include "safe-ctype.h"
#include "opcode/moxie.h"
#include "elf/moxie.h"

extern const moxie_opc_info_t moxie_opc_info[128];

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

static int pending_reloc;
static htab_t opcode_hash_control;

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

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

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

/* Byte order.  */
extern int target_big_endian;

void
md_operand (expressionS *op __attribute__((unused)))
{
  /* Empty for now. */
}

/* 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)
{
  int count;
  const moxie_opc_info_t *opcode;
  opcode_hash_control = str_htab_create ();

  /* Insert names into hash table.  */
  for (count = 0, opcode = moxie_form1_opc_info; count++ < 64; opcode++)
    str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);

  for (count = 0, opcode = moxie_form2_opc_info; count++ < 4; opcode++)
    str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);

  for (count = 0, opcode = moxie_form3_opc_info; count++ < 10; opcode++)
    str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);

  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_register_operand (char **ptr)
{
  int reg;
  char *s = *ptr;

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

  *ptr += 3;

  return reg + 2;
}

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

  moxie_opc_info_t *opcode;
  char *p;
  char pend;

  unsigned short iword = 0;

  int nlen = 0;

  /* 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++)
    nlen++;

  pend = *op_end;
  *op_end = 0;

  if (nlen == 0)
    as_bad (_("can't find opcode "));
  opcode = (moxie_opc_info_t *) str_hash_find (opcode_hash_control, op_start);
  *op_end = pend;

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

  p = frag_more (2);

  switch (opcode->itype)
    {
    case MOXIE_F2_A8V:
      iword = (1<<15) | (opcode->opcode << 12);
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	int reg;
	reg = parse_register_operand (&op_end);
	iword += (reg << 8);
	if (*op_end != ',')
	  as_warn (_("expecting comma delimited register operands"));
	op_end++;
	op_end = parse_exp_save_ilp (op_end, &arg);
	fix_new_exp (frag_now,
		     ((p + (target_big_endian ? 1 : 0)) - frag_now->fr_literal),
		     1,
		     &arg,
		     0,
		     BFD_RELOC_8);
      }
      break;
    case MOXIE_F1_AB:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	int dest, src;
	dest = parse_register_operand (&op_end);
	if (*op_end != ',')
	  as_warn (_("expecting comma delimited register operands"));
	op_end++;
	src  = parse_register_operand (&op_end);
	iword += (dest << 4) + src;
	while (ISSPACE (*op_end))
	  op_end++;
	if (*op_end != 0)
	  as_warn (_("extra stuff on line ignored"));
      }
      break;
    case MOXIE_F1_A4:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	char *where;
	int regnum;

 	regnum = parse_register_operand (&op_end);
	while (ISSPACE (*op_end))
	  op_end++;

	iword += (regnum << 4);

	if (*op_end != ',')
	  {
	    as_bad (_("expecting comma delimited operands"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

	op_end = parse_exp_save_ilp (op_end, &arg);
	where = frag_more (4);
	fix_new_exp (frag_now,
		     (where - frag_now->fr_literal),
		     4,
		     &arg,
		     0,
		     BFD_RELOC_32);
      }
      break;
    case MOXIE_F1_M:
    case MOXIE_F1_4:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	char *where;

	op_end = parse_exp_save_ilp (op_end, &arg);
	where = frag_more (4);
	fix_new_exp (frag_now,
		     (where - frag_now->fr_literal),
		     4,
		     &arg,
		     0,
		     BFD_RELOC_32);
      }
      break;
    case MOXIE_F1_NARG:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      if (*op_end != 0)
	as_warn (_("extra stuff on line ignored"));
      break;
    case MOXIE_F1_A:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	int reg;
	reg = parse_register_operand (&op_end);
	while (ISSPACE (*op_end))
	  op_end++;
	if (*op_end != 0)
	  as_warn (_("extra stuff on line ignored"));
	iword += (reg << 4);
      }
      break;
    case MOXIE_F1_ABi:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	int a, b;
	a = parse_register_operand (&op_end);
	if (*op_end != ',')
	  as_warn (_("expecting comma delimited register operands"));
	op_end++;
	if (*op_end != '(')
	  {
	    as_bad (_("expecting indirect register `($rA)'"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	b = parse_register_operand (&op_end);
	if (*op_end != ')')
	  {
	    as_bad (_("missing closing parenthesis"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	iword += (a << 4) + b;
	while (ISSPACE (*op_end))
	  op_end++;
	if (*op_end != 0)
	  as_warn (_("extra stuff on line ignored"));
      }
      break;
    case MOXIE_F1_AiB:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	int a, b;
	if (*op_end != '(')
	  {
	    as_bad (_("expecting indirect register `($rA)'"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	a = parse_register_operand (&op_end);
	if (*op_end != ')')
	  {
	    as_bad (_("missing closing parenthesis"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	if (*op_end != ',')
	  as_warn (_("expecting comma delimited register operands"));
	op_end++;
	b = parse_register_operand (&op_end);
	iword += (a << 4) + b;
	while (ISSPACE (*op_end))
	  op_end++;
	if (*op_end != 0)
	  as_warn (_("extra stuff on line ignored"));
      }
      break;
    case MOXIE_F1_4A:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	char *where;
	int a;

	op_end = parse_exp_save_ilp (op_end, &arg);
	where = frag_more (4);
	fix_new_exp (frag_now,
		     (where - frag_now->fr_literal),
		     4,
		     &arg,
		     0,
		     BFD_RELOC_32);

	if (*op_end != ',')
	  {
	    as_bad (_("expecting comma delimited operands"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

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

	iword += (a << 4);
      }
      break;
    case MOXIE_F1_ABi2:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	char *offset;
	int a, b;

 	a = parse_register_operand (&op_end);
	while (ISSPACE (*op_end))
	  op_end++;

	if (*op_end != ',')
	  {
	    as_bad (_("expecting comma delimited operands"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

	op_end = parse_exp_save_ilp (op_end, &arg);
	offset = frag_more (2);
	fix_new_exp (frag_now,
		     (offset - frag_now->fr_literal),
		     2,
		     &arg,
		     0,
		     BFD_RELOC_16);

	if (*op_end != '(')
	  {
	    as_bad (_("expecting indirect register `($rX)'"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	b = parse_register_operand (&op_end);
	if (*op_end != ')')
	  {
	    as_bad (_("missing closing parenthesis"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

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

	iword += (a << 4) + b;
      }
      break;
    case MOXIE_F1_AiB2:
      iword = opcode->opcode << 8;
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;
	char *offset;
	int a, b;

	op_end = parse_exp_save_ilp (op_end, &arg);
	offset = frag_more (2);
	fix_new_exp (frag_now,
		     (offset - frag_now->fr_literal),
		     2,
		     &arg,
		     0,
		     BFD_RELOC_16);

	if (*op_end != '(')
	  {
	    as_bad (_("expecting indirect register `($rX)'"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;
	a = parse_register_operand (&op_end);
	if (*op_end != ')')
	  {
	    as_bad (_("missing closing parenthesis"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

	if (*op_end != ',')
	  {
	    as_bad (_("expecting comma delimited operands"));
	    ignore_rest_of_line ();
	    return;
	  }
	op_end++;

 	b = parse_register_operand (&op_end);
	while (ISSPACE (*op_end))
	  op_end++;

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

	iword += (a << 4) + b;
      }
      break;
    case MOXIE_F2_NARG:
      iword = opcode->opcode << 12;
      while (ISSPACE (*op_end))
	op_end++;
      if (*op_end != 0)
	as_warn (_("extra stuff on line ignored"));
      break;
    case MOXIE_F3_PCREL:
      iword = (3<<14) | (opcode->opcode << 10);
      while (ISSPACE (*op_end))
	op_end++;
      {
	expressionS arg;

	op_end = parse_exp_save_ilp (op_end, &arg);
	fix_new_exp (frag_now,
		     (p - frag_now->fr_literal),
		     2,
		     &arg,
		     TRUE,
		     BFD_RELOC_MOXIE_10_PCREL);
      }
      break;
    case MOXIE_BAD:
      iword = 0;
      while (ISSPACE (*op_end))
	op_end++;
      if (*op_end != 0)
	as_warn (_("extra stuff on line ignored"));
      break;
    default:
      abort ();
    }

  md_number_to_chars (p, iword, 2);
  dwarf2_emit_insn (2);

  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;
}

enum options
{
  OPTION_EB = OPTION_MD_BASE,
  OPTION_EL,
};

struct option md_longopts[] =
{
  { "EB",          no_argument, NULL, OPTION_EB},
  { "EL",          no_argument, NULL, OPTION_EL},
  { NULL,          no_argument, NULL, 0}
};

size_t md_longopts_size = sizeof (md_longopts);
\f
const char *md_shortopts = "";

int
md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED)
{
  switch (c)
    {
    case OPTION_EB:
      target_big_endian = 1;
      break;
    case OPTION_EL:
      target_big_endian = 0;
      break;
    default:
      return 0;
    }

  return 1;
}

void
md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
{
  fprintf (stream, _("\
  -EB                     assemble for a big endian system (default)\n\
  -EL                     assemble for a little endian system\n"));
}

/* 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;
  long max, min;

  max = min = 0;
  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_32:
      if (target_big_endian)
	{
	  buf[0] = val >> 24;
	  buf[1] = val >> 16;
	  buf[2] = val >> 8;
	  buf[3] = val >> 0;
	}
      else
	{
	  buf[3] = val >> 24;
	  buf[2] = val >> 16;
	  buf[1] = val >> 8;
	  buf[0] = val >> 0;
	}
      buf += 4;
      break;

    case BFD_RELOC_16:
      if (target_big_endian)
	{
	  buf[0] = val >> 8;
	  buf[1] = val >> 0;
	}
      else
	{
	  buf[1] = val >> 8;
	  buf[0] = val >> 0;
	}
      buf += 2;
      break;

    case BFD_RELOC_8:
      *buf++ = val;
      break;

    case BFD_RELOC_MOXIE_10_PCREL:
      if (!val)
	break;
      if (val < -1024 || val > 1022)
	as_bad_where (fixP->fx_file, fixP->fx_line,
                      _("pcrel too far BFD_RELOC_MOXIE_10"));
      /* 11 bit offset even numbered, so we remove right bit.  */
      val >>= 1;
      newval = md_chars_to_number (buf, 2);
      newval |= val & 0x03ff;
      md_number_to_chars (buf, newval, 2);
      break;

    default:
      abort ();
    }

  if (max != 0 && (val < min || val > max))
    as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));

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

/* Put number into target byte order.  */

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

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

  if (target_big_endian)
    {
      while (n--)
	{
	  result <<= 8;
	  result |= (*where++ & 255);
	}
    }
  else
    {
      while (n--)
	{
	  result <<= 8;
	  result |= (where[n] & 255);
	}
    }

  return result;
}

/* 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:
      code = fixP->fx_r_type;
      break;
    case BFD_RELOC_MOXIE_10_PCREL:
      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);
  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;

  /* This is the standard place for KLUDGEs to work around bugs in
     bfd_install_relocation (first such note in the documentation
     appears with binutils-2.8).

     That function bfd_install_relocation does the wrong thing with
     putting stuff into the addend of a reloc (it should stay out) for a
     weak symbol.  The really bad thing is that it adds the
     "segment-relative offset" of the symbol into the reloc.  In this
     case, the reloc should instead be relative to the symbol with no
     other offset than the assembly code shows; and since the symbol is
     weak, any local definition should be ignored until link time (or
     thereafter).
     To wit:  weaksym+42  should be weaksym+42 in the reloc,
     not weaksym+(offset_from_segment_of_local_weaksym_definition)

     To "work around" this, we subtract the segment-relative offset of
     "known" weak symbols.  This evens out the extra offset.

     That happens for a.out but not for ELF, since for ELF,
     bfd_install_relocation uses the "special function" field of the
     howto, and does not execute the code that needs to be undone.  */

  if (OUTPUT_FLAVOR == bfd_target_aout_flavour
      && fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)
      && ! bfd_is_und_section (S_GET_SEGMENT (fixP->fx_addsy)))
    {
      relP->addend -= S_GET_VALUE (fixP->fx_addsy);
    }

  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;
}

/* Decide from what point a pc-relative relocation is relative to,
   relative to the pc-relative fixup.  Er, relatively speaking.  */
long
md_pcrel_from (fixS *fixP)
{
  valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;

  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_32:
      return addr + 4;
    case BFD_RELOC_MOXIE_10_PCREL:
      /* Offset is from the end of the instruction.  */
      return addr + 2;
    default:
      abort ();
      return addr;
    }
}
Commit	Line	Data
20135e4c	1	/* tc-moxie.c -- Assemble code for moxie
250d07de	2	Copyright (C) 2009-2021 Free Software Foundation, Inc.
20135e4c NC	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@moxielogic.com>. */
	22
	23	#include "as.h"
	24	#include "safe-ctype.h"
	25	#include "opcode/moxie.h"
	26	#include "elf/moxie.h"
	27
	28	extern const moxie_opc_info_t moxie_opc_info[128];
	29
	30	const char comment_chars[] = "#";
	31	const char line_separator_chars[] = ";";
	32	const char line_comment_chars[] = "#";
	33
	34	static int pending_reloc;
629310ab	35	static htab_t opcode_hash_control;
20135e4c NC	36
	37	const pseudo_typeS md_pseudo_table[] =
	38	{
	39	{0, 0, 0}
	40	};
	41
	42	const char FLT_CHARS[] = "rRsSfFdDxXpP";
	43	const char EXP_CHARS[] = "eE";
	44
e202fa84 AG	45	static valueT md_chars_to_number (char * buf, int n);
	46
	47	/* Byte order. */
	48	extern int target_big_endian;
f865a31d	49
20135e4c NC	50	void
	51	md_operand (expressionS *op __attribute__((unused)))
	52	{
	53	/* Empty for now. */
	54	}
	55
	56	/* This function is called once, at assembler startup time. It sets
	57	up the hash table with all the opcodes in it, and also initializes
	58	some aliases for compatibility with other assemblers. */
	59
	60	void
	61	md_begin (void)
	62	{
	63	int count;
	64	const moxie_opc_info_t *opcode;
629310ab	65	opcode_hash_control = str_htab_create ();
20135e4c NC	66
	67	/* Insert names into hash table. */
	68	for (count = 0, opcode = moxie_form1_opc_info; count++ < 64; opcode++)
fe0e921f	69	str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);
20135e4c NC	70
20135e4c NC	71	for (count = 0, opcode = moxie_form2_opc_info; count++ < 4; opcode++)
fe0e921f	72	str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);
20135e4c	73
f865a31d	74	for (count = 0, opcode = moxie_form3_opc_info; count++ < 10; opcode++)
fe0e921f	75	str_hash_insert (opcode_hash_control, opcode->name, opcode, 0);
20135e4c NC	76
	77	bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
	78	}
	79
	80	/* Parse an expression and then restore the input line pointer. */
	81
	82	static char *
	83	parse_exp_save_ilp (char s, expressionS op)
	84	{
	85	char *save = input_line_pointer;
	86
	87	input_line_pointer = s;
	88	expression (op);
	89	s = input_line_pointer;
	90	input_line_pointer = save;
	91	return s;
	92	}
	93
	94	static int
	95	parse_register_operand (char **ptr)
	96	{
	97	int reg;
	98	char s = ptr;
	99
	100	if (*s != '$')
	101	{
20203fb9	102	as_bad (_("expecting register"));
20135e4c NC	103	ignore_rest_of_line ();
	104	return -1;
	105	}
	106	if (s[1] == 'f' && s[2] == 'p')
	107	{
	108	*ptr += 3;
	109	return 0;
	110	}
	111	if (s[1] == 's' && s[2] == 'p')
	112	{
	113	*ptr += 3;
	114	return 1;
	115	}
	116	if (s[1] == 'r')
	117	{
	118	reg = s[2] - '0';
	119	if ((reg < 0) \|\| (reg > 9))
	120	{
20203fb9	121	as_bad (_("illegal register number"));
20135e4c NC	122	ignore_rest_of_line ();
	123	return -1;
	124	}
	125	if (reg == 1)
	126	{
	127	int r2 = s[3] - '0';
	128	if ((r2 >= 0) && (r2 <= 3))
	129	{
	130	reg = 10 + r2;
	131	*ptr += 1;
	132	}
	133	}
	134	}
	135	else
	136	{
20203fb9	137	as_bad (_("illegal register number"));
20135e4c NC	138	ignore_rest_of_line ();
	139	return -1;
	140	}
	141
	142	*ptr += 3;
	143
	144	return reg + 2;
	145	}
	146
	147	/* This is the guts of the machine-dependent assembler. STR points to
	148	a machine dependent instruction. This function is supposed to emit
	149	the frags/bytes it assembles to. */
	150
	151	void
	152	md_assemble (char *str)
	153	{
	154	char *op_start;
	155	char *op_end;
	156
	157	moxie_opc_info_t *opcode;
	158	char *p;
	159	char pend;
	160
	161	unsigned short iword = 0;
	162
	163	int nlen = 0;
	164
	165	/* Drop leading whitespace. */
	166	while (*str == ' ')
	167	str++;
	168
	169	/* Find the op code end. */
	170	op_start = str;
	171	for (op_end = str;
	172	op_end && !is_end_of_line[op_end & 0xff] && *op_end != ' ';
	173	op_end++)
	174	nlen++;
	175
	176	pend = *op_end;
	177	*op_end = 0;
	178
	179	if (nlen == 0)
	180	as_bad (_("can't find opcode "));
629310ab	181	opcode = (moxie_opc_info_t *) str_hash_find (opcode_hash_control, op_start);
20135e4c NC	182	*op_end = pend;
	183
	184	if (opcode == NULL)
	185	{
	186	as_bad (_("unknown opcode %s"), op_start);
	187	return;
	188	}
	189
	190	p = frag_more (2);
	191
	192	switch (opcode->itype)
	193	{
	194	case MOXIE_F2_A8V:
	195	iword = (1<<15) \| (opcode->opcode << 12);
	196	while (ISSPACE (*op_end))
	197	op_end++;
	198	{
	199	expressionS arg;
	200	int reg;
	201	reg = parse_register_operand (&op_end);
	202	iword += (reg << 8);
	203	if (*op_end != ',')
2cbd2211	204	as_warn (_("expecting comma delimited register operands"));
20135e4c NC	205	op_end++;
	206	op_end = parse_exp_save_ilp (op_end, &arg);
	207	fix_new_exp (frag_now,
e202fa84	208	((p + (target_big_endian ? 1 : 0)) - frag_now->fr_literal),
20135e4c NC	209	1,
	210	&arg,
	211	0,
	212	BFD_RELOC_8);
	213	}
	214	break;
	215	case MOXIE_F1_AB:
	216	iword = opcode->opcode << 8;
	217	while (ISSPACE (*op_end))
	218	op_end++;
	219	{
	220	int dest, src;
	221	dest = parse_register_operand (&op_end);
	222	if (*op_end != ',')
2cbd2211	223	as_warn (_("expecting comma delimited register operands"));
20135e4c NC	224	op_end++;
	225	src = parse_register_operand (&op_end);
	226	iword += (dest << 4) + src;
	227	while (ISSPACE (*op_end))
	228	op_end++;
	229	if (*op_end != 0)
20203fb9	230	as_warn (_("extra stuff on line ignored"));
20135e4c NC	231	}
	232	break;
	233	case MOXIE_F1_A4:
	234	iword = opcode->opcode << 8;
	235	while (ISSPACE (*op_end))
	236	op_end++;
	237	{
	238	expressionS arg;
	239	char *where;
	240	int regnum;
	241
	242	regnum = parse_register_operand (&op_end);
	243	while (ISSPACE (*op_end))
	244	op_end++;
	245
	246	iword += (regnum << 4);
	247
	248	if (*op_end != ',')
	249	{
20203fb9	250	as_bad (_("expecting comma delimited operands"));
20135e4c NC	251	ignore_rest_of_line ();
	252	return;
	253	}
	254	op_end++;
	255
	256	op_end = parse_exp_save_ilp (op_end, &arg);
	257	where = frag_more (4);
	258	fix_new_exp (frag_now,
	259	(where - frag_now->fr_literal),
	260	4,
	261	&arg,
	262	0,
	263	BFD_RELOC_32);
	264	}
	265	break;
d7a5ed35	266	case MOXIE_F1_M:
20135e4c NC	267	case MOXIE_F1_4:
	268	iword = opcode->opcode << 8;
	269	while (ISSPACE (*op_end))
	270	op_end++;
	271	{
	272	expressionS arg;
	273	char *where;
	274
	275	op_end = parse_exp_save_ilp (op_end, &arg);
	276	where = frag_more (4);
	277	fix_new_exp (frag_now,
	278	(where - frag_now->fr_literal),
	279	4,
	280	&arg,
	281	0,
	282	BFD_RELOC_32);
	283	}
	284	break;
	285	case MOXIE_F1_NARG:
	286	iword = opcode->opcode << 8;
	287	while (ISSPACE (*op_end))
	288	op_end++;
	289	if (*op_end != 0)
20203fb9	290	as_warn (_("extra stuff on line ignored"));
20135e4c NC	291	break;
	292	case MOXIE_F1_A:
	293	iword = opcode->opcode << 8;
	294	while (ISSPACE (*op_end))
	295	op_end++;
	296	{
	297	int reg;
	298	reg = parse_register_operand (&op_end);
	299	while (ISSPACE (*op_end))
	300	op_end++;
	301	if (*op_end != 0)
20203fb9	302	as_warn (_("extra stuff on line ignored"));
20135e4c NC	303	iword += (reg << 4);
	304	}
	305	break;
	306	case MOXIE_F1_ABi:
	307	iword = opcode->opcode << 8;
	308	while (ISSPACE (*op_end))
	309	op_end++;
	310	{
	311	int a, b;
	312	a = parse_register_operand (&op_end);
	313	if (*op_end != ',')
2cbd2211	314	as_warn (_("expecting comma delimited register operands"));
20135e4c NC	315	op_end++;
	316	if (*op_end != '(')
	317	{
20203fb9	318	as_bad (_("expecting indirect register `($rA)'"));
20135e4c NC	319	ignore_rest_of_line ();
	320	return;
	321	}
	322	op_end++;
	323	b = parse_register_operand (&op_end);
	324	if (*op_end != ')')
	325	{
20203fb9	326	as_bad (_("missing closing parenthesis"));
20135e4c NC	327	ignore_rest_of_line ();
	328	return;
	329	}
	330	op_end++;
	331	iword += (a << 4) + b;
	332	while (ISSPACE (*op_end))
	333	op_end++;
	334	if (*op_end != 0)
20203fb9	335	as_warn (_("extra stuff on line ignored"));
20135e4c NC	336	}
	337	break;
	338	case MOXIE_F1_AiB:
	339	iword = opcode->opcode << 8;
	340	while (ISSPACE (*op_end))
	341	op_end++;
	342	{
	343	int a, b;
	344	if (*op_end != '(')
	345	{
20203fb9	346	as_bad (_("expecting indirect register `($rA)'"));
20135e4c NC	347	ignore_rest_of_line ();
	348	return;
	349	}
	350	op_end++;
	351	a = parse_register_operand (&op_end);
	352	if (*op_end != ')')
	353	{
20203fb9	354	as_bad (_("missing closing parenthesis"));
20135e4c NC	355	ignore_rest_of_line ();
	356	return;
	357	}
	358	op_end++;
	359	if (*op_end != ',')
2cbd2211	360	as_warn (_("expecting comma delimited register operands"));
20135e4c NC	361	op_end++;
	362	b = parse_register_operand (&op_end);
	363	iword += (a << 4) + b;
	364	while (ISSPACE (*op_end))
	365	op_end++;
	366	if (*op_end != 0)
20203fb9	367	as_warn (_("extra stuff on line ignored"));
20135e4c NC	368	}
	369	break;
	370	case MOXIE_F1_4A:
	371	iword = opcode->opcode << 8;
	372	while (ISSPACE (*op_end))
	373	op_end++;
	374	{
	375	expressionS arg;
	376	char *where;
	377	int a;
	378
	379	op_end = parse_exp_save_ilp (op_end, &arg);
	380	where = frag_more (4);
	381	fix_new_exp (frag_now,
	382	(where - frag_now->fr_literal),
	383	4,
	384	&arg,
	385	0,
	386	BFD_RELOC_32);
	387
	388	if (*op_end != ',')
	389	{
20203fb9	390	as_bad (_("expecting comma delimited operands"));
20135e4c NC	391	ignore_rest_of_line ();
	392	return;
	393	}
	394	op_end++;
	395
	396	a = parse_register_operand (&op_end);
	397	while (ISSPACE (*op_end))
	398	op_end++;
	399	if (*op_end != 0)
20203fb9	400	as_warn (_("extra stuff on line ignored"));
20135e4c NC	401
	402	iword += (a << 4);
	403	}
	404	break;
bffb6004	405	case MOXIE_F1_ABi2:
20135e4c NC	406	iword = opcode->opcode << 8;
	407	while (ISSPACE (*op_end))
	408	op_end++;
	409	{
	410	expressionS arg;
	411	char *offset;
	412	int a, b;
	413
	414	a = parse_register_operand (&op_end);
	415	while (ISSPACE (*op_end))
	416	op_end++;
	417
	418	if (*op_end != ',')
	419	{
20203fb9	420	as_bad (_("expecting comma delimited operands"));
20135e4c NC	421	ignore_rest_of_line ();
	422	return;
	423	}
	424	op_end++;
	425
	426	op_end = parse_exp_save_ilp (op_end, &arg);
bffb6004	427	offset = frag_more (2);
20135e4c NC	428	fix_new_exp (frag_now,
20135e4c NC	429	(offset - frag_now->fr_literal),
bffb6004	430	2,
20135e4c NC	431	&arg,
20135e4c NC	432	0,
bffb6004	433	BFD_RELOC_16);
20135e4c NC	434
	435	if (*op_end != '(')
	436	{
20203fb9	437	as_bad (_("expecting indirect register `($rX)'"));
20135e4c NC	438	ignore_rest_of_line ();
	439	return;
	440	}
	441	op_end++;
	442	b = parse_register_operand (&op_end);
	443	if (*op_end != ')')
	444	{
20203fb9	445	as_bad (_("missing closing parenthesis"));
20135e4c NC	446	ignore_rest_of_line ();
	447	return;
	448	}
	449	op_end++;
	450
	451	while (ISSPACE (*op_end))
	452	op_end++;
	453	if (*op_end != 0)
20203fb9	454	as_warn (_("extra stuff on line ignored"));
20135e4c NC	455
	456	iword += (a << 4) + b;
	457	}
	458	break;
bffb6004	459	case MOXIE_F1_AiB2:
20135e4c NC	460	iword = opcode->opcode << 8;
	461	while (ISSPACE (*op_end))
	462	op_end++;
	463	{
	464	expressionS arg;
	465	char *offset;
	466	int a, b;
	467
	468	op_end = parse_exp_save_ilp (op_end, &arg);
bffb6004	469	offset = frag_more (2);
20135e4c NC	470	fix_new_exp (frag_now,
20135e4c NC	471	(offset - frag_now->fr_literal),
bffb6004	472	2,
20135e4c NC	473	&arg,
20135e4c NC	474	0,
bffb6004	475	BFD_RELOC_16);
20135e4c NC	476
	477	if (*op_end != '(')
	478	{
20203fb9	479	as_bad (_("expecting indirect register `($rX)'"));
20135e4c NC	480	ignore_rest_of_line ();
	481	return;
	482	}
	483	op_end++;
	484	a = parse_register_operand (&op_end);
	485	if (*op_end != ')')
	486	{
20203fb9	487	as_bad (_("missing closing parenthesis"));
20135e4c NC	488	ignore_rest_of_line ();
	489	return;
	490	}
	491	op_end++;
	492
	493	if (*op_end != ',')
	494	{
20203fb9	495	as_bad (_("expecting comma delimited operands"));
20135e4c NC	496	ignore_rest_of_line ();
	497	return;
	498	}
	499	op_end++;
	500
	501	b = parse_register_operand (&op_end);
	502	while (ISSPACE (*op_end))
	503	op_end++;
	504
	505	while (ISSPACE (*op_end))
	506	op_end++;
	507	if (*op_end != 0)
20203fb9	508	as_warn (_("extra stuff on line ignored"));
20135e4c NC	509
	510	iword += (a << 4) + b;
	511	}
	512	break;
	513	case MOXIE_F2_NARG:
	514	iword = opcode->opcode << 12;
	515	while (ISSPACE (*op_end))
	516	op_end++;
	517	if (*op_end != 0)
20203fb9	518	as_warn (_("extra stuff on line ignored"));
20135e4c	519	break;
f865a31d AG	520	case MOXIE_F3_PCREL:
	521	iword = (3<<14) \| (opcode->opcode << 10);
	522	while (ISSPACE (*op_end))
	523	op_end++;
	524	{
	525	expressionS arg;
	526
	527	op_end = parse_exp_save_ilp (op_end, &arg);
	528	fix_new_exp (frag_now,
	529	(p - frag_now->fr_literal),
	530	2,
	531	&arg,
	532	TRUE,
	533	BFD_RELOC_MOXIE_10_PCREL);
	534	}
	535	break;
3f47df7f AG	536	case MOXIE_BAD:
	537	iword = 0;
	538	while (ISSPACE (*op_end))
	539	op_end++;
	540	if (*op_end != 0)
	541	as_warn (_("extra stuff on line ignored"));
	542	break;
20135e4c	543	default:
20203fb9	544	abort ();
20135e4c NC	545	}
	546
	547	md_number_to_chars (p, iword, 2);
3ee6e4fb	548	dwarf2_emit_insn (2);
20135e4c NC	549
	550	while (ISSPACE (*op_end))
	551	op_end++;
	552
	553	if (*op_end != 0)
20203fb9	554	as_warn (_("extra stuff on line ignored"));
20135e4c NC	555
20135e4c NC	556	if (pending_reloc)
20203fb9	557	as_bad (_("Something forgot to clean up\n"));
20135e4c NC	558	}
	559
	560	/* Turn a string in input_line_pointer into a floating point constant
	561	of type type, and store the appropriate bytes in *LITP. The number
	562	of LITTLENUMS emitted is stored in *SIZEP . An error message is
	563	returned, or NULL on OK. */
	564
6d4af3c2	565	const char *
20135e4c NC	566	md_atof (int type, char litP, int sizeP)
	567	{
	568	int prec;
	569	LITTLENUM_TYPE words[4];
	570	char *t;
	571	int i;
	572
	573	switch (type)
	574	{
	575	case 'f':
	576	prec = 2;
	577	break;
	578
	579	case 'd':
	580	prec = 4;
	581	break;
	582
	583	default:
	584	*sizeP = 0;
	585	return _("bad call to md_atof");
	586	}
	587
	588	t = atof_ieee (input_line_pointer, type, words);
	589	if (t)
	590	input_line_pointer = t;
	591
	592	sizeP = prec 2;
	593
	594	for (i = prec - 1; i >= 0; i--)
	595	{
	596	md_number_to_chars (litP, (valueT) words[i], 2);
	597	litP += 2;
	598	}
	599
	600	return NULL;
	601	}
e202fa84 AG	602
	603	enum options
	604	{
	605	OPTION_EB = OPTION_MD_BASE,
	606	OPTION_EL,
	607	};
20135e4c NC	608
	609	struct option md_longopts[] =
	610	{
e202fa84 AG	611	{ "EB", no_argument, NULL, OPTION_EB},
	612	{ "EL", no_argument, NULL, OPTION_EL},
	613	{ NULL, no_argument, NULL, 0}
20135e4c	614	};
e202fa84	615
20135e4c	616	size_t md_longopts_size = sizeof (md_longopts);
e202fa84 AG	617	\f
e202fa84 AG	618	const char *md_shortopts = "";
20135e4c	619
20135e4c	620	int
17b9d67d	621	md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED)
20135e4c	622	{
e202fa84 AG	623	switch (c)
e202fa84 AG	624	{
3739860c L	625	case OPTION_EB:
3739860c L	626	target_big_endian = 1;
e202fa84	627	break;
3739860c	628	case OPTION_EL:
e202fa84	629	target_big_endian = 0;
e202fa84	630	break;
3739860c	631	default:
e202fa84 AG	632	return 0;
	633	}
	634
	635	return 1;
20135e4c NC	636	}
	637
	638	void
	639	md_show_usage (FILE *stream ATTRIBUTE_UNUSED)
	640	{
e202fa84 AG	641	fprintf (stream, _("\
	642	-EB assemble for a big endian system (default)\n\
	643	-EL assemble for a little endian system\n"));
20135e4c NC	644	}
	645
	646	/* Apply a fixup to the object file. */
	647
	648	void
3739860c	649	md_apply_fix (fixS *fixP ATTRIBUTE_UNUSED,
f865a31d	650	valueT * valP ATTRIBUTE_UNUSED, segT seg ATTRIBUTE_UNUSED)
20135e4c NC	651	{
	652	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
	653	long val = *valP;
f865a31d	654	long newval;
20135e4c	655	long max, min;
20135e4c NC	656
20135e4c NC	657	max = min = 0;
20135e4c NC	658	switch (fixP->fx_r_type)
	659	{
	660	case BFD_RELOC_32:
e202fa84 AG	661	if (target_big_endian)
	662	{
	663	buf[0] = val >> 24;
	664	buf[1] = val >> 16;
	665	buf[2] = val >> 8;
	666	buf[3] = val >> 0;
	667	}
	668	else
	669	{
	670	buf[3] = val >> 24;
	671	buf[2] = val >> 16;
	672	buf[1] = val >> 8;
	673	buf[0] = val >> 0;
	674	}
	675	buf += 4;
20135e4c NC	676	break;
	677
	678	case BFD_RELOC_16:
e202fa84 AG	679	if (target_big_endian)
	680	{
	681	buf[0] = val >> 8;
	682	buf[1] = val >> 0;
	683	}
	684	else
	685	{
	686	buf[1] = val >> 8;
	687	buf[0] = val >> 0;
	688	}
	689	buf += 2;
20135e4c NC	690	break;
	691
	692	case BFD_RELOC_8:
	693	*buf++ = val;
	694	break;
	695
f865a31d AG	696	case BFD_RELOC_MOXIE_10_PCREL:
	697	if (!val)
	698	break;
	699	if (val < -1024 \|\| val > 1022)
	700	as_bad_where (fixP->fx_file, fixP->fx_line,
	701	_("pcrel too far BFD_RELOC_MOXIE_10"));
	702	/* 11 bit offset even numbered, so we remove right bit. */
	703	val >>= 1;
	704	newval = md_chars_to_number (buf, 2);
	705	newval \|= val & 0x03ff;
	706	md_number_to_chars (buf, newval, 2);
	707	break;
	708
20135e4c NC	709	default:
	710	abort ();
	711	}
	712
	713	if (max != 0 && (val < min \|\| val > max))
	714	as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
	715
	716	if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
	717	fixP->fx_done = 1;
	718	}
	719
e202fa84	720	/* Put number into target byte order. */
20135e4c NC	721
20135e4c NC	722	void
e202fa84	723	md_number_to_chars (char * ptr, valueT use, int nbytes)
20135e4c	724	{
e202fa84 AG	725	if (target_big_endian)
	726	number_to_chars_bigendian (ptr, use, nbytes);
	727	else
	728	number_to_chars_littleendian (ptr, use, nbytes);
20135e4c NC	729	}
20135e4c NC	730
f865a31d AG	731	/* Convert from target byte order to host byte order. */
f865a31d AG	732
e202fa84 AG	733	static valueT
e202fa84 AG	734	md_chars_to_number (char * buf, int n)
f865a31d	735	{
e202fa84 AG	736	valueT result = 0;
e202fa84 AG	737	unsigned char * where = (unsigned char *) buf;
f865a31d	738
e202fa84 AG	739	if (target_big_endian)
	740	{
	741	while (n--)
	742	{
	743	result <<= 8;
	744	result \|= (*where++ & 255);
	745	}
	746	}
	747	else
f865a31d	748	{
e202fa84 AG	749	while (n--)
	750	{
	751	result <<= 8;
	752	result \|= (where[n] & 255);
	753	}
f865a31d AG	754	}
f865a31d AG	755
e202fa84	756	return result;
f865a31d AG	757	}
f865a31d AG	758
20135e4c NC	759	/* Generate a machine-dependent relocation. */
	760	arelent *
	761	tc_gen_reloc (asection section ATTRIBUTE_UNUSED, fixS fixP)
	762	{
	763	arelent *relP;
	764	bfd_reloc_code_real_type code;
	765
	766	switch (fixP->fx_r_type)
	767	{
	768	case BFD_RELOC_32:
	769	code = fixP->fx_r_type;
	770	break;
f865a31d AG	771	case BFD_RELOC_MOXIE_10_PCREL:
	772	code = fixP->fx_r_type;
	773	break;
20135e4c NC	774	default:
	775	as_bad_where (fixP->fx_file, fixP->fx_line,
	776	_("Semantics error. This type of operand can not be relocated, it must be an assembly-time constant"));
	777	return 0;
	778	}
	779
325801bd TS	780	relP = XNEW (arelent);
325801bd TS	781	relP->sym_ptr_ptr = XNEW (asymbol *);
20135e4c NC	782	*relP->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
	783	relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
	784
	785	relP->addend = fixP->fx_offset;
	786
	787	/* This is the standard place for KLUDGEs to work around bugs in
	788	bfd_install_relocation (first such note in the documentation
	789	appears with binutils-2.8).
	790
	791	That function bfd_install_relocation does the wrong thing with
	792	putting stuff into the addend of a reloc (it should stay out) for a
	793	weak symbol. The really bad thing is that it adds the
	794	"segment-relative offset" of the symbol into the reloc. In this
	795	case, the reloc should instead be relative to the symbol with no
	796	other offset than the assembly code shows; and since the symbol is
	797	weak, any local definition should be ignored until link time (or
	798	thereafter).
	799	To wit: weaksym+42 should be weaksym+42 in the reloc,
	800	not weaksym+(offset_from_segment_of_local_weaksym_definition)
	801
	802	To "work around" this, we subtract the segment-relative offset of
	803	"known" weak symbols. This evens out the extra offset.
	804
	805	That happens for a.out but not for ELF, since for ELF,
	806	bfd_install_relocation uses the "special function" field of the
	807	howto, and does not execute the code that needs to be undone. */
	808
	809	if (OUTPUT_FLAVOR == bfd_target_aout_flavour
	810	&& fixP->fx_addsy && S_IS_WEAK (fixP->fx_addsy)
	811	&& ! bfd_is_und_section (S_GET_SEGMENT (fixP->fx_addsy)))
	812	{
	813	relP->addend -= S_GET_VALUE (fixP->fx_addsy);
	814	}
	815
	816	relP->howto = bfd_reloc_type_lookup (stdoutput, code);
	817	if (! relP->howto)
	818	{
	819	const char *name;
	820
	821	name = S_GET_NAME (fixP->fx_addsy);
	822	if (name == NULL)
	823	name = _("<unknown>");
	824	as_fatal (_("Cannot generate relocation type for symbol %s, code %s"),
	825	name, bfd_get_reloc_code_name (code));
	826	}
	827
	828	return relP;
	829	}
	830
	831	/* Decide from what point a pc-relative relocation is relative to,
	832	relative to the pc-relative fixup. Er, relatively speaking. */
	833	long
	834	md_pcrel_from (fixS *fixP)
	835	{
	836	valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
	837
20135e4c NC	838	switch (fixP->fx_r_type)
	839	{
	840	case BFD_RELOC_32:
	841	return addr + 4;
f865a31d	842	case BFD_RELOC_MOXIE_10_PCREL:
7078b409 AG	843	/* Offset is from the end of the instruction. */
7078b409 AG	844	return addr + 2;
20135e4c NC	845	default:
	846	abort ();
	847	return addr;
	848	}
	849	}