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

/* tc-xstormy16.c -- Assembler for the Sanyo XSTORMY16.
   Copyright 2000, 2001, 2002, 2003 Free Software Foundation.

   This file is part of GAS, the GNU Assembler.

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

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

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <stdio.h>
#include "as.h"
#include "subsegs.h"
#include "symcat.h"
#include "opcodes/xstormy16-desc.h"
#include "opcodes/xstormy16-opc.h"
#include "cgen.h"

/* Structure to hold all of the different components describing
   an individual instruction.  */
typedef struct
{
  const CGEN_INSN *	insn;
  const CGEN_INSN *	orig_insn;
  CGEN_FIELDS		fields;
#if CGEN_INT_INSN_P
  CGEN_INSN_INT         buffer [1];
#define INSN_VALUE(buf) (*(buf))
#else
  unsigned char         buffer [CGEN_MAX_INSN_SIZE];
#define INSN_VALUE(buf) (buf)
#endif
  char *		addr;
  fragS *		frag;
  int                   num_fixups;
  fixS *                fixups [GAS_CGEN_MAX_FIXUPS];
  int                   indices [MAX_OPERAND_INSTANCES];
}
xstormy16_insn;

const char comment_chars[]        = ";";
const char line_comment_chars[]   = "#";
const char line_separator_chars[] = "|";
const char EXP_CHARS[]            = "eE";
const char FLT_CHARS[]            = "dD";

#define O_fptr_symbol	(O_max + 1)
\f
#define XSTORMY16_SHORTOPTS ""
const char * md_shortopts = XSTORMY16_SHORTOPTS;

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

int
md_parse_option (c, arg)
     int    c ATTRIBUTE_UNUSED;
     char * arg ATTRIBUTE_UNUSED;
{
  return 0;
}

void
md_show_usage (stream)
  FILE * stream;
{
  fprintf (stream, _(" XSTORMY16 specific command line options:\n"));
}

/* The target specific pseudo-ops which we support.  */
const pseudo_typeS md_pseudo_table[] =
{
  { "word",	cons,		4 },
  { NULL, 	NULL, 		0 }
};

\f
void
md_begin ()
{
  /* Initialize the `cgen' interface.  */

  /* Set the machine number and endian.  */
  gas_cgen_cpu_desc = xstormy16_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
					  CGEN_CPU_OPEN_ENDIAN,
					  CGEN_ENDIAN_LITTLE,
					  CGEN_CPU_OPEN_END);
  xstormy16_cgen_init_asm (gas_cgen_cpu_desc);

  /* This is a callback from cgen to gas to parse operands.  */
  cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
}

static bfd_boolean skipping_fptr = FALSE;

void
md_assemble (str)
     char * str;
{
  xstormy16_insn insn;
  char *    errmsg;

  /* Make sure that if we had an erroneous input line which triggered
     the skipping_fptr boolean that it does not affect following lines.  */
  skipping_fptr = FALSE;

  /* Initialize GAS's cgen interface for a new instruction.  */
  gas_cgen_init_parse ();

  insn.insn = xstormy16_cgen_assemble_insn
    (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);

  if (!insn.insn)
    {
      as_bad (errmsg);
      return;
    }

  /* Doesn't really matter what we pass for RELAX_P here.  */
  gas_cgen_finish_insn (insn.insn, insn.buffer,
			CGEN_FIELDS_BITSIZE (& insn.fields), 0, NULL);
}

void
md_operand (e)
     expressionS * e;
{
  if (*input_line_pointer != '@')
    return;

  if (strncmp (input_line_pointer + 1, "fptr", 4) == 0)
    {
      input_line_pointer += 5;
      SKIP_WHITESPACE ();
      if (*input_line_pointer != '(')
	{
	  as_bad ("Expected '('");
	  goto err;
	}
      input_line_pointer++;

      expression (e);

      if (*input_line_pointer != ')')
	{
	  as_bad ("Missing ')'");
	  goto err;
	}
      input_line_pointer++;
      SKIP_WHITESPACE ();

      if (e->X_op != O_symbol)
	as_bad ("Not a symbolic expression");
      else if (* input_line_pointer == '-')
	/* We are computing the difference of two function pointers
	   like this:

	    .hword  @fptr (foo) - @fptr (bar)

	  In this situation we do not want to generate O_fptr_symbol
	  operands because the result is an absolute value, not a
	  function pointer.

	  We need to make the check here, rather than when the fixup
	  is generated as the function names (foo & bar in the above
	  example) might be local symbols and we want the expression
	  to be evaluated now.  This kind of thing can happen when
	  gcc is generating computed gotos.  */
	skipping_fptr = TRUE;
      else if (skipping_fptr)
	skipping_fptr = FALSE;
      else
        e->X_op = O_fptr_symbol;
    }

  return;
 err:
  ignore_rest_of_line ();
}

/* Called while parsing data to create a fixup.
   Create BFD_RELOC_XSTORMY16_FPTR16 relocations.  */

void
xstormy16_cons_fix_new (f, where, nbytes, exp)
     fragS *f;
     int where;
     int nbytes;
     expressionS *exp;
{
  bfd_reloc_code_real_type code;
  fixS *fix;

  if (exp->X_op == O_fptr_symbol)
    {
      if (nbytes != 2)
	{
	  as_bad ("unsupported fptr fixup size %d", nbytes);
	  return;
	}
      exp->X_op = O_symbol;
      code = BFD_RELOC_XSTORMY16_FPTR16;
    }
  else if (nbytes == 1)
    code = BFD_RELOC_8;
  else if (nbytes == 2)
    code = BFD_RELOC_16;
  else if (nbytes == 4)
    code = BFD_RELOC_32;
  else
    {
      as_bad ("unsupported fixup size %d", nbytes);
      return;
    }

  fix = fix_new_exp (f, where, nbytes, exp, 0, code);
}

/* Called while parsing an instruction to create a fixup.
   Create BFD_RELOC_XSTORMY16_FPTR16 relocations.  */

fixS *
xstormy16_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
     fragS *              frag;
     int                  where;
     const CGEN_INSN *    insn;
     int                  length;
     const CGEN_OPERAND * operand;
     int                  opinfo;
     expressionS *        exp;
{
  fixS *fixP;
  operatorT op = exp->X_op;

  if (op == O_fptr_symbol)
    exp->X_op = O_symbol;

  fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
				    operand, opinfo, exp);

  if (op == O_fptr_symbol)
    {
      if (operand->type != XSTORMY16_OPERAND_IMM16)
	as_bad ("unsupported fptr fixup");
      else
	{
	  fixP->fx_r_type = BFD_RELOC_XSTORMY16_FPTR16;
	  fixP->fx_where += 2;
	}
    }

  return fixP;
}

valueT
md_section_align (segment, size)
     segT   segment;
     valueT size;
{
  int align = bfd_get_section_alignment (stdoutput, segment);
  return ((size + (1 << align) - 1) & (-1 << align));
}

symbolS *
md_undefined_symbol (name)
  char * name ATTRIBUTE_UNUSED;
{
  return 0;
}
\f
/* Return an initial guess of the length by which a fragment must grow to
   hold a branch to reach its destination.
   Also updates fr_type/fr_subtype as necessary.

   Called just before doing relaxation.
   Any symbol that is now undefined will not become defined.
   The guess for fr_var is ACTUALLY the growth beyond fr_fix.
   Whatever we do to grow fr_fix or fr_var contributes to our returned value.
   Although it may not be explicit in the frag, pretend fr_var starts with a
   0 value.  */

int
md_estimate_size_before_relax (fragP, segment)
     fragS * fragP ATTRIBUTE_UNUSED;
     segT    segment ATTRIBUTE_UNUSED;
{
  /* No assembler relaxation is defined (or necessary) for this port.  */
  abort ();
}

/* *fragP has been relaxed to its final size, and now needs to have
   the bytes inside it modified to conform to the new size.

   Called after relaxation is finished.
   fragP->fr_type == rs_machine_dependent.
   fragP->fr_subtype is the subtype of what the address relaxed to.  */

void
md_convert_frag (abfd, sec, fragP)
  bfd *   abfd ATTRIBUTE_UNUSED;
  segT    sec ATTRIBUTE_UNUSED;
  fragS * fragP ATTRIBUTE_UNUSED;
{
  /* No assembler relaxation is defined (or necessary) for this port.  */
  abort ();
}
\f
/* Functions concerning relocs.  */

/* The location from which a PC relative jump should be calculated,
   given a PC relative reloc.  */

long
md_pcrel_from_section (fixP, sec)
     fixS * fixP;
     segT   sec;
{
  if (fixP->fx_addsy != (symbolS *) NULL
      && (! S_IS_DEFINED (fixP->fx_addsy)
	  || S_GET_SEGMENT (fixP->fx_addsy) != sec)
          || xstormy16_force_relocation (fixP))
    /* The symbol is undefined,
       or it is defined but not in this section,
       or the relocation will be relative to this symbol not the section symbol.	 
       Let the linker figure it out.  */
    return 0;

  return fixP->fx_frag->fr_address + fixP->fx_where;
}

/* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
   Returns BFD_RELOC_NONE if no reloc type can be found.
   *FIXP may be modified if desired.  */

bfd_reloc_code_real_type
md_cgen_lookup_reloc (insn, operand, fixP)
     const CGEN_INSN *    insn ATTRIBUTE_UNUSED;
     const CGEN_OPERAND * operand;
     fixS *               fixP;
{
  switch (operand->type)
    {
    case XSTORMY16_OPERAND_IMM2:
    case XSTORMY16_OPERAND_IMM3:
    case XSTORMY16_OPERAND_IMM3B:
    case XSTORMY16_OPERAND_IMM4:
    case XSTORMY16_OPERAND_HMEM8:
      return BFD_RELOC_NONE;

    case XSTORMY16_OPERAND_IMM12:
      fixP->fx_where += 2;
      return BFD_RELOC_XSTORMY16_12;

    case XSTORMY16_OPERAND_IMM8:
    case XSTORMY16_OPERAND_LMEM8:
      return fixP->fx_pcrel ? BFD_RELOC_8_PCREL : BFD_RELOC_8;

    case XSTORMY16_OPERAND_IMM16:
      /* This might have been processed at parse time.  */
      fixP->fx_where += 2;
      if (fixP->fx_cgen.opinfo && fixP->fx_cgen.opinfo != BFD_RELOC_NONE)
	return fixP->fx_cgen.opinfo;
      return fixP->fx_pcrel ? BFD_RELOC_16_PCREL : BFD_RELOC_16;

    case XSTORMY16_OPERAND_ABS24:
      return BFD_RELOC_XSTORMY16_24;

    case XSTORMY16_OPERAND_REL8_4:
      fixP->fx_addnumber -= 2;
    case XSTORMY16_OPERAND_REL8_2:
      fixP->fx_addnumber -= 2;
      fixP->fx_pcrel = 1;
      return BFD_RELOC_8_PCREL;

    case XSTORMY16_OPERAND_REL12:
      fixP->fx_where += 2;
      /* Fall through...  */
    case XSTORMY16_OPERAND_REL12A:
      fixP->fx_addnumber -= 2;
      fixP->fx_pcrel = 1;
      return BFD_RELOC_XSTORMY16_REL_12;

    default : /* avoid -Wall warning */
      abort ();
    }
}

/* See whether we need to force a relocation into the output file.
   This is used to force out switch and PC relative relocations when
   relaxing.  */

int
xstormy16_force_relocation (fix)
     fixS * fix;
{
  if (fix->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
    return 1;

  return generic_force_reloc (fix);
}

/* Return true if a relocation against a symbol may be replaced with
   a relocation against section+offset.  */

bfd_boolean
xstormy16_fix_adjustable (fixP)
   fixS * fixP;
{
  /* We need the symbol name for the VTABLE entries.  */
  if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
      || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
    return 0;

  if (fixP->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
    return 0;

  return 1;
}

/* This is a copy of gas_cgen_md_apply_fix3, with some enhancements to
   do various things that would not be valid for all ports.  */

void
xstormy16_md_apply_fix3 (fixP, valueP, seg)
     fixS *   fixP;
     valueT * valueP;
     segT     seg ATTRIBUTE_UNUSED;
{
  char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
  valueT value = *valueP;
  /* Canonical name, since used a lot.  */
  CGEN_CPU_DESC cd = gas_cgen_cpu_desc;

  /* md_cgen_lookup_reloc() will adjust this to compensate for where
     in the opcode the relocation happens, for pcrel relocations.  We
     have no other way of keeping track of what this offset needs to
     be.  */
  fixP->fx_addnumber = 0;

  /* This port has pc-relative relocs and DIFF_EXPR_OK defined, so
     it must deal with turning a BFD_RELOC_{8,16,32,64} into a
     BFD_RELOC_*_PCREL for the case of

	.word something-.
  */
  if (fixP->fx_pcrel)
    switch (fixP->fx_r_type)
      {
      case BFD_RELOC_8:
	fixP->fx_r_type = BFD_RELOC_8_PCREL;
	break;
      case BFD_RELOC_16:
	fixP->fx_r_type = BFD_RELOC_16_PCREL;
	break;
      case BFD_RELOC_32:
	fixP->fx_r_type = BFD_RELOC_32_PCREL;
	break;
      case BFD_RELOC_64:
	fixP->fx_r_type = BFD_RELOC_64_PCREL;
	break;
      default:
	break;
      }

  if (fixP->fx_addsy == (symbolS *) NULL)
    fixP->fx_done = 1;

  /* We don't actually support subtracting a symbol.  */
  if (fixP->fx_subsy != (symbolS *) NULL)
    as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));

  if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
    {
      int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
      const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
      const char *errmsg;
      bfd_reloc_code_real_type reloc_type;
      CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
      const CGEN_INSN *insn = fixP->fx_cgen.insn;

      /* If the reloc has been fully resolved finish the operand here.  */
      /* FIXME: This duplicates the capabilities of code in BFD.  */
      if (fixP->fx_done)
	{
	  CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
	  CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);

#if CGEN_INT_INSN_P
	  {
	    CGEN_INSN_INT insn_value =
	      cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));

	    /* ??? 0 is passed for `pc'.  */
	    errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
						   &insn_value, (bfd_vma) 0);
	    cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
				 insn_value);
	  }
#else
	  /* ??? 0 is passed for `pc'.  */
	  errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
						 (bfd_vma) 0);
#endif
	  if (errmsg)
	    as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
	}

      if (fixP->fx_done)
	return;

      /* The operand isn't fully resolved.  Determine a BFD reloc value
	 based on the operand information and leave it to
	 bfd_install_relocation.  Note that this doesn't work when
	 !partial_inplace.  */

      reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
      if (reloc_type != BFD_RELOC_NONE)
	{
	  fixP->fx_r_type = reloc_type;
	}
      else
	{
	  as_bad_where (fixP->fx_file, fixP->fx_line,
			_("unresolved expression that must be resolved"));
	  fixP->fx_done = 1;
	  return;
	}
    }
  else if (fixP->fx_done)
    {
      /* We're finished with this fixup.  Install it because
	 bfd_install_relocation won't be called to do it.  */
      switch (fixP->fx_r_type)
	{
	case BFD_RELOC_8:
	  md_number_to_chars (where, value, 1);
	  break;
	case BFD_RELOC_16:
	  md_number_to_chars (where, value, 2);
	  break;
	case BFD_RELOC_32:
	  md_number_to_chars (where, value, 4);
	  break;
	case BFD_RELOC_64:
	  md_number_to_chars (where, value, 8);
	  break;
	default:
	  as_bad_where (fixP->fx_file, fixP->fx_line,
			_("internal error: can't install fix for reloc type %d (`%s')"),
			fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
	  break;
	}
    }
  else
    {
      /* bfd_install_relocation will be called to finish things up.  */
    }

  /* This is a RELA port.  Thus, it does not need to store a
     value if it is going to make a reloc.  What's more, when
     assembling a line like

     .byte global-0x7f00

     we'll get a spurious error message if we try to stuff 0x7f00 into
     the byte.  */
  if (! fixP->fx_done)
    *valueP = 0;

  /* Tuck `value' away for use by tc_gen_reloc.
     See the comment describing fx_addnumber in write.h.
     This field is misnamed (or misused :-).  */
  fixP->fx_addnumber += value;
}

\f
/* Write a value out to the object file, using the appropriate endianness.  */

void
md_number_to_chars (buf, val, n)
     char * buf;
     valueT val;
     int    n;
{
  number_to_chars_littleendian (buf, val, 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.
*/

/* Equal to MAX_PRECISION in atof-ieee.c */
#define MAX_LITTLENUMS 6

char *
md_atof (type, litP, sizeP)
     char   type;
     char * litP;
     int *  sizeP;
{
  int              prec;
  LITTLENUM_TYPE   words [MAX_LITTLENUMS];
  LITTLENUM_TYPE   *wordP;
  char *           t;

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

    case 'd':
    case 'D':
      prec = 4;
      break;

   /* FIXME: Some targets allow other format chars for bigger sizes here.  */

    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 * sizeof (LITTLENUM_TYPE);

  *sizeP = prec * sizeof (LITTLENUM_TYPE);
  /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
     the littleendianness of the processor.  */
  for (wordP = words + prec - 1; prec--;)
    {
      md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
      litP += sizeof (LITTLENUM_TYPE);
    }

  return 0;
}
Commit	Line	Data
93fbbb04	1	/* tc-xstormy16.c -- Assembler for the Sanyo XSTORMY16.
ae6063d4	2	Copyright 2000, 2001, 2002, 2003 Free Software Foundation.
93fbbb04 GK	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 2, 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, 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include <stdio.h>
	22	#include "as.h"
5d6255fe	23	#include "subsegs.h"
93fbbb04 GK	24	#include "symcat.h"
	25	#include "opcodes/xstormy16-desc.h"
	26	#include "opcodes/xstormy16-opc.h"
	27	#include "cgen.h"
	28
	29	/* Structure to hold all of the different components describing
	30	an individual instruction. */
	31	typedef struct
	32	{
	33	const CGEN_INSN * insn;
	34	const CGEN_INSN * orig_insn;
	35	CGEN_FIELDS fields;
	36	#if CGEN_INT_INSN_P
	37	CGEN_INSN_INT buffer [1];
	38	#define INSN_VALUE(buf) (*(buf))
	39	#else
	40	unsigned char buffer [CGEN_MAX_INSN_SIZE];
	41	#define INSN_VALUE(buf) (buf)
	42	#endif
	43	char * addr;
	44	fragS * frag;
	45	int num_fixups;
	46	fixS * fixups [GAS_CGEN_MAX_FIXUPS];
	47	int indices [MAX_OPERAND_INSTANCES];
	48	}
	49	xstormy16_insn;
	50
	51	const char comment_chars[] = ";";
	52	const char line_comment_chars[] = "#";
	53	const char line_separator_chars[] = "\|";
	54	const char EXP_CHARS[] = "eE";
	55	const char FLT_CHARS[] = "dD";
	56
	57	#define O_fptr_symbol (O_max + 1)
	58	\f
	59	#define XSTORMY16_SHORTOPTS ""
	60	const char * md_shortopts = XSTORMY16_SHORTOPTS;
	61
	62	struct option md_longopts[] =
	63	{
	64	{NULL, no_argument, NULL, 0}
	65	};
	66	size_t md_longopts_size = sizeof (md_longopts);
	67
	68	int
	69	md_parse_option (c, arg)
	70	int c ATTRIBUTE_UNUSED;
	71	char * arg ATTRIBUTE_UNUSED;
	72	{
	73	return 0;
	74	}
	75
	76	void
	77	md_show_usage (stream)
	78	FILE * stream;
	79	{
	80	fprintf (stream, _(" XSTORMY16 specific command line options:\n"));
5d6255fe	81	}
93fbbb04 GK	82
	83	/* The target specific pseudo-ops which we support. */
	84	const pseudo_typeS md_pseudo_table[] =
	85	{
	86	{ "word", cons, 4 },
	87	{ NULL, NULL, 0 }
	88	};
	89
	90	\f
	91	void
	92	md_begin ()
	93	{
	94	/* Initialize the `cgen' interface. */
5d6255fe	95
93fbbb04 GK	96	/* Set the machine number and endian. */
	97	gas_cgen_cpu_desc = xstormy16_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
	98	CGEN_CPU_OPEN_ENDIAN,
	99	CGEN_ENDIAN_LITTLE,
	100	CGEN_CPU_OPEN_END);
	101	xstormy16_cgen_init_asm (gas_cgen_cpu_desc);
	102
	103	/* This is a callback from cgen to gas to parse operands. */
	104	cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
	105	}
	106
e66c629e NC	107	static bfd_boolean skipping_fptr = FALSE;
e66c629e NC	108
93fbbb04 GK	109	void
	110	md_assemble (str)
	111	char * str;
	112	{
	113	xstormy16_insn insn;
	114	char * errmsg;
	115
e66c629e NC	116	/* Make sure that if we had an erroneous input line which triggered
	117	the skipping_fptr boolean that it does not affect following lines. */
	118	skipping_fptr = FALSE;
	119
93fbbb04 GK	120	/* Initialize GAS's cgen interface for a new instruction. */
	121	gas_cgen_init_parse ();
	122
	123	insn.insn = xstormy16_cgen_assemble_insn
	124	(gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
5d6255fe	125
93fbbb04 GK	126	if (!insn.insn)
	127	{
	128	as_bad (errmsg);
	129	return;
	130	}
	131
	132	/* Doesn't really matter what we pass for RELAX_P here. */
	133	gas_cgen_finish_insn (insn.insn, insn.buffer,
	134	CGEN_FIELDS_BITSIZE (& insn.fields), 0, NULL);
	135	}
	136
5d6255fe	137	void
93fbbb04 GK	138	md_operand (e)
	139	expressionS * e;
	140	{
	141	if (*input_line_pointer != '@')
	142	return;
	143
f53e95c7	144	if (strncmp (input_line_pointer + 1, "fptr", 4) == 0)
93fbbb04 GK	145	{
	146	input_line_pointer += 5;
	147	SKIP_WHITESPACE ();
	148	if (*input_line_pointer != '(')
	149	{
	150	as_bad ("Expected '('");
	151	goto err;
	152	}
	153	input_line_pointer++;
	154
	155	expression (e);
	156
	157	if (*input_line_pointer != ')')
	158	{
	159	as_bad ("Missing ')'");
	160	goto err;
	161	}
	162	input_line_pointer++;
e66c629e	163	SKIP_WHITESPACE ();
93fbbb04 GK	164
	165	if (e->X_op != O_symbol)
	166	as_bad ("Not a symbolic expression");
e66c629e NC	167	else if (* input_line_pointer == '-')
	168	/* We are computing the difference of two function pointers
	169	like this:
	170
	171	.hword @fptr (foo) - @fptr (bar)
	172
	173	In this situation we do not want to generate O_fptr_symbol
	174	operands because the result is an absolute value, not a
	175	function pointer.
	176
	177	We need to make the check here, rather than when the fixup
	178	is generated as the function names (foo & bar in the above
	179	example) might be local symbols and we want the expression
	180	to be evaluated now. This kind of thing can happen when
	181	gcc is generating computed gotos. */
	182	skipping_fptr = TRUE;
	183	else if (skipping_fptr)
	184	skipping_fptr = FALSE;
93fbbb04 GK	185	else
	186	e->X_op = O_fptr_symbol;
	187	}
	188
	189	return;
	190	err:
	191	ignore_rest_of_line ();
	192	}
	193
	194	/* Called while parsing data to create a fixup.
	195	Create BFD_RELOC_XSTORMY16_FPTR16 relocations. */
	196
	197	void
	198	xstormy16_cons_fix_new (f, where, nbytes, exp)
	199	fragS *f;
	200	int where;
	201	int nbytes;
	202	expressionS *exp;
	203	{
	204	bfd_reloc_code_real_type code;
	205	fixS *fix;
	206
	207	if (exp->X_op == O_fptr_symbol)
	208	{
	209	if (nbytes != 2)
	210	{
	211	as_bad ("unsupported fptr fixup size %d", nbytes);
	212	return;
	213	}
	214	exp->X_op = O_symbol;
	215	code = BFD_RELOC_XSTORMY16_FPTR16;
	216	}
	217	else if (nbytes == 1)
	218	code = BFD_RELOC_8;
	219	else if (nbytes == 2)
	220	code = BFD_RELOC_16;
	221	else if (nbytes == 4)
	222	code = BFD_RELOC_32;
	223	else
	224	{
	225	as_bad ("unsupported fixup size %d", nbytes);
	226	return;
	227	}
	228
	229	fix = fix_new_exp (f, where, nbytes, exp, 0, code);
	230	}
	231
5d6255fe	232	/* Called while parsing an instruction to create a fixup.
93fbbb04 GK	233	Create BFD_RELOC_XSTORMY16_FPTR16 relocations. */
	234
	235	fixS *
	236	xstormy16_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
	237	fragS * frag;
	238	int where;
	239	const CGEN_INSN * insn;
	240	int length;
	241	const CGEN_OPERAND * operand;
	242	int opinfo;
	243	expressionS * exp;
	244	{
	245	fixS *fixP;
	246	operatorT op = exp->X_op;
5d6255fe	247
93fbbb04 GK	248	if (op == O_fptr_symbol)
	249	exp->X_op = O_symbol;
	250
	251	fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
	252	operand, opinfo, exp);
	253
	254	if (op == O_fptr_symbol)
	255	{
	256	if (operand->type != XSTORMY16_OPERAND_IMM16)
	257	as_bad ("unsupported fptr fixup");
	258	else
	259	{
	260	fixP->fx_r_type = BFD_RELOC_XSTORMY16_FPTR16;
	261	fixP->fx_where += 2;
	262	}
	263	}
	264
	265	return fixP;
	266	}
	267
	268	valueT
	269	md_section_align (segment, size)
	270	segT segment;
	271	valueT size;
	272	{
	273	int align = bfd_get_section_alignment (stdoutput, segment);
	274	return ((size + (1 << align) - 1) & (-1 << align));
	275	}
	276
	277	symbolS *
	278	md_undefined_symbol (name)
	279	char * name ATTRIBUTE_UNUSED;
	280	{
	281	return 0;
	282	}
	283	\f
	284	/* Return an initial guess of the length by which a fragment must grow to
	285	hold a branch to reach its destination.
	286	Also updates fr_type/fr_subtype as necessary.
	287
	288	Called just before doing relaxation.
	289	Any symbol that is now undefined will not become defined.
	290	The guess for fr_var is ACTUALLY the growth beyond fr_fix.
	291	Whatever we do to grow fr_fix or fr_var contributes to our returned value.
	292	Although it may not be explicit in the frag, pretend fr_var starts with a
	293	0 value. */
	294
	295	int
	296	md_estimate_size_before_relax (fragP, segment)
	297	fragS * fragP ATTRIBUTE_UNUSED;
	298	segT segment ATTRIBUTE_UNUSED;
	299	{
	300	/* No assembler relaxation is defined (or necessary) for this port. */
	301	abort ();
5d6255fe	302	}
93fbbb04 GK	303
	304	/* *fragP has been relaxed to its final size, and now needs to have
	305	the bytes inside it modified to conform to the new size.
	306
	307	Called after relaxation is finished.
	308	fragP->fr_type == rs_machine_dependent.
	309	fragP->fr_subtype is the subtype of what the address relaxed to. */
	310
	311	void
	312	md_convert_frag (abfd, sec, fragP)
	313	bfd * abfd ATTRIBUTE_UNUSED;
	314	segT sec ATTRIBUTE_UNUSED;
	315	fragS * fragP ATTRIBUTE_UNUSED;
	316	{
	317	/* No assembler relaxation is defined (or necessary) for this port. */
	318	abort ();
	319	}
	320	\f
	321	/* Functions concerning relocs. */
	322
	323	/* The location from which a PC relative jump should be calculated,
	324	given a PC relative reloc. */
	325
	326	long
	327	md_pcrel_from_section (fixP, sec)
	328	fixS * fixP;
	329	segT sec;
	330	{
	331	if (fixP->fx_addsy != (symbolS *) NULL
	332	&& (! S_IS_DEFINED (fixP->fx_addsy)
ceb41009 NC	333	\|\| S_GET_SEGMENT (fixP->fx_addsy) != sec)
	334	\|\| xstormy16_force_relocation (fixP))
	335	/* The symbol is undefined,
	336	or it is defined but not in this section,
	337	or the relocation will be relative to this symbol not the section symbol.
	338	Let the linker figure it out. */
	339	return 0;
93fbbb04 GK	340
	341	return fixP->fx_frag->fr_address + fixP->fx_where;
	342	}
	343
	344	/* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
	345	Returns BFD_RELOC_NONE if no reloc type can be found.
	346	FIXP may be modified if desired. /
	347
	348	bfd_reloc_code_real_type
	349	md_cgen_lookup_reloc (insn, operand, fixP)
	350	const CGEN_INSN * insn ATTRIBUTE_UNUSED;
	351	const CGEN_OPERAND * operand;
	352	fixS * fixP;
	353	{
	354	switch (operand->type)
	355	{
	356	case XSTORMY16_OPERAND_IMM2:
	357	case XSTORMY16_OPERAND_IMM3:
	358	case XSTORMY16_OPERAND_IMM3B:
	359	case XSTORMY16_OPERAND_IMM4:
93fbbb04 GK	360	case XSTORMY16_OPERAND_HMEM8:
93fbbb04 GK	361	return BFD_RELOC_NONE;
5d6255fe	362
8f46beda DD	363	case XSTORMY16_OPERAND_IMM12:
	364	fixP->fx_where += 2;
	365	return BFD_RELOC_XSTORMY16_12;
	366
93fbbb04 GK	367	case XSTORMY16_OPERAND_IMM8:
	368	case XSTORMY16_OPERAND_LMEM8:
	369	return fixP->fx_pcrel ? BFD_RELOC_8_PCREL : BFD_RELOC_8;
5d6255fe	370
93fbbb04	371	case XSTORMY16_OPERAND_IMM16:
9bb76eb8	372	/* This might have been processed at parse time. */
93fbbb04	373	fixP->fx_where += 2;
9bb76eb8 DD	374	if (fixP->fx_cgen.opinfo && fixP->fx_cgen.opinfo != BFD_RELOC_NONE)
9bb76eb8 DD	375	return fixP->fx_cgen.opinfo;
93fbbb04 GK	376	return fixP->fx_pcrel ? BFD_RELOC_16_PCREL : BFD_RELOC_16;
	377
	378	case XSTORMY16_OPERAND_ABS24:
	379	return BFD_RELOC_XSTORMY16_24;
	380
93fbbb04	381	case XSTORMY16_OPERAND_REL8_4:
2d10acd2 DD	382	fixP->fx_addnumber -= 2;
	383	case XSTORMY16_OPERAND_REL8_2:
	384	fixP->fx_addnumber -= 2;
93fbbb04 GK	385	fixP->fx_pcrel = 1;
	386	return BFD_RELOC_8_PCREL;
	387
	388	case XSTORMY16_OPERAND_REL12:
	389	fixP->fx_where += 2;
5d6255fe	390	/* Fall through... */
93fbbb04	391	case XSTORMY16_OPERAND_REL12A:
2d10acd2	392	fixP->fx_addnumber -= 2;
93fbbb04 GK	393	fixP->fx_pcrel = 1;
	394	return BFD_RELOC_XSTORMY16_REL_12;
	395
	396	default : /* avoid -Wall warning */
	397	abort ();
	398	}
	399	}
	400
	401	/* See whether we need to force a relocation into the output file.
	402	This is used to force out switch and PC relative relocations when
	403	relaxing. */
	404
	405	int
	406	xstormy16_force_relocation (fix)
	407	fixS * fix;
	408	{
ae6063d4 AM	409	if (fix->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
ae6063d4 AM	410	return 1;
a161fe53	411
ae6063d4	412	return generic_force_reloc (fix);
93fbbb04 GK	413	}
	414
	415	/* Return true if a relocation against a symbol may be replaced with
	416	a relocation against section+offset. */
	417
b34976b6	418	bfd_boolean
93fbbb04 GK	419	xstormy16_fix_adjustable (fixP)
	420	fixS * fixP;
	421	{
1f7fd478	422	/* We need the symbol name for the VTABLE entries. */
a161fe53	423	if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1f7fd478 NC	424	\|\| fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
	425	return 0;
	426
a161fe53 AM	427	if (fixP->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
	428	return 0;
	429
	430	return 1;
93fbbb04 GK	431	}
	432
	433	/* This is a copy of gas_cgen_md_apply_fix3, with some enhancements to
	434	do various things that would not be valid for all ports. */
	435
	436	void
	437	xstormy16_md_apply_fix3 (fixP, valueP, seg)
	438	fixS * fixP;
	439	valueT * valueP;
	440	segT seg ATTRIBUTE_UNUSED;
	441	{
	442	char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
a161fe53	443	valueT value = *valueP;
93fbbb04 GK	444	/* Canonical name, since used a lot. */
	445	CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
	446
2d10acd2 DD	447	/* md_cgen_lookup_reloc() will adjust this to compensate for where
	448	in the opcode the relocation happens, for pcrel relocations. We
	449	have no other way of keeping track of what this offset needs to
	450	be. */
	451	fixP->fx_addnumber = 0;
	452
93fbbb04 GK	453	/* This port has pc-relative relocs and DIFF_EXPR_OK defined, so
	454	it must deal with turning a BFD_RELOC_{8,16,32,64} into a
	455	BFD_RELOC_*_PCREL for the case of
	456
	457	.word something-.
	458	*/
	459	if (fixP->fx_pcrel)
	460	switch (fixP->fx_r_type)
	461	{
	462	case BFD_RELOC_8:
	463	fixP->fx_r_type = BFD_RELOC_8_PCREL;
	464	break;
	465	case BFD_RELOC_16:
	466	fixP->fx_r_type = BFD_RELOC_16_PCREL;
	467	break;
	468	case BFD_RELOC_32:
	469	fixP->fx_r_type = BFD_RELOC_32_PCREL;
	470	break;
	471	case BFD_RELOC_64:
	472	fixP->fx_r_type = BFD_RELOC_64_PCREL;
	473	break;
	474	default:
	475	break;
	476	}
5d6255fe	477
93fbbb04	478	if (fixP->fx_addsy == (symbolS *) NULL)
a161fe53 AM	479	fixP->fx_done = 1;
	480
	481	/* We don't actually support subtracting a symbol. */
	482	if (fixP->fx_subsy != (symbolS *) NULL)
	483	as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
93fbbb04 GK	484
	485	if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
	486	{
	487	int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
	488	const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
	489	const char *errmsg;
	490	bfd_reloc_code_real_type reloc_type;
	491	CGEN_FIELDS *fields = alloca (CGEN_CPU_SIZEOF_FIELDS (cd));
	492	const CGEN_INSN *insn = fixP->fx_cgen.insn;
	493
	494	/* If the reloc has been fully resolved finish the operand here. */
	495	/* FIXME: This duplicates the capabilities of code in BFD. */
	496	if (fixP->fx_done)
	497	{
	498	CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
	499	CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
	500
	501	#if CGEN_INT_INSN_P
	502	{
	503	CGEN_INSN_INT insn_value =
	504	cgen_get_insn_value (cd, where, CGEN_INSN_BITSIZE (insn));
	505
	506	/* ??? 0 is passed for `pc'. */
	507	errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
	508	&insn_value, (bfd_vma) 0);
	509	cgen_put_insn_value (cd, where, CGEN_INSN_BITSIZE (insn),
	510	insn_value);
	511	}
	512	#else
	513	/* ??? 0 is passed for `pc'. */
	514	errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields, where,
	515	(bfd_vma) 0);
	516	#endif
	517	if (errmsg)
	518	as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
	519	}
	520
	521	if (fixP->fx_done)
1f7fd478	522	return;
93fbbb04 GK	523
	524	/* The operand isn't fully resolved. Determine a BFD reloc value
	525	based on the operand information and leave it to
	526	bfd_install_relocation. Note that this doesn't work when
b34976b6	527	!partial_inplace. */
93fbbb04 GK	528
	529	reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
	530	if (reloc_type != BFD_RELOC_NONE)
	531	{
	532	fixP->fx_r_type = reloc_type;
	533	}
	534	else
	535	{
	536	as_bad_where (fixP->fx_file, fixP->fx_line,
	537	_("unresolved expression that must be resolved"));
	538	fixP->fx_done = 1;
1f7fd478	539	return;
93fbbb04 GK	540	}
	541	}
	542	else if (fixP->fx_done)
	543	{
	544	/* We're finished with this fixup. Install it because
	545	bfd_install_relocation won't be called to do it. */
	546	switch (fixP->fx_r_type)
	547	{
	548	case BFD_RELOC_8:
	549	md_number_to_chars (where, value, 1);
	550	break;
	551	case BFD_RELOC_16:
	552	md_number_to_chars (where, value, 2);
	553	break;
	554	case BFD_RELOC_32:
	555	md_number_to_chars (where, value, 4);
	556	break;
	557	case BFD_RELOC_64:
	558	md_number_to_chars (where, value, 8);
	559	break;
	560	default:
	561	as_bad_where (fixP->fx_file, fixP->fx_line,
	562	_("internal error: can't install fix for reloc type %d (`%s')"),
	563	fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
	564	break;
	565	}
	566	}
	567	else
	568	{
	569	/* bfd_install_relocation will be called to finish things up. */
	570	}
	571
	572	/* This is a RELA port. Thus, it does not need to store a
	573	value if it is going to make a reloc. What's more, when
	574	assembling a line like
5d6255fe	575
93fbbb04	576	.byte global-0x7f00
5d6255fe	577
93fbbb04 GK	578	we'll get a spurious error message if we try to stuff 0x7f00 into
	579	the byte. */
	580	if (! fixP->fx_done)
	581	*valueP = 0;
	582
	583	/* Tuck `value' away for use by tc_gen_reloc.
	584	See the comment describing fx_addnumber in write.h.
ceb41009 NC	585	This field is misnamed (or misused :-). */
ceb41009 NC	586	fixP->fx_addnumber += value;
93fbbb04 GK	587	}
	588
	589	\f
	590	/* Write a value out to the object file, using the appropriate endianness. */
	591
	592	void
	593	md_number_to_chars (buf, val, n)
	594	char * buf;
	595	valueT val;
	596	int n;
	597	{
	598	number_to_chars_littleendian (buf, val, n);
	599	}
	600
	601	/* Turn a string in input_line_pointer into a floating point constant of type
	602	type, and store the appropriate bytes in *litP. The number of LITTLENUMS
	603	emitted is stored in *sizeP . An error message is returned, or NULL on OK.
	604	*/
	605
	606	/* Equal to MAX_PRECISION in atof-ieee.c */
	607	#define MAX_LITTLENUMS 6
	608
	609	char *
	610	md_atof (type, litP, sizeP)
	611	char type;
	612	char * litP;
	613	int * sizeP;
	614	{
	615	int prec;
	616	LITTLENUM_TYPE words [MAX_LITTLENUMS];
	617	LITTLENUM_TYPE *wordP;
	618	char * t;
	619
	620	switch (type)
	621	{
	622	case 'f':
	623	case 'F':
	624	prec = 2;
	625	break;
	626
	627	case 'd':
	628	case 'D':
	629	prec = 4;
	630	break;
	631
	632	/* FIXME: Some targets allow other format chars for bigger sizes here. */
	633
	634	default:
	635	* sizeP = 0;
	636	return _("Bad call to md_atof()");
	637	}
	638
	639	t = atof_ieee (input_line_pointer, type, words);
	640	if (t)
	641	input_line_pointer = t;
	642	* sizeP = prec * sizeof (LITTLENUM_TYPE);
	643
	644	sizeP = prec sizeof (LITTLENUM_TYPE);
	645	/* This loops outputs the LITTLENUMs in REVERSE order; in accord with
	646	the littleendianness of the processor. */
	647	for (wordP = words + prec - 1; prec--;)
	648	{
	649	md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
	650	litP += sizeof (LITTLENUM_TYPE);
651	}
5d6255fe	652
93fbbb04 GK	653	return 0;
93fbbb04 GK	654	}