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

/* tc-ip2k.c -- Assembler for the Scenix IP2xxx.
   Copyright (C) 2000, 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 <ctype.h>

#include "as.h"
#include "dwarf2dbg.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";

static void ip2k_elf_section_text (int);
static void ip2k_elf_section_rtn (int);

/* The target specific pseudo-ops which we support.  */
const pseudo_typeS md_pseudo_table[] =
{
    { "file",	(void (*) PARAMS ((int))) dwarf2_directive_file, 0 },
    { "loc",	dwarf2_directive_loc,	0 },
    { "text",   ip2k_elf_section_text,  0 },
    { "sect",   ip2k_elf_section_rtn,   0 },
    { NULL, 	NULL,			0 }
};

\f

#define OPTION_CPU_IP2022    (OPTION_MD_BASE)
#define OPTION_CPU_IP2022EXT (OPTION_MD_BASE+1)

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 = "";

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

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

int
md_parse_option (c, arg)
    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 (stream)
    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 ()
{
  /* 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 (str)
     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;
      long 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 (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
int
md_estimate_size_before_relax (fragP, segment)
     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 (abfd, sec, fragP)
    bfd   * abfd  ATTRIBUTE_UNUSED;
    segT    sec   ATTRIBUTE_UNUSED;
    fragS * fragP ATTRIBUTE_UNUSED;
{
}

\f
/* Functions concerning relocs.  */

long
md_pcrel_from (fixP)
     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 (insn, operand, fixP)
     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 (buf, val, n)
     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 (type, litP, sizeP)
     char   type;
     char * litP;
     int *  sizeP;
{
  int              prec;
  LITTLENUM_TYPE   words [MAX_LITTLENUMS];
  LITTLENUM_TYPE  *wordP;
  char *           t;
  char *           atof_ieee PARAMS ((char *, int, LITTLENUM_TYPE *));

  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 (fix)
     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_fix3 (fixP, valueP, seg)
     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_fix3 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, where,
			       CGEN_INSN_BITSIZE (fixP->fx_cgen.insn));
      /* Preserve (DP) or (SP) specification.  */
      *valueP += (insn_value & 0x180);
    }

  gas_cgen_md_apply_fix3 (fixP, valueP, seg);
}

int
ip2k_elf_section_flags (flags, attr, type)
     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;
}

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