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

/* tc-pj.c -- Assemble code for Pico Java
   Copyright (C) 1999-2016 Free Software Foundation, Inc.

   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 3, 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.  */

/* Contributed by Steve Chamberlain of Transmeta <sac@pobox.com>.  */

#include "as.h"
#include "safe-ctype.h"
#include "opcode/pj.h"

extern const pj_opc_info_t pj_opc_info[512];

const char comment_chars[]        = "!/";
const char line_separator_chars[] = ";";
const char line_comment_chars[]   = "/!#";

static int pending_reloc;
static struct hash_control *opcode_hash_control;

static void
little (int ignore ATTRIBUTE_UNUSED)
{
  target_big_endian = 0;
}

static void
big (int ignore ATTRIBUTE_UNUSED)
{
  target_big_endian = 1;
}

const pseudo_typeS md_pseudo_table[] =
{
  {"ml",    little, 0},
  {"mb",    big,    0},
  {0, 0, 0}
};

const char FLT_CHARS[] = "rRsSfFdDxXpP";
const char EXP_CHARS[] = "eE";

void
md_operand (expressionS *op)
{
  if (strncmp (input_line_pointer, "%hi16", 5) == 0)
    {
      if (pending_reloc)
	as_bad (_("confusing relocation expressions"));
      pending_reloc = BFD_RELOC_PJ_CODE_HI16;
      input_line_pointer += 5;
      expression (op);
    }

  if (strncmp (input_line_pointer, "%lo16", 5) == 0)
    {
      if (pending_reloc)
	as_bad (_("confusing relocation expressions"));
      pending_reloc = BFD_RELOC_PJ_CODE_LO16;
      input_line_pointer += 5;
      expression (op);
    }
}

/* Parse an expression and then restore the input line pointer.  */

static char *
parse_exp_save_ilp (char *s, expressionS *op)
{
  char *save = input_line_pointer;

  input_line_pointer = s;
  expression (op);
  s = input_line_pointer;
  input_line_pointer = save;
  return s;
}

/* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
   reloc for a cons.  We could use the definition there, except that
   we want to handle magic pending reloc expressions specially.  */

void
pj_cons_fix_new_pj (fragS *frag, int where, int nbytes, expressionS *exp,
		    bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)
{
  static int rv[5][2] =
  { { 0, 0 },
    { BFD_RELOC_8, BFD_RELOC_8 },
    { BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 },
    { 0, 0 },
    { BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }};

  fix_new_exp (frag, where, nbytes, exp, 0,
	       pending_reloc ? pending_reloc
	       : rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]);

  pending_reloc = 0;
}

/* Turn a reloc description character from the pj-opc.h table into
   code which BFD can handle.  */

static int
c_to_r (int x)
{
  switch (x)
    {
    case O_R8:
      return BFD_RELOC_8_PCREL;
    case O_U8:
    case O_8:
      return BFD_RELOC_8;
    case O_R16:
      return BFD_RELOC_PJ_CODE_REL16;
    case O_U16:
    case O_16:
      return BFD_RELOC_PJ_CODE_DIR16;
    case O_R32:
      return BFD_RELOC_PJ_CODE_REL32;
    case O_32:
      return BFD_RELOC_PJ_CODE_DIR32;
    }
  abort ();
  return 0;
}

/* Handler for the ipush fake opcode,
   turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>.  */

static void
ipush_code (pj_opc_info_t *opcode ATTRIBUTE_UNUSED, char *str)
{
  char *b = frag_more (6);
  expressionS arg;

  b[0] = 0x11;
  b[3] = 0xed;
  parse_exp_save_ilp (str + 1, &arg);
  if (pending_reloc)
    {
      as_bad (_("can't have relocation for ipush"));
      pending_reloc = 0;
    }

  fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2,
	       &arg, 0, BFD_RELOC_PJ_CODE_DIR16);
  fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2,
	       &arg, 0, BFD_RELOC_PJ_CODE_HI16);
}

/* Insert names into the opcode table which are really mini macros,
   not opcodes.  The fakeness is indicated with an opcode of -1.  */

static void
fake_opcode (const char *name,
	     void (*func) (struct pj_opc_info_t *, char *))
{
  pj_opc_info_t * fake = XNEW (pj_opc_info_t);

  fake->opcode = -1;
  fake->opcode_next = -1;
  fake->u.func = func;
  hash_insert (opcode_hash_control, name, (char *) fake);
}

/* Enter another entry into the opcode hash table so the same opcode
   can have another name.  */

static void
alias (const char *new_name, const char *old)
{
  hash_insert (opcode_hash_control, new_name,
	       (char *) hash_find (opcode_hash_control, old));
}

/* This function is called once, at assembler startup time.  It sets
   up the hash table with all the opcodes in it, and also initializes
   some aliases for compatibility with other assemblers.  */

void
md_begin (void)
{
  const pj_opc_info_t *opcode;
  opcode_hash_control = hash_new ();

  /* Insert names into hash table.  */
  for (opcode = pj_opc_info; opcode->u.name; opcode++)
    hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode);

  /* Insert the only fake opcode.  */
  fake_opcode ("ipush", ipush_code);

  /* Add some aliases for opcode names.  */
  alias ("ifeq_s", "ifeq");
  alias ("ifne_s", "ifne");
  alias ("if_icmpge_s", "if_icmpge");
  alias ("if_icmpne_s", "if_icmpne");
  alias ("if_icmpeq_s", "if_icmpeq");
  alias ("if_icmpgt_s", "if_icmpgt");
  alias ("goto_s", "goto");

  bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
}

/* This is the guts of the machine-dependent assembler.  STR points to
   a machine dependent instruction.  This function is supposed to emit
   the frags/bytes it assembles to.  */

void
md_assemble (char *str)
{
  char *op_start;
  char *op_end;

  pj_opc_info_t *opcode;
  char *output;
  int idx = 0;
  char pend;

  int nlen = 0;

  /* Drop leading whitespace.  */
  while (*str == ' ')
    str++;

  /* Find the op code end.  */
  op_start = str;
  for (op_end = str;
       *op_end && !is_end_of_line[*op_end & 0xff] && *op_end != ' ';
       op_end++)
    nlen++;

  pend = *op_end;
  *op_end = 0;

  if (nlen == 0)
    as_bad (_("can't find opcode "));

  opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start);
  *op_end = pend;

  if (opcode == NULL)
    {
      as_bad (_("unknown opcode %s"), op_start);
      return;
    }

  dwarf2_emit_insn (0);
  if (opcode->opcode == -1)
    {
      /* It's a fake opcode.  Dig out the args and pretend that was
         what we were passed.  */
      (*opcode->u.func) (opcode, op_end);
    }
  else
    {
      int an;

      output = frag_more (opcode->len);
      output[idx++] = opcode->opcode;

      if (opcode->opcode_next != -1)
	output[idx++] = opcode->opcode_next;

      for (an = 0; opcode->arg[an]; an++)
	{
	  expressionS arg;

	  if (*op_end == ',' && an != 0)
	    op_end++;

	  if (*op_end == 0)
	    as_bad (_("expected expression"));

	  op_end = parse_exp_save_ilp (op_end, &arg);

	  fix_new_exp (frag_now,
		       output - frag_now->fr_literal + idx,
		       ASIZE (opcode->arg[an]),
		       &arg,
		       PCREL (opcode->arg[an]),
		       pending_reloc ? pending_reloc : c_to_r (opcode->arg[an]));

	  idx += ASIZE (opcode->arg[an]);
	  pending_reloc = 0;
	}

      while (ISSPACE (*op_end))
	op_end++;

      if (*op_end != 0)
	as_warn (_("extra stuff on line ignored"));

    }

  if (pending_reloc)
    as_bad (_("Something forgot to clean up\n"));
}

const char *
md_atof (int type, char *litP, int *sizeP)
{
  return ieee_md_atof (type, litP, sizeP, target_big_endian);
}
\f
const char *md_shortopts = "";

struct option md_longopts[] =
{
#define OPTION_LITTLE (OPTION_MD_BASE)
#define OPTION_BIG    (OPTION_LITTLE + 1)

  {"little", no_argument, NULL, OPTION_LITTLE},
  {"big", no_argument, NULL, OPTION_BIG},
  {NULL, no_argument, NULL, 0}
};
size_t md_longopts_size = sizeof (md_longopts);

int
md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
{
  switch (c)
    {
    case OPTION_LITTLE:
      little (0);
      break;
    case OPTION_BIG:
      big (0);
      break;
    default:
      return 0;
    }
  return 1;
}

void
md_show_usage (FILE *stream)
{
  fprintf (stream, _("\
PJ options:\n\
-little			generate little endian code\n\
-big			generate big endian code\n"));
}

/* Apply a fixup to the object file.  */

void
md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
{
  char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  long val = *valP;
  long max, min;

  max = min = 0;
  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_VTABLE_INHERIT:
    case BFD_RELOC_VTABLE_ENTRY:
      fixP->fx_done = 0;
      return;

    case BFD_RELOC_PJ_CODE_REL16:
      if (val < -0x8000 || val >= 0x7fff)
	as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far"));
      buf[0] |= (val >> 8) & 0xff;
      buf[1] = val & 0xff;
      break;

    case BFD_RELOC_PJ_CODE_HI16:
      *buf++ = val >> 24;
      *buf++ = val >> 16;
      fixP->fx_addnumber = val & 0xffff;
      break;

    case BFD_RELOC_PJ_CODE_DIR16:
    case BFD_RELOC_PJ_CODE_LO16:
      *buf++ = val >> 8;
      *buf++ = val >> 0;

      max = 0xffff;
      min = -0xffff;
      break;

    case BFD_RELOC_8:
      max = 0xff;
      min = -0xff;
      *buf++ = val;
      break;

    case BFD_RELOC_PJ_CODE_DIR32:
      *buf++ = val >> 24;
      *buf++ = val >> 16;
      *buf++ = val >> 8;
      *buf++ = val >> 0;
      break;

    case BFD_RELOC_32:
      if (target_big_endian)
	{
	  *buf++ = val >> 24;
	  *buf++ = val >> 16;
	  *buf++ = val >> 8;
	  *buf++ = val >> 0;
	}
      else
	{
	  *buf++ = val >> 0;
	  *buf++ = val >> 8;
	  *buf++ = val >> 16;
	  *buf++ = val >> 24;
	}
      break;

    case BFD_RELOC_16:
      if (target_big_endian)
	{
	  *buf++ = val >> 8;
	  *buf++ = val >> 0;
	}
      else
	{
	  *buf++ = val >> 0;
	  *buf++ = val >> 8;
	}
      break;

    case BFD_RELOC_PJ_CODE_REL32:
      fixP->fx_done = 0;
      return;

    default:
      abort ();
    }

  if (max != 0 && (val < min || val > max))
    as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));

  if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
    fixP->fx_done = 1;
}

/* Put number into target byte order.  Always put values in an
   executable section into big endian order.  */

void
md_number_to_chars (char *ptr, valueT use, int nbytes)
{
  if (target_big_endian || now_seg->flags & SEC_CODE)
    number_to_chars_bigendian (ptr, use, nbytes);
  else
    number_to_chars_littleendian (ptr, use, nbytes);
}

/* Translate internal representation of relocation info to BFD target
   format.  */

arelent *
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
{
  arelent *rel;
  bfd_reloc_code_real_type r_type;

  rel = XNEW (arelent);
  rel->sym_ptr_ptr = XNEW (asymbol *);
  *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
  rel->address = fixp->fx_frag->fr_address + fixp->fx_where;

  r_type = fixp->fx_r_type;
  rel->addend = fixp->fx_addnumber;
  rel->howto = bfd_reloc_type_lookup (stdoutput, r_type);

  if (rel->howto == NULL)
    {
      as_bad_where (fixp->fx_file, fixp->fx_line,
		    _("Cannot represent relocation type %s"),
		    bfd_get_reloc_code_name (r_type));
      /* Set howto to a garbage value so that we can keep going.  */
      rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
      gas_assert (rel->howto != NULL);
    }

  return rel;
}
Commit	Line	Data
	1	/* tc-pj.c -- Assemble code for Pico Java
	2	Copyright (C) 1999-2016 Free Software Foundation, Inc.
	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 3, 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, 51 Franklin Street - Fifth Floor,
	19	Boston, MA 02110-1301, USA. */
	20
	21	/* Contributed by Steve Chamberlain of Transmeta <sac@pobox.com>. */
	22
	23	#include "as.h"
	24	#include "safe-ctype.h"
	25	#include "opcode/pj.h"
	26
	27	extern const pj_opc_info_t pj_opc_info[512];
	28
	29	const char comment_chars[] = "!/";
	30	const char line_separator_chars[] = ";";
	31	const char line_comment_chars[] = "/!#";
	32
	33	static int pending_reloc;
	34	static struct hash_control *opcode_hash_control;
	35
	36	static void
	37	little (int ignore ATTRIBUTE_UNUSED)
	38	{
	39	target_big_endian = 0;
	40	}
	41
	42	static void
	43	big (int ignore ATTRIBUTE_UNUSED)
	44	{
	45	target_big_endian = 1;
	46	}
	47
	48	const pseudo_typeS md_pseudo_table[] =
	49	{
	50	{"ml", little, 0},
	51	{"mb", big, 0},
	52	{0, 0, 0}
	53	};
	54
	55	const char FLT_CHARS[] = "rRsSfFdDxXpP";
	56	const char EXP_CHARS[] = "eE";
	57
	58	void
	59	md_operand (expressionS *op)
	60	{
	61	if (strncmp (input_line_pointer, "%hi16", 5) == 0)
	62	{
	63	if (pending_reloc)
	64	as_bad (_("confusing relocation expressions"));
	65	pending_reloc = BFD_RELOC_PJ_CODE_HI16;
	66	input_line_pointer += 5;
	67	expression (op);
	68	}
	69
	70	if (strncmp (input_line_pointer, "%lo16", 5) == 0)
	71	{
	72	if (pending_reloc)
	73	as_bad (_("confusing relocation expressions"));
	74	pending_reloc = BFD_RELOC_PJ_CODE_LO16;
	75	input_line_pointer += 5;
	76	expression (op);
	77	}
	78	}
	79
	80	/* Parse an expression and then restore the input line pointer. */
	81
	82	static char *
	83	parse_exp_save_ilp (char s, expressionS op)
	84	{
	85	char *save = input_line_pointer;
	86
	87	input_line_pointer = s;
	88	expression (op);
	89	s = input_line_pointer;
	90	input_line_pointer = save;
	91	return s;
	92	}
	93
	94	/* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
	95	reloc for a cons. We could use the definition there, except that
	96	we want to handle magic pending reloc expressions specially. */
	97
	98	void
	99	pj_cons_fix_new_pj (fragS frag, int where, int nbytes, expressionS exp,
	100	bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)
	101	{
	102	static int rv[5][2] =
	103	{ { 0, 0 },
	104	{ BFD_RELOC_8, BFD_RELOC_8 },
	105	{ BFD_RELOC_PJ_CODE_DIR16, BFD_RELOC_16 },
	106	{ 0, 0 },
	107	{ BFD_RELOC_PJ_CODE_DIR32, BFD_RELOC_32 }};
	108
	109	fix_new_exp (frag, where, nbytes, exp, 0,
	110	pending_reloc ? pending_reloc
	111	: rv[nbytes][(now_seg->flags & SEC_CODE) ? 0 : 1]);
	112
	113	pending_reloc = 0;
	114	}
	115
	116	/* Turn a reloc description character from the pj-opc.h table into
	117	code which BFD can handle. */
	118
	119	static int
	120	c_to_r (int x)
	121	{
	122	switch (x)
	123	{
	124	case O_R8:
	125	return BFD_RELOC_8_PCREL;
	126	case O_U8:
	127	case O_8:
	128	return BFD_RELOC_8;
	129	case O_R16:
	130	return BFD_RELOC_PJ_CODE_REL16;
	131	case O_U16:
	132	case O_16:
	133	return BFD_RELOC_PJ_CODE_DIR16;
	134	case O_R32:
	135	return BFD_RELOC_PJ_CODE_REL32;
	136	case O_32:
	137	return BFD_RELOC_PJ_CODE_DIR32;
	138	}
	139	abort ();
	140	return 0;
	141	}
	142
	143	/* Handler for the ipush fake opcode,
	144	turns ipush <foo> into sipush lo16<foo>, sethi hi16<foo>. */
	145
	146	static void
	147	ipush_code (pj_opc_info_t opcode ATTRIBUTE_UNUSED, char str)
	148	{
	149	char *b = frag_more (6);
	150	expressionS arg;
	151
	152	b[0] = 0x11;
	153	b[3] = 0xed;
	154	parse_exp_save_ilp (str + 1, &arg);
	155	if (pending_reloc)
	156	{
	157	as_bad (_("can't have relocation for ipush"));
	158	pending_reloc = 0;
	159	}
	160
	161	fix_new_exp (frag_now, b - frag_now->fr_literal + 1, 2,
	162	&arg, 0, BFD_RELOC_PJ_CODE_DIR16);
	163	fix_new_exp (frag_now, b - frag_now->fr_literal + 4, 2,
	164	&arg, 0, BFD_RELOC_PJ_CODE_HI16);
	165	}
	166
	167	/* Insert names into the opcode table which are really mini macros,
	168	not opcodes. The fakeness is indicated with an opcode of -1. */
	169
	170	static void
	171	fake_opcode (const char *name,
	172	void (func) (struct pj_opc_info_t , char *))
	173	{
	174	pj_opc_info_t * fake = XNEW (pj_opc_info_t);
	175
	176	fake->opcode = -1;
	177	fake->opcode_next = -1;
	178	fake->u.func = func;
	179	hash_insert (opcode_hash_control, name, (char *) fake);
	180	}
	181
	182	/* Enter another entry into the opcode hash table so the same opcode
	183	can have another name. */
	184
	185	static void
	186	alias (const char new_name, const char old)
	187	{
	188	hash_insert (opcode_hash_control, new_name,
	189	(char *) hash_find (opcode_hash_control, old));
	190	}
	191
	192	/* This function is called once, at assembler startup time. It sets
	193	up the hash table with all the opcodes in it, and also initializes
	194	some aliases for compatibility with other assemblers. */
	195
	196	void
	197	md_begin (void)
	198	{
	199	const pj_opc_info_t *opcode;
	200	opcode_hash_control = hash_new ();
	201
	202	/* Insert names into hash table. */
	203	for (opcode = pj_opc_info; opcode->u.name; opcode++)
	204	hash_insert (opcode_hash_control, opcode->u.name, (char *) opcode);
	205
	206	/* Insert the only fake opcode. */
	207	fake_opcode ("ipush", ipush_code);
	208
	209	/* Add some aliases for opcode names. */
	210	alias ("ifeq_s", "ifeq");
	211	alias ("ifne_s", "ifne");
	212	alias ("if_icmpge_s", "if_icmpge");
	213	alias ("if_icmpne_s", "if_icmpne");
	214	alias ("if_icmpeq_s", "if_icmpeq");
	215	alias ("if_icmpgt_s", "if_icmpgt");
	216	alias ("goto_s", "goto");
	217
	218	bfd_set_arch_mach (stdoutput, TARGET_ARCH, 0);
	219	}
	220
	221	/* This is the guts of the machine-dependent assembler. STR points to
	222	a machine dependent instruction. This function is supposed to emit
	223	the frags/bytes it assembles to. */
	224
	225	void
	226	md_assemble (char *str)
	227	{
	228	char *op_start;
	229	char *op_end;
	230
	231	pj_opc_info_t *opcode;
	232	char *output;
	233	int idx = 0;
	234	char pend;
	235
	236	int nlen = 0;
	237
	238	/* Drop leading whitespace. */
	239	while (*str == ' ')
	240	str++;
	241
	242	/* Find the op code end. */
	243	op_start = str;
	244	for (op_end = str;
	245	op_end && !is_end_of_line[op_end & 0xff] && *op_end != ' ';
	246	op_end++)
	247	nlen++;
	248
	249	pend = *op_end;
	250	*op_end = 0;
	251
	252	if (nlen == 0)
	253	as_bad (_("can't find opcode "));
	254
	255	opcode = (pj_opc_info_t *) hash_find (opcode_hash_control, op_start);
	256	*op_end = pend;
	257
	258	if (opcode == NULL)
	259	{
	260	as_bad (_("unknown opcode %s"), op_start);
	261	return;
	262	}
	263
	264	dwarf2_emit_insn (0);
	265	if (opcode->opcode == -1)
	266	{
	267	/* It's a fake opcode. Dig out the args and pretend that was
	268	what we were passed. */
	269	(*opcode->u.func) (opcode, op_end);
	270	}
	271	else
	272	{
	273	int an;
	274
	275	output = frag_more (opcode->len);
	276	output[idx++] = opcode->opcode;
	277
	278	if (opcode->opcode_next != -1)
	279	output[idx++] = opcode->opcode_next;
	280
	281	for (an = 0; opcode->arg[an]; an++)
	282	{
	283	expressionS arg;
	284
	285	if (*op_end == ',' && an != 0)
	286	op_end++;
	287
	288	if (*op_end == 0)
	289	as_bad (_("expected expression"));
	290
	291	op_end = parse_exp_save_ilp (op_end, &arg);
	292
	293	fix_new_exp (frag_now,
	294	output - frag_now->fr_literal + idx,
	295	ASIZE (opcode->arg[an]),
	296	&arg,
	297	PCREL (opcode->arg[an]),
	298	pending_reloc ? pending_reloc : c_to_r (opcode->arg[an]));
	299
	300	idx += ASIZE (opcode->arg[an]);
	301	pending_reloc = 0;
	302	}
	303
	304	while (ISSPACE (*op_end))
	305	op_end++;
	306
	307	if (*op_end != 0)
	308	as_warn (_("extra stuff on line ignored"));
	309
	310	}
	311
	312	if (pending_reloc)
	313	as_bad (_("Something forgot to clean up\n"));
	314	}
	315
	316	const char *
	317	md_atof (int type, char litP, int sizeP)
	318	{
	319	return ieee_md_atof (type, litP, sizeP, target_big_endian);
	320	}
	321	\f
	322	const char *md_shortopts = "";
	323
	324	struct option md_longopts[] =
	325	{
	326	#define OPTION_LITTLE (OPTION_MD_BASE)
	327	#define OPTION_BIG (OPTION_LITTLE + 1)
	328
	329	{"little", no_argument, NULL, OPTION_LITTLE},
	330	{"big", no_argument, NULL, OPTION_BIG},
	331	{NULL, no_argument, NULL, 0}
	332	};
	333	size_t md_longopts_size = sizeof (md_longopts);
	334
	335	int
	336	md_parse_option (int c, const char *arg ATTRIBUTE_UNUSED)
	337	{
	338	switch (c)
	339	{
	340	case OPTION_LITTLE:
	341	little (0);
	342	break;
	343	case OPTION_BIG:
	344	big (0);
	345	break;
	346	default:
	347	return 0;
	348	}
	349	return 1;
	350	}
	351
	352	void
	353	md_show_usage (FILE *stream)
	354	{
	355	fprintf (stream, _("\
	356	PJ options:\n\
	357	-little generate little endian code\n\
	358	-big generate big endian code\n"));
	359	}
	360
	361	/* Apply a fixup to the object file. */
	362
	363	void
	364	md_apply_fix (fixS fixP, valueT valP, segT seg ATTRIBUTE_UNUSED)
	365	{
	366	char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
	367	long val = *valP;
	368	long max, min;
	369
	370	max = min = 0;
	371	switch (fixP->fx_r_type)
	372	{
	373	case BFD_RELOC_VTABLE_INHERIT:
	374	case BFD_RELOC_VTABLE_ENTRY:
	375	fixP->fx_done = 0;
	376	return;
	377
	378	case BFD_RELOC_PJ_CODE_REL16:
	379	if (val < -0x8000 \|\| val >= 0x7fff)
	380	as_bad_where (fixP->fx_file, fixP->fx_line, _("pcrel too far"));
	381	buf[0] \|= (val >> 8) & 0xff;
	382	buf[1] = val & 0xff;
	383	break;
	384
	385	case BFD_RELOC_PJ_CODE_HI16:
	386	*buf++ = val >> 24;
	387	*buf++ = val >> 16;
	388	fixP->fx_addnumber = val & 0xffff;
	389	break;
	390
	391	case BFD_RELOC_PJ_CODE_DIR16:
	392	case BFD_RELOC_PJ_CODE_LO16:
	393	*buf++ = val >> 8;
	394	*buf++ = val >> 0;
	395
	396	max = 0xffff;
	397	min = -0xffff;
	398	break;
	399
	400	case BFD_RELOC_8:
	401	max = 0xff;
	402	min = -0xff;
	403	*buf++ = val;
	404	break;
	405
	406	case BFD_RELOC_PJ_CODE_DIR32:
	407	*buf++ = val >> 24;
	408	*buf++ = val >> 16;
	409	*buf++ = val >> 8;
	410	*buf++ = val >> 0;
	411	break;
	412
	413	case BFD_RELOC_32:
	414	if (target_big_endian)
	415	{
	416	*buf++ = val >> 24;
	417	*buf++ = val >> 16;
	418	*buf++ = val >> 8;
	419	*buf++ = val >> 0;
	420	}
	421	else
	422	{
	423	*buf++ = val >> 0;
	424	*buf++ = val >> 8;
	425	*buf++ = val >> 16;
	426	*buf++ = val >> 24;
	427	}
	428	break;
	429
	430	case BFD_RELOC_16:
	431	if (target_big_endian)
	432	{
	433	*buf++ = val >> 8;
	434	*buf++ = val >> 0;
	435	}
	436	else
	437	{
	438	*buf++ = val >> 0;
	439	*buf++ = val >> 8;
	440	}
	441	break;
	442
	443	case BFD_RELOC_PJ_CODE_REL32:
	444	fixP->fx_done = 0;
	445	return;
	446
	447	default:
	448	abort ();
	449	}
	450
	451	if (max != 0 && (val < min \|\| val > max))
	452	as_bad_where (fixP->fx_file, fixP->fx_line, _("offset out of range"));
	453
	454	if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
	455	fixP->fx_done = 1;
	456	}
	457
	458	/* Put number into target byte order. Always put values in an
	459	executable section into big endian order. */
	460
	461	void
	462	md_number_to_chars (char *ptr, valueT use, int nbytes)
	463	{
	464	if (target_big_endian \|\| now_seg->flags & SEC_CODE)
	465	number_to_chars_bigendian (ptr, use, nbytes);
	466	else
	467	number_to_chars_littleendian (ptr, use, nbytes);
	468	}
	469
	470	/* Translate internal representation of relocation info to BFD target
	471	format. */
	472
	473	arelent *
	474	tc_gen_reloc (asection section ATTRIBUTE_UNUSED, fixS fixp)
	475	{
	476	arelent *rel;
	477	bfd_reloc_code_real_type r_type;
	478
	479	rel = XNEW (arelent);
	480	rel->sym_ptr_ptr = XNEW (asymbol *);
	481	*rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
	482	rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
	483
	484	r_type = fixp->fx_r_type;
	485	rel->addend = fixp->fx_addnumber;
	486	rel->howto = bfd_reloc_type_lookup (stdoutput, r_type);
	487
	488	if (rel->howto == NULL)
	489	{
	490	as_bad_where (fixp->fx_file, fixp->fx_line,
	491	_("Cannot represent relocation type %s"),
	492	bfd_get_reloc_code_name (r_type));
	493	/* Set howto to a garbage value so that we can keep going. */
	494	rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
	495	gas_assert (rel->howto != NULL);
	496	}
	497
	498	return rel;
	499	}