[binutils.git] / gas / config / tc-ip2k.c

/* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
   Copyright (C) 2000, 2002, 2003, 2005 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, 51 Franklin Street - Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include <stdio.h>
#include "as.h"
#include "subsegs.h"     
#include "symcat.h"
#include "opcodes/ip2k-desc.h"
#include "opcodes/ip2k-opc.h"
#include "cgen.h"
#include "elf/common.h"
#include "elf/ip2k.h"
#include "libbfd.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];
}
ip2k_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";

/* Flag to detect when switching to code section where insn alignment is
   implied.  */
static int force_code_align = 0;

/* Mach selected from command line.  */
static int ip2k_mach = 0;
static unsigned ip2k_mach_bitmask = 0;


static void
ip2k_elf_section_rtn (int i)
{
  obj_elf_section(i);

  if (force_code_align)
    {
      /* The s_align_ptwo function expects that we are just after a .align
	 directive and it will either try and read the align value or stop
	 if end of line so we must fake it out so it thinks we are at the
	 end of the line.  */
      char *old_input_line_pointer = input_line_pointer;
      input_line_pointer = "\n";
      s_align_ptwo (1);
      force_code_align = 0;
      /* Restore.  */
      input_line_pointer = old_input_line_pointer;
    }
}

static void
ip2k_elf_section_text (int i)
{
  char *old_input_line_pointer;
  obj_elf_text(i);

  /* the s_align_ptwo function expects that we are just after a .align
     directive and it will either try and read the align value or stop if
     end of line so we must fake it out so it thinks we are at the end of
     the line.  */
  old_input_line_pointer = input_line_pointer;
  input_line_pointer = "\n";
  s_align_ptwo (1);
  force_code_align = 0;
  /* Restore.  */
  input_line_pointer = old_input_line_pointer;
}

/* The target specific pseudo-ops which we support.  */
const pseudo_typeS md_pseudo_table[] =
{
    { "text",   ip2k_elf_section_text,  0 },
    { "sect",   ip2k_elf_section_rtn,   0 },
    { NULL, 	NULL,			0 }
};

\f

enum options
{
  OPTION_CPU_IP2022 = OPTION_MD_BASE,
  OPTION_CPU_IP2022EXT
};

struct option md_longopts[] = 
{
  { "mip2022",     no_argument, NULL, OPTION_CPU_IP2022 },
  { "mip2022ext",  no_argument, NULL, OPTION_CPU_IP2022EXT },
  { NULL,           no_argument, NULL, 0 },
};
size_t md_longopts_size = sizeof (md_longopts);

const char * md_shortopts = "";

int
md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
{
  switch (c)
    {
    case OPTION_CPU_IP2022:
      ip2k_mach = bfd_mach_ip2022;
      ip2k_mach_bitmask = 1 << MACH_IP2022;
      break;

    case OPTION_CPU_IP2022EXT:
      ip2k_mach = bfd_mach_ip2022ext;
      ip2k_mach_bitmask = 1 << MACH_IP2022EXT;
      break;

    default:
      return 0;
    }

  return 1;
}

void
md_show_usage (FILE * stream)
{
  fprintf (stream, _("IP2K specific command line options:\n"));
  fprintf (stream, _("  -mip2022               restrict to IP2022 insns \n"));
  fprintf (stream, _("  -mip2022ext            permit extended IP2022 insn\n"));
}

\f
void
md_begin (void)
{
  /* Initialize the `cgen' interface.  */
  
  /* Set the machine number and endian.  */
  gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS,
					  ip2k_mach_bitmask,
					  CGEN_CPU_OPEN_ENDIAN,
					  CGEN_ENDIAN_BIG,
					  CGEN_CPU_OPEN_END);
  ip2k_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);

  /* Set the machine type.  */
  bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach);
}


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

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

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

  if (!insn.insn)
    {
      as_bad ("%s", errmsg);
      return;
    }

  /* Check for special relocation required by SKIP instructions.  */
  if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA))
    /* Unconditional skip has a 1-bit relocation of the current pc, so
       that we emit either sb pcl.0 or snb pcl.0 depending on whether
       the PCL (pc + 2) >> 1 is odd or even.  */
    {
      enum cgen_parse_operand_result result_type;
      bfd_vma value;
      const char *curpc_plus_2 = ".+2";
      const char *err;

      err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2,
				IP2K_OPERAND_ADDR16CJP,
				BFD_RELOC_IP2K_PC_SKIP,
				& result_type, & value);
      if (err)
	{
	  as_bad ("%s", err);
	  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), 1, NULL);
}

valueT
md_section_align (segT segment, valueT size)
{
  int align = bfd_get_section_alignment (stdoutput, segment);

  return ((size + (1 << align) - 1) & (-1 << align));
}


symbolS *
md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
{
    return 0;
}
\f
int
md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
			       segT    segment ATTRIBUTE_UNUSED)
{
  as_fatal (_("md_estimate_size_before_relax\n"));
  return 1;
} 


/* *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 (bfd   * abfd  ATTRIBUTE_UNUSED,
		 segT    sec   ATTRIBUTE_UNUSED,
		 fragS * fragP ATTRIBUTE_UNUSED)
{
}

\f
/* Functions concerning relocs.  */

long
md_pcrel_from (fixS *fixP)
{
  as_fatal (_("md_pcrel_from\n"));

  /* Return the address of the delay slot. */
  return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
}


/* 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 (const CGEN_INSN *    insn     ATTRIBUTE_UNUSED,
		      const CGEN_OPERAND * operand,
		      fixS *               fixP     ATTRIBUTE_UNUSED)
{
  bfd_reloc_code_real_type result;

  result = BFD_RELOC_NONE;

  switch (operand->type)
    {
    case IP2K_OPERAND_FR:
    case IP2K_OPERAND_ADDR16L:
    case IP2K_OPERAND_ADDR16H:
    case IP2K_OPERAND_LIT8:
      /* These may have been processed at parse time.  */
      if (fixP->fx_cgen.opinfo != 0)
	result = fixP->fx_cgen.opinfo;
      fixP->fx_no_overflow = 1;
      break;

    case IP2K_OPERAND_ADDR16CJP:
      result = fixP->fx_cgen.opinfo;
      if (result == 0 || result == BFD_RELOC_NONE)
	result = BFD_RELOC_IP2K_ADDR16CJP;
      fixP->fx_no_overflow = 1;
      break;

    case IP2K_OPERAND_ADDR16P:
      result = BFD_RELOC_IP2K_PAGE3;
      fixP->fx_no_overflow = 1;
      break;

    default:
      result = BFD_RELOC_NONE;
      break;
    }

  return result;
}


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

void
md_number_to_chars (char * buf, valueT val, int n)
{
  number_to_chars_bigendian (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 (int type, char * litP, int *  sizeP)
{
  int              prec;
  LITTLENUM_TYPE   words [MAX_LITTLENUMS];
  LITTLENUM_TYPE  *wordP;
  char *           t;

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

    case 'd':
    case 'D':
    case 'r':
    case 'R':
      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);

  /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
     the ip2k endianness.  */
  for (wordP = words; prec--;)
    {
      md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
      litP += sizeof (LITTLENUM_TYPE);
    }
     
  return 0;
}


/* See whether we need to force a relocation into the output file.
   Force most of them, since the linker's bfd relocation engine
   understands range limits better than gas' cgen fixup engine.
   Consider the case of a fixup intermediate value being larger than
   the instruction it will be eventually encoded within.  */

int
ip2k_force_relocation (fixS * fix)
{
  switch (fix->fx_r_type)
    {
    case BFD_RELOC_IP2K_FR9:
    case BFD_RELOC_IP2K_FR_OFFSET:
    case BFD_RELOC_IP2K_BANK:
    case BFD_RELOC_IP2K_ADDR16CJP:
    case BFD_RELOC_IP2K_PAGE3:
    case BFD_RELOC_IP2K_LO8DATA:
    case BFD_RELOC_IP2K_HI8DATA:
    case BFD_RELOC_IP2K_EX8DATA:
    case BFD_RELOC_IP2K_LO8INSN:
    case BFD_RELOC_IP2K_HI8INSN:
    case BFD_RELOC_IP2K_PC_SKIP:
    case BFD_RELOC_IP2K_TEXT:
      return 1;

    case BFD_RELOC_16:
      if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy)
	  && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy)
	  && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE))
	{
	  fix->fx_r_type = BFD_RELOC_IP2K_TEXT;
	  return 0;
	}
      break;

    default:
      break;
    }

  return generic_force_reloc (fix);
}

void
ip2k_apply_fix (fixS *fixP, valueT *valueP, segT seg)
{
  if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT
      && ! fixP->fx_addsy
      && ! fixP->fx_subsy)
    {
      *valueP = ((int)(* valueP)) / 2;
      fixP->fx_r_type = BFD_RELOC_16;
    }
  else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR)
    {
      /* Must be careful when we are fixing up an FR.  We could be
	 fixing up an offset to (SP) or (DP) in which case we don't
	 want to step on the top 2 bits of the FR operand.  The
	 gas_cgen_md_apply_fix doesn't know any better and overwrites
	 the entire operand.  We counter this by adding the bits
	 to the new value.  */
      char *where = fixP->fx_frag->fr_literal + fixP->fx_where;

      /* Canonical name, since used a lot.  */
      CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
      CGEN_INSN_INT insn_value
	= cgen_get_insn_value (cd, (unsigned char *) where,
			       CGEN_INSN_BITSIZE (fixP->fx_cgen.insn));
      /* Preserve (DP) or (SP) specification.  */
      *valueP += (insn_value & 0x180);
    }

  gas_cgen_md_apply_fix (fixP, valueP, seg);
}

int
ip2k_elf_section_flags (int flags,
			int attr ATTRIBUTE_UNUSED,
			int type ATTRIBUTE_UNUSED)
{
  /* This is used to detect when the section changes to an executable section.
     This function is called by the elf section processing.  When we note an
     executable section specifier we set an internal flag to denote when
     word alignment should be forced.  */
  if (flags & SEC_CODE)
    force_code_align = 1;
 
  return flags;
}
Commit	Line	Data
a40cbfa3	1	/* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
2132e3a3	2	Copyright (C) 2000, 2002, 2003, 2005 Free Software Foundation.
a40cbfa3 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 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
4b4da160 NC	18	the Free Software Foundation, 51 Franklin Street - Fifth Floor,
4b4da160 NC	19	Boston, MA 02110-1301, USA. */
a40cbfa3 NC	20
a40cbfa3 NC	21	#include <stdio.h>
a40cbfa3	22	#include "as.h"
a40cbfa3 NC	23	#include "subsegs.h"
	24	#include "symcat.h"
	25	#include "opcodes/ip2k-desc.h"
	26	#include "opcodes/ip2k-opc.h"
	27	#include "cgen.h"
	28	#include "elf/common.h"
	29	#include "elf/ip2k.h"
	30	#include "libbfd.h"
	31
	32	/* Structure to hold all of the different components describing
	33	an individual instruction. */
	34	typedef struct
	35	{
	36	const CGEN_INSN * insn;
	37	const CGEN_INSN * orig_insn;
	38	CGEN_FIELDS fields;
	39	#if CGEN_INT_INSN_P
	40	CGEN_INSN_INT buffer [1];
	41	#define INSN_VALUE(buf) (*(buf))
	42	#else
	43	unsigned char buffer [CGEN_MAX_INSN_SIZE];
	44	#define INSN_VALUE(buf) (buf)
	45	#endif
	46	char * addr;
	47	fragS * frag;
	48	int num_fixups;
	49	fixS * fixups [GAS_CGEN_MAX_FIXUPS];
	50	int indices [MAX_OPERAND_INSTANCES];
	51	}
	52	ip2k_insn;
	53
	54	const char comment_chars[] = ";";
	55	const char line_comment_chars[] = "#";
	56	const char line_separator_chars[] = "";
	57	const char EXP_CHARS[] = "eE";
	58	const char FLT_CHARS[] = "dD";
	59
ea1562b3 NC	60	/* Flag to detect when switching to code section where insn alignment is
	61	implied. */
	62	static int force_code_align = 0;
	63
	64	/* Mach selected from command line. */
	65	static int ip2k_mach = 0;
	66	static unsigned ip2k_mach_bitmask = 0;
	67
	68
	69	static void
	70	ip2k_elf_section_rtn (int i)
	71	{
	72	obj_elf_section(i);
	73
	74	if (force_code_align)
	75	{
	76	/* The s_align_ptwo function expects that we are just after a .align
	77	directive and it will either try and read the align value or stop
	78	if end of line so we must fake it out so it thinks we are at the
	79	end of the line. */
	80	char *old_input_line_pointer = input_line_pointer;
	81	input_line_pointer = "\n";
	82	s_align_ptwo (1);
	83	force_code_align = 0;
	84	/* Restore. */
	85	input_line_pointer = old_input_line_pointer;
	86	}
	87	}
	88
	89	static void
	90	ip2k_elf_section_text (int i)
	91	{
	92	char *old_input_line_pointer;
	93	obj_elf_text(i);
	94
	95	/* the s_align_ptwo function expects that we are just after a .align
	96	directive and it will either try and read the align value or stop if
	97	end of line so we must fake it out so it thinks we are at the end of
	98	the line. */
	99	old_input_line_pointer = input_line_pointer;
	100	input_line_pointer = "\n";
	101	s_align_ptwo (1);
	102	force_code_align = 0;
	103	/* Restore. */
	104	input_line_pointer = old_input_line_pointer;
	105	}
a40cbfa3 NC	106
	107	/* The target specific pseudo-ops which we support. */
	108	const pseudo_typeS md_pseudo_table[] =
	109	{
a40cbfa3 NC	110	{ "text", ip2k_elf_section_text, 0 },
	111	{ "sect", ip2k_elf_section_rtn, 0 },
	112	{ NULL, NULL, 0 }
	113	};
	114
	115	\f
	116
ea1562b3 NC	117	enum options
	118	{
	119	OPTION_CPU_IP2022 = OPTION_MD_BASE,
	120	OPTION_CPU_IP2022EXT
	121	};
a40cbfa3 NC	122
	123	struct option md_longopts[] =
	124	{
	125	{ "mip2022", no_argument, NULL, OPTION_CPU_IP2022 },
	126	{ "mip2022ext", no_argument, NULL, OPTION_CPU_IP2022EXT },
	127	{ NULL, no_argument, NULL, 0 },
	128	};
	129	size_t md_longopts_size = sizeof (md_longopts);
	130
	131	const char * md_shortopts = "";
	132
a40cbfa3	133	int
ea1562b3	134	md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED)
a40cbfa3 NC	135	{
	136	switch (c)
	137	{
	138	case OPTION_CPU_IP2022:
	139	ip2k_mach = bfd_mach_ip2022;
	140	ip2k_mach_bitmask = 1 << MACH_IP2022;
	141	break;
	142
	143	case OPTION_CPU_IP2022EXT:
	144	ip2k_mach = bfd_mach_ip2022ext;
	145	ip2k_mach_bitmask = 1 << MACH_IP2022EXT;
	146	break;
	147
	148	default:
	149	return 0;
	150	}
	151
	152	return 1;
	153	}
	154
a40cbfa3	155	void
ea1562b3	156	md_show_usage (FILE * stream)
a40cbfa3 NC	157	{
	158	fprintf (stream, _("IP2K specific command line options:\n"));
	159	fprintf (stream, _(" -mip2022 restrict to IP2022 insns \n"));
	160	fprintf (stream, _(" -mip2022ext permit extended IP2022 insn\n"));
	161	}
	162
	163	\f
	164	void
ea1562b3	165	md_begin (void)
a40cbfa3 NC	166	{
	167	/* Initialize the `cgen' interface. */
	168
	169	/* Set the machine number and endian. */
	170	gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS,
	171	ip2k_mach_bitmask,
	172	CGEN_CPU_OPEN_ENDIAN,
	173	CGEN_ENDIAN_BIG,
	174	CGEN_CPU_OPEN_END);
	175	ip2k_cgen_init_asm (gas_cgen_cpu_desc);
	176
	177	/* This is a callback from cgen to gas to parse operands. */
	178	cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
	179
	180	/* Set the machine type. */
	181	bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach);
	182	}
	183
	184
	185	void
ea1562b3	186	md_assemble (char * str)
a40cbfa3 NC	187	{
	188	ip2k_insn insn;
	189	char * errmsg;
	190
	191	/* Initialize GAS's cgen interface for a new instruction. */
	192	gas_cgen_init_parse ();
	193
	194	insn.insn = ip2k_cgen_assemble_insn
	195	(gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
	196
	197	if (!insn.insn)
	198	{
	199	as_bad ("%s", errmsg);
	200	return;
	201	}
	202
	203	/* Check for special relocation required by SKIP instructions. */
	204	if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA))
	205	/* Unconditional skip has a 1-bit relocation of the current pc, so
	206	that we emit either sb pcl.0 or snb pcl.0 depending on whether
	207	the PCL (pc + 2) >> 1 is odd or even. */
	208	{
	209	enum cgen_parse_operand_result result_type;
2132e3a3	210	bfd_vma value;
a40cbfa3	211	const char *curpc_plus_2 = ".+2";
64384dfd	212	const char *err;
a40cbfa3	213
64384dfd AM	214	err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2,
	215	IP2K_OPERAND_ADDR16CJP,
	216	BFD_RELOC_IP2K_PC_SKIP,
	217	& result_type, & value);
	218	if (err)
a40cbfa3	219	{
64384dfd	220	as_bad ("%s", err);
a40cbfa3 NC	221	return;
	222	}
	223	}
	224
	225	/* Doesn't really matter what we pass for RELAX_P here. */
	226	gas_cgen_finish_insn (insn.insn, insn.buffer,
	227	CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
	228	}
	229
	230	valueT
ea1562b3	231	md_section_align (segT segment, valueT size)
a40cbfa3 NC	232	{
	233	int align = bfd_get_section_alignment (stdoutput, segment);
	234
	235	return ((size + (1 << align) - 1) & (-1 << align));
	236	}
	237
	238
	239	symbolS *
ea1562b3	240	md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
a40cbfa3 NC	241	{
	242	return 0;
	243	}
	244	\f
	245	int
ea1562b3 NC	246	md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
ea1562b3 NC	247	segT segment ATTRIBUTE_UNUSED)
a40cbfa3 NC	248	{
	249	as_fatal (_("md_estimate_size_before_relax\n"));
	250	return 1;
	251	}
	252
	253
	254	/* *fragP has been relaxed to its final size, and now needs to have
	255	the bytes inside it modified to conform to the new size.
	256
	257	Called after relaxation is finished.
	258	fragP->fr_type == rs_machine_dependent.
	259	fragP->fr_subtype is the subtype of what the address relaxed to. */
	260
	261	void
ea1562b3 NC	262	md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
	263	segT sec ATTRIBUTE_UNUSED,
	264	fragS * fragP ATTRIBUTE_UNUSED)
a40cbfa3 NC	265	{
	266	}
	267
	268	\f
	269	/* Functions concerning relocs. */
	270
	271	long
ea1562b3	272	md_pcrel_from (fixS *fixP)
a40cbfa3 NC	273	{
	274	as_fatal (_("md_pcrel_from\n"));
	275
	276	/* Return the address of the delay slot. */
	277	return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
	278	}
	279
	280
	281	/* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
	282	Returns BFD_RELOC_NONE if no reloc type can be found.
	283	FIXP may be modified if desired. /
	284
	285	bfd_reloc_code_real_type
ea1562b3 NC	286	md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED,
	287	const CGEN_OPERAND * operand,
	288	fixS * fixP ATTRIBUTE_UNUSED)
a40cbfa3 NC	289	{
	290	bfd_reloc_code_real_type result;
	291
	292	result = BFD_RELOC_NONE;
	293
	294	switch (operand->type)
	295	{
	296	case IP2K_OPERAND_FR:
	297	case IP2K_OPERAND_ADDR16L:
	298	case IP2K_OPERAND_ADDR16H:
	299	case IP2K_OPERAND_LIT8:
	300	/* These may have been processed at parse time. */
	301	if (fixP->fx_cgen.opinfo != 0)
	302	result = fixP->fx_cgen.opinfo;
	303	fixP->fx_no_overflow = 1;
	304	break;
	305
	306	case IP2K_OPERAND_ADDR16CJP:
	307	result = fixP->fx_cgen.opinfo;
	308	if (result == 0 \|\| result == BFD_RELOC_NONE)
	309	result = BFD_RELOC_IP2K_ADDR16CJP;
	310	fixP->fx_no_overflow = 1;
	311	break;
	312
	313	case IP2K_OPERAND_ADDR16P:
	314	result = BFD_RELOC_IP2K_PAGE3;
	315	fixP->fx_no_overflow = 1;
	316	break;
	317
	318	default:
	319	result = BFD_RELOC_NONE;
	320	break;
	321	}
	322
	323	return result;
	324	}
	325
	326
	327	/* Write a value out to the object file, using the appropriate endianness. */
	328
	329	void
ea1562b3	330	md_number_to_chars (char * buf, valueT val, int n)
a40cbfa3 NC	331	{
	332	number_to_chars_bigendian (buf, val, n);
	333	}
	334
	335	/* Turn a string in input_line_pointer into a floating point constant of type
	336	type, and store the appropriate bytes in *litP. The number of LITTLENUMS
	337	emitted is stored in *sizeP . An error message is returned, or NULL on
	338	OK. */
	339
	340	/* Equal to MAX_PRECISION in atof-ieee.c */
	341	#define MAX_LITTLENUMS 6
	342
	343	char *
ea1562b3	344	md_atof (int type, char * litP, int * sizeP)
a40cbfa3 NC	345	{
	346	int prec;
	347	LITTLENUM_TYPE words [MAX_LITTLENUMS];
	348	LITTLENUM_TYPE *wordP;
	349	char * t;
a40cbfa3 NC	350
	351	switch (type)
	352	{
	353	case 'f':
	354	case 'F':
	355	case 's':
	356	case 'S':
	357	prec = 2;
	358	break;
	359
	360	case 'd':
	361	case 'D':
	362	case 'r':
	363	case 'R':
	364	prec = 4;
	365	break;
	366
	367	/* FIXME: Some targets allow other format chars for bigger sizes here. */
	368
	369	default:
	370	* sizeP = 0;
	371	return _("Bad call to md_atof()");
	372	}
	373
	374	t = atof_ieee (input_line_pointer, type, words);
	375	if (t)
	376	input_line_pointer = t;
	377	* sizeP = prec * sizeof (LITTLENUM_TYPE);
	378
	379	/* This loops outputs the LITTLENUMs in REVERSE order; in accord with
	380	the ip2k endianness. */
	381	for (wordP = words; prec--;)
	382	{
	383	md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
	384	litP += sizeof (LITTLENUM_TYPE);
	385	}
	386
	387	return 0;
	388	}
	389
	390
	391	/* See whether we need to force a relocation into the output file.
	392	Force most of them, since the linker's bfd relocation engine
	393	understands range limits better than gas' cgen fixup engine.
	394	Consider the case of a fixup intermediate value being larger than
	395	the instruction it will be eventually encoded within. */
	396
	397	int
ea1562b3	398	ip2k_force_relocation (fixS * fix)
a40cbfa3 NC	399	{
	400	switch (fix->fx_r_type)
	401	{
a40cbfa3 NC	402	case BFD_RELOC_IP2K_FR9:
	403	case BFD_RELOC_IP2K_FR_OFFSET:
	404	case BFD_RELOC_IP2K_BANK:
	405	case BFD_RELOC_IP2K_ADDR16CJP:
	406	case BFD_RELOC_IP2K_PAGE3:
	407	case BFD_RELOC_IP2K_LO8DATA:
	408	case BFD_RELOC_IP2K_HI8DATA:
	409	case BFD_RELOC_IP2K_EX8DATA:
	410	case BFD_RELOC_IP2K_LO8INSN:
	411	case BFD_RELOC_IP2K_HI8INSN:
	412	case BFD_RELOC_IP2K_PC_SKIP:
	413	case BFD_RELOC_IP2K_TEXT:
	414	return 1;
	415
	416	case BFD_RELOC_16:
a161fe53	417	if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy)
a40cbfa3 NC	418	&& fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy)
	419	&& (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE))
	420	{
	421	fix->fx_r_type = BFD_RELOC_IP2K_TEXT;
	422	return 0;
	423	}
a161fe53	424	break;
a40cbfa3 NC	425
a40cbfa3 NC	426	default:
a161fe53	427	break;
a40cbfa3	428	}
a161fe53	429
ae6063d4	430	return generic_force_reloc (fix);
a40cbfa3 NC	431	}
	432
	433	void
55cf6793	434	ip2k_apply_fix (fixS fixP, valueT valueP, segT seg)
a40cbfa3 NC	435	{
	436	if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT
	437	&& ! fixP->fx_addsy
	438	&& ! fixP->fx_subsy)
	439	{
ea1562b3	440	valueP = ((int)( valueP)) / 2;
a40cbfa3 NC	441	fixP->fx_r_type = BFD_RELOC_16;
	442	}
	443	else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR)
	444	{
	445	/* Must be careful when we are fixing up an FR. We could be
	446	fixing up an offset to (SP) or (DP) in which case we don't
	447	want to step on the top 2 bits of the FR operand. The
55cf6793	448	gas_cgen_md_apply_fix doesn't know any better and overwrites
a40cbfa3 NC	449	the entire operand. We counter this by adding the bits
	450	to the new value. */
	451	char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
	452
	453	/* Canonical name, since used a lot. */
	454	CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
	455	CGEN_INSN_INT insn_value
2132e3a3	456	= cgen_get_insn_value (cd, (unsigned char *) where,
a40cbfa3 NC	457	CGEN_INSN_BITSIZE (fixP->fx_cgen.insn));
	458	/* Preserve (DP) or (SP) specification. */
	459	*valueP += (insn_value & 0x180);
	460	}
	461
55cf6793	462	gas_cgen_md_apply_fix (fixP, valueP, seg);
a40cbfa3 NC	463	}
	464
	465	int
ea1562b3 NC	466	ip2k_elf_section_flags (int flags,
	467	int attr ATTRIBUTE_UNUSED,
	468	int type ATTRIBUTE_UNUSED)
a40cbfa3 NC	469	{
	470	/* This is used to detect when the section changes to an executable section.
	471	This function is called by the elf section processing. When we note an
	472	executable section specifier we set an internal flag to denote when
	473	word alignment should be forced. */
	474	if (flags & SEC_CODE)
	475	force_code_align = 1;
	476
	477	return flags;
	478	}
	479