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

/* tc-openrisc.c -- Assembler for the OpenRISC family.
   Copyright 2001, 2002, 2003 Free Software Foundation.
   Contributed by Johan Rydberg, jrydberg@opencores.org

   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/openrisc-desc.h"
#include "opcodes/openrisc-opc.h"
#include "cgen.h"

/* Structure to hold all of the different components describing
   an individual instruction.  */
typedef struct openrisc_insn openrisc_insn;

struct openrisc_insn
{
  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];
};


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

\f
#define OPENRISC_SHORTOPTS "m:"
const char * md_shortopts = OPENRISC_SHORTOPTS;

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

unsigned long openrisc_machine = 0; /* default */

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

void
md_show_usage (stream)
  FILE * stream ATTRIBUTE_UNUSED;
{
}

static void ignore_pseudo PARAMS ((int));

static void
ignore_pseudo (val)
     int val ATTRIBUTE_UNUSED;
{
  discard_rest_of_line ();
}

const char openrisc_comment_chars [] = ";#";

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


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

  /* Set the machine number and endian.  */
  gas_cgen_cpu_desc = openrisc_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
                                              CGEN_CPU_OPEN_ENDIAN,
                                              CGEN_ENDIAN_BIG,
                                              CGEN_CPU_OPEN_END);
  openrisc_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);
}

void
md_assemble (str)
     char * str;
{
  static int last_insn_had_delay_slot = 0;
  openrisc_insn insn;
  char *    errmsg;

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

  insn.insn = openrisc_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), 1, NULL);

#if 0 /* Currently disabled  */
  /* Warn about invalid insns in delay slots.  */
  if (last_insn_had_delay_slot
      && CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_NOT_IN_DELAY_SLOT))
    as_warn (_("Instruction %s not allowed in a delay slot."),
	     CGEN_INSN_NAME (insn.insn));
#endif

  last_insn_had_delay_slot
    = CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT);
}


/* The syntax in the manual says constants begin with '#'.
   We just ignore it.  */

void
md_operand (expressionP)
     expressionS * expressionP;
{
  if (* input_line_pointer == '#')
    {
      input_line_pointer ++;
      expression (expressionP);
    }
}

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
/* Interface to relax_segment.  */

/* FIXME: Look through this.  */

const relax_typeS md_relax_table[] =
{
/* The fields are:
   1) most positive reach of this state,
   2) most negative reach of this state,
   3) how many bytes this mode will add to the size of the current frag
   4) which index into the table to try if we can't fit into this one.  */

  /* The first entry must be unused because an `rlx_more' value of zero ends
     each list.  */
  {1, 1, 0, 0},

  /* The displacement used by GAS is from the end of the 2 byte insn,
     so we subtract 2 from the following.  */
  /* 16 bit insn, 8 bit disp -> 10 bit range.
     This doesn't handle a branch in the right slot at the border:
     the "& -4" isn't taken into account.  It's not important enough to
     complicate things over it, so we subtract an extra 2 (or + 2 in -ve
     case).  */
  {511 - 2 - 2, -512 - 2 + 2, 0, 2 },
  /* 32 bit insn, 24 bit disp -> 26 bit range.  */
  {0x2000000 - 1 - 2, -0x2000000 - 2, 2, 0 },
  /* Same thing, but with leading nop for alignment.  */
  {0x2000000 - 1 - 2, -0x2000000 - 2, 4, 0 }
};

long
openrisc_relax_frag (segment, fragP, stretch)
     segT    segment;
     fragS * fragP;
     long    stretch;
{
  /* Address of branch insn.  */
  long address = fragP->fr_address + fragP->fr_fix - 2;
  long growth = 0;

  /* Keep 32 bit insns aligned on 32 bit boundaries.  */
  if (fragP->fr_subtype == 2)
    {
      if ((address & 3) != 0)
	{
	  fragP->fr_subtype = 3;
	  growth = 2;
	}
    }
  else if (fragP->fr_subtype == 3)
    {
      if ((address & 3) == 0)
	{
	  fragP->fr_subtype = 2;
	  growth = -2;
	}
    }
  else
    {
      growth = relax_frag (segment, fragP, stretch);

      /* Long jump on odd halfword boundary?  */
      if (fragP->fr_subtype == 2 && (address & 3) != 0)
	{
	  fragP->fr_subtype = 3;
	  growth += 2;
	}
    }

  return growth;
}


/* 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;
     segT    segment;
{
  /* The only thing we have to handle here are symbols outside of the
     current segment.  They may be undefined or in a different segment in
     which case linker scripts may place them anywhere.
     However, we can't finish the fragment here and emit the reloc as insn
     alignment requirements may move the insn about.  */

  if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
    {
      /* The symbol is undefined in this segment.
	 Change the relaxation subtype to the max allowable and leave
	 all further handling to md_convert_frag.  */
      fragP->fr_subtype = 2;

      {
	const CGEN_INSN * insn;
	int               i;

	/* Update the recorded insn.
	   Fortunately we don't have to look very far.
	   FIXME: Change this to record in the instruction the next higher
	   relaxable insn to use.  */
	for (i = 0, insn = fragP->fr_cgen.insn; i < 4; i++, insn++)
	  {
	    if ((strcmp (CGEN_INSN_MNEMONIC (insn),
			 CGEN_INSN_MNEMONIC (fragP->fr_cgen.insn))
		 == 0)
		&& CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAX))
	      break;
	  }
	if (i == 4)
	  abort ();

	fragP->fr_cgen.insn = insn;
	return 2;
      }
    }

  return md_relax_table[fragP->fr_subtype].rlx_length;
}

/* *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;
{
  /* FIXME */
}

\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))
    {
      /* The symbol is undefined (or is defined but not in this section).
	 Let the linker figure it out.  */
      return 0;
    }

  return (fixP->fx_frag->fr_address + fixP->fx_where) & ~1;
}


/* 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;
{
  bfd_reloc_code_real_type type;

  switch (operand->type)
    {
    case OPENRISC_OPERAND_ABS_26:
      fixP->fx_pcrel = 0;
      type = BFD_RELOC_OPENRISC_ABS_26;
      goto emit;
    case OPENRISC_OPERAND_DISP_26:
      fixP->fx_pcrel = 1;
      type = BFD_RELOC_OPENRISC_REL_26;
      goto emit;

    case OPENRISC_OPERAND_HI16:
      type = BFD_RELOC_HI16;
      goto emit;

    case OPENRISC_OPERAND_LO16:
      type = BFD_RELOC_LO16;
      goto emit;

    emit:
      return type;

    default : /* avoid -Wall warning */
      break;
    }

  return BFD_RELOC_NONE;
}
\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_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              i;
  int              prec;
  LITTLENUM_TYPE   words [MAX_LITTLENUMS];
  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);

  for (i = 0; i < prec; i++)
    {
      md_number_to_chars (litP, (valueT) words[i],
			  sizeof (LITTLENUM_TYPE));
      litP += sizeof (LITTLENUM_TYPE);
    }

  return 0;
}

bfd_boolean
openrisc_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;

  return 1;
}
Commit	Line	Data
c7e40348	1	/* tc-openrisc.c -- Assembler for the OpenRISC family.
ae6063d4	2	Copyright 2001, 2002, 2003 Free Software Foundation.
c7e40348 NC	3	Contributed by Johan Rydberg, jrydberg@opencores.org
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to
	19	the Free Software Foundation, 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
	22	#include <stdio.h>
c7e40348 NC	23	#include "as.h"
	24	#include "subsegs.h"
	25	#include "symcat.h"
	26	#include "opcodes/openrisc-desc.h"
	27	#include "opcodes/openrisc-opc.h"
	28	#include "cgen.h"
	29
	30	/* Structure to hold all of the different components describing
	31	an individual instruction. */
	32	typedef struct openrisc_insn openrisc_insn;
	33
	34	struct openrisc_insn
	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
	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
	60	\f
	61	#define OPENRISC_SHORTOPTS "m:"
	62	const char * md_shortopts = OPENRISC_SHORTOPTS;
	63
	64	struct option md_longopts[] =
	65	{
	66	{NULL, no_argument, NULL, 0}
	67	};
	68	size_t md_longopts_size = sizeof (md_longopts);
	69
	70	unsigned long openrisc_machine = 0; /* default */
	71
	72	int
	73	md_parse_option (c, arg)
	74	int c ATTRIBUTE_UNUSED;
	75	char * arg ATTRIBUTE_UNUSED;
	76	{
	77	return 0;
	78	}
	79
	80	void
	81	md_show_usage (stream)
	82	FILE * stream ATTRIBUTE_UNUSED;
	83	{
	84	}
	85
717acf4b AM	86	static void ignore_pseudo PARAMS ((int));
717acf4b AM	87
c7e40348 NC	88	static void
	89	ignore_pseudo (val)
	90	int val ATTRIBUTE_UNUSED;
	91	{
	92	discard_rest_of_line ();
	93	}
	94
	95	const char openrisc_comment_chars [] = ";#";
	96
	97	/* The target specific pseudo-ops which we support. */
	98	const pseudo_typeS md_pseudo_table[] =
	99	{
	100	{ "word", cons, 4 },
	101	{ "proc", ignore_pseudo, 0 },
	102	{ "endproc", ignore_pseudo, 0 },
	103	{ NULL, NULL, 0 }
	104	};
	105
	106
	107	\f
	108	void
	109	md_begin ()
	110	{
	111	/* Initialize the `cgen' interface. */
	112
	113	/* Set the machine number and endian. */
	114	gas_cgen_cpu_desc = openrisc_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
	115	CGEN_CPU_OPEN_ENDIAN,
	116	CGEN_ENDIAN_BIG,
	117	CGEN_CPU_OPEN_END);
	118	openrisc_cgen_init_asm (gas_cgen_cpu_desc);
	119
	120	/* This is a callback from cgen to gas to parse operands. */
	121	cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
	122	}
	123
	124	void
	125	md_assemble (str)
	126	char * str;
	127	{
	128	static int last_insn_had_delay_slot = 0;
	129	openrisc_insn insn;
	130	char * errmsg;
	131
	132	/* Initialize GAS's cgen interface for a new instruction. */
	133	gas_cgen_init_parse ();
	134
	135	insn.insn = openrisc_cgen_assemble_insn
	136	(gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
	137
	138	if (!insn.insn)
	139	{
	140	as_bad (errmsg);
	141	return;
	142	}
	143
	144	/* Doesn't really matter what we pass for RELAX_P here. */
	145	gas_cgen_finish_insn (insn.insn, insn.buffer,
	146	CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
	147
	148	#if 0 /* Currently disabled */
	149	/* Warn about invalid insns in delay slots. */
	150	if (last_insn_had_delay_slot
	151	&& CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_NOT_IN_DELAY_SLOT))
152	as_warn (_("Instruction %s not allowed in a delay slot."),
153	CGEN_INSN_NAME (insn.insn));
154	#endif
155
156	last_insn_had_delay_slot
157	= CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT);
158	}
159
160
161	/* The syntax in the manual says constants begin with '#'.
162	We just ignore it. */
163
164	void
165	md_operand (expressionP)
166	expressionS * expressionP;
167	{
168	if (* input_line_pointer == '#')
169	{
170	input_line_pointer ++;
171	expression (expressionP);
172	}
173	}
174
175	valueT
176	md_section_align (segment, size)
177	segT segment;
178	valueT size;
179	{
180	int align = bfd_get_section_alignment (stdoutput, segment);
181	return ((size + (1 << align) - 1) & (-1 << align));
182	}
183
184	symbolS *
185	md_undefined_symbol (name)
186	char * name ATTRIBUTE_UNUSED;
187	{
188	return 0;
189	}
190
191	\f
192	/* Interface to relax_segment. */
193
194	/* FIXME: Look through this. */
195
196	const relax_typeS md_relax_table[] =
197	{
198	/* The fields are:
199	1) most positive reach of this state,
200	2) most negative reach of this state,
201	3) how many bytes this mode will add to the size of the current frag
202	4) which index into the table to try if we can't fit into this one. */
203
204	/* The first entry must be unused because an `rlx_more' value of zero ends
205	each list. */
206	{1, 1, 0, 0},
207
208	/* The displacement used by GAS is from the end of the 2 byte insn,
209	so we subtract 2 from the following. */
210	/* 16 bit insn, 8 bit disp -> 10 bit range.
211	This doesn't handle a branch in the right slot at the border:
212	the "& -4" isn't taken into account. It's not important enough to
213	complicate things over it, so we subtract an extra 2 (or + 2 in -ve
214	case). */
215	{511 - 2 - 2, -512 - 2 + 2, 0, 2 },
216	/* 32 bit insn, 24 bit disp -> 26 bit range. */
217	{0x2000000 - 1 - 2, -0x2000000 - 2, 2, 0 },
218	/* Same thing, but with leading nop for alignment. */
219	{0x2000000 - 1 - 2, -0x2000000 - 2, 4, 0 }
220	};
221
222	long
223	openrisc_relax_frag (segment, fragP, stretch)
224	segT segment;
225	fragS * fragP;
226	long stretch;
227	{
228	/* Address of branch insn. */
229	long address = fragP->fr_address + fragP->fr_fix - 2;
230	long growth = 0;
231
232	/* Keep 32 bit insns aligned on 32 bit boundaries. */
233	if (fragP->fr_subtype == 2)
234	{
235	if ((address & 3) != 0)
236	{
237	fragP->fr_subtype = 3;
238	growth = 2;
239	}
240	}
241	else if (fragP->fr_subtype == 3)
242	{
243	if ((address & 3) == 0)
244	{
245	fragP->fr_subtype = 2;
246	growth = -2;
247	}
248	}
249	else
250	{
251	growth = relax_frag (segment, fragP, stretch);
252
253	/* Long jump on odd halfword boundary? */
254	if (fragP->fr_subtype == 2 && (address & 3) != 0)
255	{
256	fragP->fr_subtype = 3;
257	growth += 2;
258	}
259	}
260
261	return growth;
262	}
263
264
265	/* Return an initial guess of the length by which a fragment must grow to
266	hold a branch to reach its destination.
267	Also updates fr_type/fr_subtype as necessary.
268
269	Called just before doing relaxation.
270	Any symbol that is now undefined will not become defined.
271	The guess for fr_var is ACTUALLY the growth beyond fr_fix.
272	Whatever we do to grow fr_fix or fr_var contributes to our returned value.
273	Although it may not be explicit in the frag, pretend fr_var starts with a
274	0 value. */
275
276	int
277	md_estimate_size_before_relax (fragP, segment)
278	fragS * fragP;
279	segT segment;
280	{
c7e40348 NC	281	/* The only thing we have to handle here are symbols outside of the
	282	current segment. They may be undefined or in a different segment in
	283	which case linker scripts may place them anywhere.
	284	However, we can't finish the fragment here and emit the reloc as insn
	285	alignment requirements may move the insn about. */
	286
	287	if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
	288	{
	289	/* The symbol is undefined in this segment.
	290	Change the relaxation subtype to the max allowable and leave
	291	all further handling to md_convert_frag. */
	292	fragP->fr_subtype = 2;
	293
	294	{
	295	const CGEN_INSN * insn;
	296	int i;
	297
	298	/* Update the recorded insn.
	299	Fortunately we don't have to look very far.
	300	FIXME: Change this to record in the instruction the next higher
	301	relaxable insn to use. */
	302	for (i = 0, insn = fragP->fr_cgen.insn; i < 4; i++, insn++)
	303	{
	304	if ((strcmp (CGEN_INSN_MNEMONIC (insn),
	305	CGEN_INSN_MNEMONIC (fragP->fr_cgen.insn))
	306	== 0)
	307	&& CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAX))
	308	break;
	309	}
	310	if (i == 4)
	311	abort ();
	312
	313	fragP->fr_cgen.insn = insn;
	314	return 2;
	315	}
	316	}
	317
606ab118	318	return md_relax_table[fragP->fr_subtype].rlx_length;
c7e40348 NC	319	}
	320
	321	/* *fragP has been relaxed to its final size, and now needs to have
	322	the bytes inside it modified to conform to the new size.
	323
	324	Called after relaxation is finished.
	325	fragP->fr_type == rs_machine_dependent.
	326	fragP->fr_subtype is the subtype of what the address relaxed to. */
	327
	328	void
	329	md_convert_frag (abfd, sec, fragP)
	330	bfd * abfd ATTRIBUTE_UNUSED;
	331	segT sec ATTRIBUTE_UNUSED;
	332	fragS * fragP ATTRIBUTE_UNUSED;
	333	{
	334	/* FIXME */
	335	}
	336
	337	\f
	338	/* Functions concerning relocs. */
	339
	340	/* The location from which a PC relative jump should be calculated,
	341	given a PC relative reloc. */
	342
	343	long
	344	md_pcrel_from_section (fixP, sec)
	345	fixS * fixP;
	346	segT sec;
	347	{
	348	if (fixP->fx_addsy != (symbolS *) NULL
	349	&& (! S_IS_DEFINED (fixP->fx_addsy)
	350	\|\| S_GET_SEGMENT (fixP->fx_addsy) != sec))
	351	{
	352	/* The symbol is undefined (or is defined but not in this section).
	353	Let the linker figure it out. */
	354	return 0;
	355	}
	356
	357	return (fixP->fx_frag->fr_address + fixP->fx_where) & ~1;
	358	}
	359
	360
	361	/* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
	362	Returns BFD_RELOC_NONE if no reloc type can be found.
	363	FIXP may be modified if desired. /
	364
	365	bfd_reloc_code_real_type
	366	md_cgen_lookup_reloc (insn, operand, fixP)
	367	const CGEN_INSN * insn ATTRIBUTE_UNUSED;
	368	const CGEN_OPERAND * operand;
	369	fixS * fixP;
	370	{
	371	bfd_reloc_code_real_type type;
	372
	373	switch (operand->type)
	374	{
5d6255fe KH	375	case OPENRISC_OPERAND_ABS_26:
5d6255fe KH	376	fixP->fx_pcrel = 0;
c7e40348 NC	377	type = BFD_RELOC_OPENRISC_ABS_26;
c7e40348 NC	378	goto emit;
5d6255fe KH	379	case OPENRISC_OPERAND_DISP_26:
5d6255fe KH	380	fixP->fx_pcrel = 1;
c7e40348 NC	381	type = BFD_RELOC_OPENRISC_REL_26;
	382	goto emit;
	383
	384	case OPENRISC_OPERAND_HI16:
	385	type = BFD_RELOC_HI16;
	386	goto emit;
	387
	388	case OPENRISC_OPERAND_LO16:
	389	type = BFD_RELOC_LO16;
	390	goto emit;
	391
	392	emit:
	393	return type;
	394
	395	default : /* avoid -Wall warning */
	396	break;
	397	}
	398
	399	return BFD_RELOC_NONE;
	400	}
c7e40348 NC	401	\f
	402	/* Write a value out to the object file, using the appropriate endianness. */
	403
	404	void
	405	md_number_to_chars (buf, val, n)
	406	char * buf;
	407	valueT val;
	408	int n;
	409	{
	410	number_to_chars_bigendian (buf, val, n);
	411	}
	412
	413	/* Turn a string in input_line_pointer into a floating point constant of type
	414	type, and store the appropriate bytes in *litP. The number of LITTLENUMS
	415	emitted is stored in *sizeP . An error message is returned, or NULL on OK.
	416	*/
	417
	418	/* Equal to MAX_PRECISION in atof-ieee.c */
	419	#define MAX_LITTLENUMS 6
	420
	421	char *
	422	md_atof (type, litP, sizeP)
	423	char type;
	424	char * litP;
	425	int * sizeP;
	426	{
	427	int i;
	428	int prec;
	429	LITTLENUM_TYPE words [MAX_LITTLENUMS];
	430	char * t;
c7e40348 NC	431
	432	switch (type)
	433	{
	434	case 'f':
	435	case 'F':
	436	case 's':
	437	case 'S':
	438	prec = 2;
	439	break;
	440
	441	case 'd':
	442	case 'D':
	443	case 'r':
	444	case 'R':
	445	prec = 4;
	446	break;
	447
	448	/* FIXME: Some targets allow other format chars for bigger sizes here. */
	449
	450	default:
	451	* sizeP = 0;
	452	return _("Bad call to md_atof()");
	453	}
	454
	455	t = atof_ieee (input_line_pointer, type, words);
	456	if (t)
	457	input_line_pointer = t;
	458	* sizeP = prec * sizeof (LITTLENUM_TYPE);
	459
	460	for (i = 0; i < prec; i++)
	461	{
	462	md_number_to_chars (litP, (valueT) words[i],
	463	sizeof (LITTLENUM_TYPE));
	464	litP += sizeof (LITTLENUM_TYPE);
	465	}
	466
	467	return 0;
	468	}
	469
b34976b6	470	bfd_boolean
c7e40348 NC	471	openrisc_fix_adjustable (fixP)
	472	fixS * fixP;
	473	{
c7e40348 NC	474	/* We need the symbol name for the VTABLE entries */
	475	if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
	476	\|\| fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5d6255fe	477	return 0;
c7e40348 NC	478
	479	return 1;
	480	}
	481
	482
	483