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