xref: /openbsd/gnu/usr.bin/binutils/gas/config/tc-pdp11.c (revision d2201f2f)

/* tc-pdp11.c - pdp11-specific -
   Copyright 2001, 2002 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 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.  */

/*
  Apparently unused functions:
    md_convert_frag
    md_estimate_size_before_relax
    md_create_short_jump
    md_create_long_jump
*/

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

static int set_option PARAMS ((char *arg));
static int set_cpu_model PARAMS ((char *arg));
static int set_machine_model PARAMS ((char *arg));

extern int flonum_gen2vax PARAMS ((char format_letter, FLONUM_TYPE * f,
                                   LITTLENUM_TYPE * words));

#define TRUE 1
#define FALSE 0

/*
 * A representation for PDP-11 machine code.
 */
struct pdp11_code
{
  char *error;
  int code;
  int additional;	/* is there an additional word? */
  int word;		/* additional word, if any */
  struct
  {
    bfd_reloc_code_real_type type;
    expressionS exp;
    int pc_rel;
  } reloc;
};

/*
 * Instruction set extensions.
 *
 * If you change this from an array to something else, please update
 * the "PDP-11 instruction set extensions" comment in pdp11.h.
 */
int pdp11_extension[PDP11_EXT_NUM];

/*
 * Assembly options.
 */

#define ASM_OPT_PIC 1
#define ASM_OPT_NUM 2

int asm_option[ASM_OPT_NUM];

/* These chars start a comment anywhere in a source file (except inside
   another comment */
const char comment_chars[] = "#/";

/* These chars only start a comment at the beginning of a line.  */
const char line_comment_chars[] = "#/";

const char line_separator_chars[] = ";";

/* Chars that can be used to separate mant from exp in floating point nums */
const char EXP_CHARS[] = "eE";

/* Chars that mean this number is a floating point constant */
/* as in 0f123.456 */
/* or    0H1.234E-12 (see exp chars above) */
const char FLT_CHARS[] = "dDfF";

void pseudo_even (int);
void pseudo_bss (int);

const pseudo_typeS md_pseudo_table[] =
{
  { "bss", pseudo_bss, 0 },
  { "even", pseudo_even, 0 },
  { 0, 0, 0 },
};

static void
init_defaults ()
{
  static int first = 1;

  if (first)
    {
      set_option ("all-extensions");
      set_option ("pic");
      first = 0;
    }
}

static struct hash_control *insn_hash = NULL;

void
md_begin ()
{
  int i;

  init_defaults ();

  insn_hash = hash_new ();
  if (insn_hash == NULL)
    as_fatal ("Virtual memory exhausted");

  for (i = 0; i < pdp11_num_opcodes; i++)
    hash_insert (insn_hash, pdp11_opcodes[i].name, (PTR)(pdp11_opcodes + i));
  for (i = 0; i < pdp11_num_aliases; i++)
    hash_insert (insn_hash, pdp11_aliases[i].name, (PTR)(pdp11_aliases + i));
}

void
md_number_to_chars (con, value, nbytes)
     char con[];
     valueT value;
     int nbytes;
{
  /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
   * 0x12345678 is stored as "\x56\x78\x12\x34". It's
   * anyones guess what 0x123456 would be stored like.
   */

  switch (nbytes)
    {
    case 0:
      break;
    case 1:
      con[0] =  value       & 0xff;
      break;
    case 2:
      con[0] =  value       & 0xff;
      con[1] = (value >>  8) & 0xff;
      break;
    case 4:
      con[0] = (value >> 16) & 0xff;
      con[1] = (value >> 24) & 0xff;
      con[2] =  value       & 0xff;
      con[3] = (value >>  8) & 0xff;
      break;
    default:
      BAD_CASE (nbytes);
    }
}

/* Fix up some data or instructions after we find out the value of a symbol
   that they reference.  Knows about order of bytes in address.  */

void
md_apply_fix3 (fixP, valP, seg)
     fixS *fixP;
     valueT * valP;
     segT seg ATTRIBUTE_UNUSED;
{
  valueT code;
  valueT mask;
  valueT val = * valP;
  char *buf;
  int shift;
  int size;

  buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  size = fixP->fx_size;
  code = md_chars_to_number (buf, size);

  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_16:
    case BFD_RELOC_16_PCREL:
      mask = 0xffff;
      shift = 0;
      break;
    case BFD_RELOC_PDP11_DISP_8_PCREL:
      mask = 0x00ff;
      shift = 1;
      break;
    case BFD_RELOC_PDP11_DISP_6_PCREL:
      mask = 0x003f;
      shift = 1;
      break;
    default:
      BAD_CASE (fixP->fx_r_type);
    }

  if (fixP->fx_addsy != NULL)
    val += symbol_get_bfdsym (fixP->fx_addsy)->section->vma;
    /* *value += fixP->fx_addsy->bsym->section->vma; */

  code &= ~mask;
  code |= (val >> shift) & mask;
  number_to_chars_littleendian (buf, code, size);

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

long
md_chars_to_number (con, nbytes)
     unsigned char con[];	/* Low order byte 1st.  */
     int nbytes;		/* Number of bytes in the input.  */
{
  /* On a PDP-11, 0x1234 is stored as "\x12\x34", and
   * 0x12345678 is stored as "\x56\x78\x12\x34". It's
   * anyones guess what 0x123456 would be stored like.
   */

  switch (nbytes)
    {
    case 0:
      return 0;
    case 1:
      return con[0];
    case 2:
      return (con[1] << BITS_PER_CHAR) | con[0];
    case 4:
      return
	(((con[1] << BITS_PER_CHAR) | con[0]) << (2 * BITS_PER_CHAR)) |
	 ((con[3] << BITS_PER_CHAR) | con[2]);
    default:
      BAD_CASE (nbytes);
      return 0;
    }
}

static char *
skip_whitespace (char *str)
{
  while (*str == ' ' || *str == '\t')
    str++;
  return str;
}

static char *
find_whitespace (char *str)
{
  while (*str != ' ' && *str != '\t' && *str != 0)
    str++;
  return str;
}

static char *
parse_reg (char *str, struct pdp11_code *operand)
{
  str = skip_whitespace (str);
  if (TOLOWER (*str) == 'r')
    {
      str++;
      switch (*str)
	{
	case '0': case '1': case '2': case '3':
	case '4': case '5': case '6': case '7':
	  operand->code = *str - '0';
	  str++;
	  break;
	default:
	  operand->error = "Bad register name";
	  return str - 1;
	}
    }
  else if (strncmp (str, "sp", 2) == 0 ||
	   strncmp (str, "SP", 2) == 0)
    {
      operand->code = 6;
      str += 2;
    }
  else if (strncmp (str, "pc", 2) == 0 ||
	   strncmp (str, "PC", 2) == 0)
    {
      operand->code = 7;
      str += 2;
    }
  else
    {
      operand->error = "Bad register name";
      return str;
    }

  return str;
}

static char *
parse_ac5 (char *str, struct pdp11_code *operand)
{
  str = skip_whitespace (str);
  if (strncmp (str, "fr", 2) == 0 ||
      strncmp (str, "FR", 2) == 0 ||
      strncmp (str, "ac", 2) == 0 ||
      strncmp (str, "AC", 2) == 0)
    {
      str += 2;
      switch (*str)
	{
	case '0': case '1': case '2': case '3':
        case '4': case '5':
	  operand->code = *str - '0';
	  str++;
	  break;
	default:
	  operand->error = "Bad register name";
	  return str - 2;
	}
    }
  else
    {
      operand->error = "Bad register name";
      return str;
    }

  return str;
}

static char *
parse_ac (char *str, struct pdp11_code *operand)
{
  str = parse_ac5 (str, operand);
  if (!operand->error && operand->code > 3)
    {
	  operand->error = "Bad register name";
	  return str - 3;
    }

  return str;
}

static char *
parse_expression (char *str, struct pdp11_code *operand)
{
  char *save_input_line_pointer;
  segT seg;

  save_input_line_pointer = input_line_pointer;
  input_line_pointer = str;
  seg = expression (&operand->reloc.exp);
  if (seg == NULL)
    {
      input_line_pointer = save_input_line_pointer;
      operand->error = "Error in expression";
      return str;
    }

  str = input_line_pointer;
  input_line_pointer = save_input_line_pointer;

  operand->reloc.pc_rel = 0;

#if 0
  /* FIXME: what follows is broken badly.  You can't deal with differences
     in radix conventions this way, because of symbolic constants, constant
     expressions made up of pieces of differing radix, etc.  The only
     choices are to change ../expr.c to know about pdp11 conventions, or
     to accept the fact that gas will use consistent conventions that differ
     from those of traditional pdp11 assemblers.  For now, I've
     chosen the latter.   paul koning, 12/23/2001
  */
  if (operand->reloc.exp.X_op == O_constant)
    {
      if (*str == '.')
	str++;
      else
	{
	  /* FIXME: buffer overflow! */
	  char buf[100];
	  char *end;

	  sprintf (buf, "%ld", operand->reloc.exp.X_add_number);
	  operand->reloc.exp.X_add_number = strtol (buf, &end, 8);
	}
    }
#endif
  return str;
}

static char *
parse_op_no_deferred (char *str, struct pdp11_code *operand)
{
  LITTLENUM_TYPE literal_float[2];

  str = skip_whitespace (str);

  switch (*str)
    {
    case '(':				/* (rn) and (rn)+ */
      str = parse_reg (str + 1, operand);
      if (operand->error)
	return str;
      str = skip_whitespace (str);
      if (*str != ')')
	{
	  operand->error = "Missing ')'";
	  return str;
	}
      str++;
      if (*str == '+')
	{
	  operand->code |= 020;
	  str++;
	}
      else
	{
	  operand->code |= 010;
	}
      break;

    case '#':				/* immediate */
    case '$':
      str = parse_expression (str + 1, operand);
      if (operand->error)
	return str;
      operand->additional = TRUE;
      operand->word = operand->reloc.exp.X_add_number;
      switch (operand->reloc.exp.X_op)
	{
	case O_constant:
	  break;
	case O_symbol:
	case O_add:
	case O_subtract:
	  operand->reloc.type = BFD_RELOC_16;
	  operand->reloc.pc_rel = 0;
	  break;
        case O_big:
          if (operand->reloc.exp.X_add_number > 0)
            {
              operand->error = "Error in expression";
              break;
            }
          /* it's a floating literal...  */
          know (operand->reloc.exp.X_add_number < 0);
          flonum_gen2vax ('f', &generic_floating_point_number, literal_float);
          operand->word = literal_float[0];
          if (literal_float[1] != 0)
            as_warn (_("Low order bits truncated in immediate float operand"));
          break;
	default:
	  operand->error = "Error in expression";
	  break;
	}
      operand->code = 027;
      break;

    default:				/* label, d(rn), -(rn) */
      {
	char *old = str;

	if (strncmp (str, "-(", 2) == 0)	/* -(rn) */
	  {
	    str = parse_reg (str + 2, operand);
	    if (operand->error)
	      return str;
	    str = skip_whitespace (str);
	    if (*str != ')')
	      {
		operand->error = "Missing ')'";
		return str;
	      }
	    operand->code |= 040;
	    str++;
	    break;
	  }

	str = parse_expression (str, operand);
	if (operand->error)
	  return str;

	str = skip_whitespace (str);

	if (*str != '(')		/* label */
	  {
	    if (operand->reloc.exp.X_op != O_symbol)
	      {
		operand->error = "Label expected";
		return old;
	      }
	    operand->code = 067;
	    operand->additional = 1;
	    operand->word = 0;
	    operand->reloc.type = BFD_RELOC_16_PCREL;
	    operand->reloc.pc_rel = 1;
	    break;
	  }

	str++;				/* d(rn) */
	str = parse_reg (str, operand);
	if (operand->error)
	  return str;

	str = skip_whitespace (str);

	if (*str != ')')
	  {
	    operand->error = "Missing ')'";
	    return str;
	  }

	str++;
	operand->additional = TRUE;
	operand->code |= 060;
	switch (operand->reloc.exp.X_op)
	  {
	  case O_symbol:
	    operand->word = 0;
	    operand->reloc.pc_rel = 1;
	    break;
	  case O_constant:
	    if ((operand->code & 7) == 7)
	      {
		operand->reloc.pc_rel = 1;
		operand->word = operand->reloc.exp.X_add_number;
	      }
	    else
	      {
		operand->word = operand->reloc.exp.X_add_number;
	      }
	    break;
	  default:
	    BAD_CASE (operand->reloc.exp.X_op);
	  }
	break;
      }
    }

  return str;
}

static char *
parse_op_noreg (char *str, struct pdp11_code *operand)
{
  str = skip_whitespace (str);
  operand->error = NULL;

  if (*str == '@' || *str == '*')
    {
      str = parse_op_no_deferred (str + 1, operand);
      if (operand->error)
	return str;
      operand->code |= 010;
    }
  else
    str = parse_op_no_deferred (str, operand);

  return str;
}

static char *
parse_op (char *str, struct pdp11_code *operand)
{
  str = skip_whitespace (str);

  str = parse_reg (str, operand);
  if (!operand->error)
    return str;

  operand->error = NULL;
  parse_ac5 (str, operand);
  if (!operand->error)
    {
      operand->error = "Float AC not legal as integer operand";
      return str;
    }

  return parse_op_noreg (str, operand);
}

static char *
parse_fop (char *str, struct pdp11_code *operand)
{
  str = skip_whitespace (str);

  str = parse_ac5 (str, operand);
  if (!operand->error)
    return str;

  operand->error = NULL;
  parse_reg (str, operand);
  if (!operand->error)
    {
      operand->error = "General register not legal as float operand";
      return str;
    }

  return parse_op_noreg (str, operand);
}

static char *
parse_separator (char *str, int *error)
{
  str = skip_whitespace (str);
  *error = (*str != ',');
  if (!*error)
    str++;
  return str;
}

void
md_assemble (instruction_string)
     char *instruction_string;
{
  const struct pdp11_opcode *op;
  struct pdp11_code insn, op1, op2;
  int error;
  int size;
  char *err = NULL;
  char *str;
  char *p;
  char c;

  str = skip_whitespace (instruction_string);
  p = find_whitespace (str);
  if (p - str == 0)
    {
      as_bad ("No instruction found");
      return;
    }

  c = *p;
  *p = '\0';
  op = (struct pdp11_opcode *)hash_find (insn_hash, str);
  *p = c;
  if (op == 0)
    {
#if 0
      op1.error = NULL;
      op1.additional = FALSE;
      op1.reloc.type = BFD_RELOC_NONE;
      op1.code = 0;
      op1.word = 0;
      str = parse_expression (str, &op1);
      if (op1.error)
	{
	  as_bad (op1.error);
	  return;
	}

      {
	char *to = frag_more (2);

	md_number_to_chars (to, op1.code, 2);
	if (insn.reloc.type != BFD_RELOC_NONE)
	  fix_new_exp (frag_now, to - frag_now->fr_literal, 2,
		       &insn.reloc.exp, insn.reloc.pc_rel, insn.reloc.type);
      }
#else
      as_bad (_("Unknown instruction '%s'"), str);
#endif

      return;
    }

  if (!pdp11_extension[op->extension])
    {
      as_warn ("Unsupported instruction set extension: %s", op->name);
      return;
    }

  insn.error = NULL;
  insn.code = op->opcode;
  insn.reloc.type = BFD_RELOC_NONE;
  op1.error = NULL;
  op1.additional = FALSE;
  op1.reloc.type = BFD_RELOC_NONE;
  op2.error = NULL;
  op2.additional = FALSE;
  op2.reloc.type = BFD_RELOC_NONE;

  str = p;
  size = 2;

  switch (op->type)
    {
    case PDP11_OPCODE_NO_OPS:
      str = skip_whitespace (str);
      if (*str == 0)
	str = "";
      break;

    case PDP11_OPCODE_IMM3:
    case PDP11_OPCODE_IMM6:
    case PDP11_OPCODE_IMM8:
      str = skip_whitespace (str);
      if (*str == '#' || *str == '$')
	str++;
      str = parse_expression (str, &op1);
      if (op1.error)
	break;
      if (op1.reloc.exp.X_op != O_constant || op1.reloc.type != BFD_RELOC_NONE)
	{
	  op1.error = "operand is not an absolute constant";
	  break;
	}
      switch (op->type)
	{
	case PDP11_OPCODE_IMM3:
	  if (op1.reloc.exp.X_add_number & ~7)
	    {
	      op1.error = "3-bit immediate out of range";
	      break;
	    }
	  break;
	case PDP11_OPCODE_IMM6:
	  if (op1.reloc.exp.X_add_number & ~0x3f)
	    {
	      op1.error = "6-bit immediate out of range";
	      break;
	    }
	  break;
	case PDP11_OPCODE_IMM8:
	  if (op1.reloc.exp.X_add_number & ~0xff)
	    {
	      op1.error = "8-bit immediate out of range";
	      break;
	    }
	  break;
	}
      insn.code |= op1.reloc.exp.X_add_number;
      break;

    case PDP11_OPCODE_DISPL:
      {
	char *new;
	new = parse_expression (str, &op1);
	op1.code = 0;
	op1.reloc.pc_rel = 1;
	op1.reloc.type = BFD_RELOC_PDP11_DISP_8_PCREL;
	if (op1.reloc.exp.X_op != O_symbol)
	  {
	    op1.error = "Symbol expected";
	    break;
	  }
	if (op1.code & ~0xff)
	  {
	    err = "8-bit displacement out of range";
	    break;
	  }
	str = new;
	insn.code |= op1.code;
	insn.reloc = op1.reloc;
      }
      break;

    case PDP11_OPCODE_REG:
      str = parse_reg (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      break;

    case PDP11_OPCODE_OP:
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      break;

    case PDP11_OPCODE_FOP:
      str = parse_fop (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      break;

    case PDP11_OPCODE_REG_OP:
      str = parse_reg (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      str = parse_separator (str, &error);
      if (error)
	{
	  op2.error = "Missing ','";
	  break;
	}
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      break;

    case PDP11_OPCODE_REG_OP_REV:
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      str = parse_separator (str, &error);
      if (error)
	{
	  op2.error = "Missing ','";
	  break;
	}
      str = parse_reg (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      break;

    case PDP11_OPCODE_AC_FOP:
      str = parse_ac (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      str = parse_separator (str, &error);
      if (error)
	{
	  op1.error = "Missing ','";
	  break;
	}
      str = parse_fop (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      break;

    case PDP11_OPCODE_FOP_AC:
      str = parse_fop (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      str = parse_separator (str, &error);
      if (error)
	{
	  op1.error = "Missing ','";
	  break;
	}
      str = parse_ac (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      break;

    case PDP11_OPCODE_AC_OP:
      str = parse_ac (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      str = parse_separator (str, &error);
      if (error)
	{
	  op1.error = "Missing ','";
	  break;
	}
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      break;

    case PDP11_OPCODE_OP_AC:
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code;
      if (op1.additional)
	size += 2;
      str = parse_separator (str, &error);
      if (error)
	{
	  op1.error = "Missing ','";
	  break;
	}
      str = parse_ac (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code << 6;
      break;

    case PDP11_OPCODE_OP_OP:
      str = parse_op (str, &op1);
      if (op1.error)
	break;
      insn.code |= op1.code << 6;
      if (op1.additional)
	size += 2;
      str = parse_separator (str, &error);
      if (error)
	{
	  op2.error = "Missing ','";
	  break;
	}
      str = parse_op (str, &op2);
      if (op2.error)
	break;
      insn.code |= op2.code;
      if (op2.additional)
	size += 2;
      break;

    case PDP11_OPCODE_REG_DISPL:
      {
	char *new;
	str = parse_reg (str, &op2);
	if (op2.error)
	  break;
	insn.code |= op2.code << 6;
	str = parse_separator (str, &error);
	if (error)
	  {
	    op1.error = "Missing ','";
	    break;
	  }
	new = parse_expression (str, &op1);
	op1.code = 0;
	op1.reloc.pc_rel = 1;
	op1.reloc.type = BFD_RELOC_PDP11_DISP_6_PCREL;
	if (op1.reloc.exp.X_op != O_symbol)
	  {
	    op1.error = "Symbol expected";
	    break;
	  }
	if (op1.code & ~0x3f)
	  {
	    err = "6-bit displacement out of range";
	    break;
	  }
	str = new;
	insn.code |= op1.code;
	insn.reloc = op1.reloc;
      }
      break;

    default:
      BAD_CASE (op->type);
    }

  if (op1.error)
    err = op1.error;
  else if (op2.error)
    err = op2.error;
  else
    {
      str = skip_whitespace (str);
      if (*str)
	err = "Too many operands";
    }

  {
    char *to = NULL;

    if (err)
      {
	as_bad (err);
	return;
      }

    to = frag_more (size);

    md_number_to_chars (to, insn.code, 2);
    if (insn.reloc.type != BFD_RELOC_NONE)
      fix_new_exp (frag_now, to - frag_now->fr_literal, 2,
		   &insn.reloc.exp, insn.reloc.pc_rel, insn.reloc.type);
    to += 2;

    if (op1.additional)
      {
	md_number_to_chars (to, op1.word, 2);
	if (op1.reloc.type != BFD_RELOC_NONE)
	  fix_new_exp (frag_now, to - frag_now->fr_literal, 2,
		       &op1.reloc.exp, op1.reloc.pc_rel, op1.reloc.type);
	to += 2;
      }

    if (op2.additional)
      {
	md_number_to_chars (to, op2.word, 2);
	if (op2.reloc.type != BFD_RELOC_NONE)
	  fix_new_exp (frag_now, to - frag_now->fr_literal, 2,
		       &op2.reloc.exp, op2.reloc.pc_rel, op2.reloc.type);
      }
  }
}

int
md_estimate_size_before_relax (fragP, segment)
     fragS *fragP ATTRIBUTE_UNUSED;
     segT segment ATTRIBUTE_UNUSED;
{
  return 0;
}

void
md_convert_frag (headers, seg, fragP)
     bfd *headers ATTRIBUTE_UNUSED;
     segT seg ATTRIBUTE_UNUSED;
     fragS *fragP ATTRIBUTE_UNUSED;
{
}

const int md_short_jump_size = 2;
const int md_long_jump_size = 4;

void
md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
     char *ptr ATTRIBUTE_UNUSED;
     addressT from_addr ATTRIBUTE_UNUSED;
     addressT to_addr ATTRIBUTE_UNUSED;
     fragS *frag ATTRIBUTE_UNUSED;
     symbolS *to_symbol ATTRIBUTE_UNUSED;
{
}

void
md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
     char *ptr ATTRIBUTE_UNUSED;
     addressT from_addr ATTRIBUTE_UNUSED;
     addressT to_addr ATTRIBUTE_UNUSED;
     fragS *frag ATTRIBUTE_UNUSED;
     symbolS *to_symbol ATTRIBUTE_UNUSED;
{
}

static int
set_option (arg)
     char *arg;
{
  int yes = 1;

  if (strcmp (arg, "all-extensions") == 0 ||
      strcmp (arg, "all") == 0)
    {
      memset (pdp11_extension, ~0, sizeof pdp11_extension);
      pdp11_extension[PDP11_NONE] = 0;
      return 1;
    }
  else if (strcmp (arg, "no-extensions") == 0)
    {
      memset (pdp11_extension, 0, sizeof pdp11_extension);
      pdp11_extension[PDP11_BASIC] = 1;
      return 1;
    }

  if (strncmp (arg, "no-", 3) == 0)
    {
      yes = 0;
      arg += 3;
    }

  if (strcmp (arg, "cis") == 0)			/* commersial instructions */
    pdp11_extension[PDP11_CIS] = yes;
  else if (strcmp (arg, "csm") == 0)		/* call supervisor mode */
    pdp11_extension[PDP11_CSM] = yes;
  else if (strcmp (arg, "eis") == 0)		/* extended instruction set */
    pdp11_extension[PDP11_EIS] = pdp11_extension[PDP11_LEIS] = yes;
  else if (strcmp (arg, "fis") == 0 ||		/* KEV11 floating-point */
	   strcmp (arg, "kev11") == 0 ||
	   strcmp (arg, "kev-11") == 0)
    pdp11_extension[PDP11_FIS] = yes;
  else if (strcmp (arg, "fpp") == 0 ||		/* FP-11 floating-point */
	   strcmp (arg, "fpu") == 0 ||
	   strcmp (arg, "fp11") == 0 ||
	   strcmp (arg, "fp-11") == 0 ||
	   strcmp (arg, "fpj11") == 0 ||
	   strcmp (arg, "fp-j11") == 0 ||
	   strcmp (arg, "fpj-11") == 0)
    pdp11_extension[PDP11_FPP] = yes;
  else if (strcmp (arg, "limited-eis") == 0)	/* limited extended insns */
    {
      pdp11_extension[PDP11_LEIS] = yes;
      if (!pdp11_extension[PDP11_LEIS])
	pdp11_extension[PDP11_EIS] = 0;
    }
  else if (strcmp (arg, "mfpt") == 0)		/* move from processor type */
    pdp11_extension[PDP11_MFPT] = yes;
  else if (strncmp (arg, "mproc", 5) == 0 ||	/* multiprocessor insns: */
	   strncmp (arg, "multiproc", 9) == 0 )	/* TSTSET, WRTLCK */
    pdp11_extension[PDP11_MPROC] = yes;
  else if (strcmp (arg, "mxps") == 0)		/* move from/to proc status */
    pdp11_extension[PDP11_MXPS] = yes;
  else if (strcmp (arg, "pic") == 0)		/* position-independent code */
    asm_option[ASM_OPT_PIC] = yes;
  else if (strcmp (arg, "spl") == 0)		/* set priority level */
    pdp11_extension[PDP11_SPL] = yes;
  else if (strcmp (arg, "ucode") == 0 ||	/* microcode instructions: */
	   strcmp (arg, "microcode") == 0)	/* LDUB, MED, XFC */
    pdp11_extension[PDP11_UCODE] = yes;
  else
    return 0;

  return 1;
}

static int
set_cpu_model (arg)
     char *arg;
{
  char buf[4];
  char *model = buf;

  if (arg[0] == 'k')
    arg++;

  *model++ = *arg++;

  if (strchr ("abdx", model[-1]) == NULL)
    return 0;

  if (model[-1] == 'd')
    {
      if (arg[0] == 'f' ||
	  arg[0] == 'j')
	model[-1] = *arg++;
    }
  else if (model[-1] == 'x')
    {
      if (arg[0] == 't')
	model[-1] = *arg++;
    }

  if (arg[0] == '-')
    arg++;

  if (strncmp (arg, "11", 2) != 0)
    return 0;
  arg += 2;

  if (arg[0] == '-')
    {
      if (*++arg == 0)
	return 0;
    }

  /* allow up to two revision letters */
  if (arg[0] != 0)
    *model++ = *arg++;
  if (arg[0] != 0)
    *model++ = *arg++;

  *model++ = 0;

  set_option ("no-extensions");

  if (strncmp (buf, "a", 1) == 0)		/* KA11 (11/15/20) */
    return 1; /* no extensions */

  else if (strncmp (buf, "b", 1) == 0)		/* KB11 (11/45/50/55/70) */
    return set_option ("eis") &&
           set_option ("spl");

  else if (strncmp (buf, "da", 2) == 0)		/* KD11-A (11/35/40) */
    return set_option ("limited-eis");

  else if (strncmp (buf, "db", 2) == 0 ||	/* KD11-B (11/05/10) */
	   strncmp (buf, "dd", 2) == 0)		/* KD11-D (11/04) */
    return 1; /* no extensions */

  else if (strncmp (buf, "de", 2) == 0)		/* KD11-E (11/34) */
    return set_option ("eis") &&
           set_option ("mxps");

  else if (strncmp (buf, "df", 2) == 0 ||	/* KD11-F (11/03) */
	   strncmp (buf, "dh", 2) == 0 ||	/* KD11-H (11/03) */
	   strncmp (buf, "dq", 2) == 0)		/* KD11-Q (11/03) */
    return set_option ("limited-eis") &&
           set_option ("mxps");

  else if (strncmp (buf, "dk", 2) == 0)		/* KD11-K (11/60) */
    return set_option ("eis") &&
           set_option ("mxps") &&
           set_option ("ucode");

  else if (strncmp (buf, "dz", 2) == 0)		/* KD11-Z (11/44) */
    return set_option ("csm") &&
           set_option ("eis") &&
           set_option ("mfpt") &&
           set_option ("mxps") &&
           set_option ("spl");

  else if (strncmp (buf, "f", 1) == 0)		/* F11 (11/23/24) */
    return set_option ("eis") &&
           set_option ("mfpt") &&
           set_option ("mxps");

  else if (strncmp (buf, "j", 1) == 0)		/* J11 (11/53/73/83/84/93/94)*/
    return set_option ("csm") &&
           set_option ("eis") &&
           set_option ("mfpt") &&
           set_option ("multiproc") &&
           set_option ("mxps") &&
           set_option ("spl");

  else if (strncmp (buf, "t", 1) == 0)		/* T11 (11/21) */
    return set_option ("limited-eis") &&
           set_option ("mxps");

  else
    return 0;
}

static int
set_machine_model (arg)
     char *arg;
{
  if (strncmp (arg, "pdp-11/", 7) != 0 &&
      strncmp (arg, "pdp11/", 6) != 0 &&
      strncmp (arg, "11/", 3) != 0)
    return 0;

  if (strncmp (arg, "pdp", 3) == 0)
    arg += 3;
  if (arg[0] == '-')
    arg++;
  if (strncmp (arg, "11/", 3) == 0)
    arg += 3;

  if (strcmp (arg, "03") == 0)			/* 11/03 */
    return set_cpu_model ("kd11f");		/* KD11-F */

  else if (strcmp (arg, "04") == 0)		/* 11/04 */
    return set_cpu_model ("kd11d");		/* KD11-D */

  else if (strcmp (arg, "05") == 0 ||		/* 11/05 or 11/10 */
	   strcmp (arg, "10") == 0)
    return set_cpu_model ("kd11b");		/* KD11-B */

  else if (strcmp (arg, "15") == 0 ||		/* 11/15 or 11/20 */
	   strcmp (arg, "20") == 0)
    return set_cpu_model ("ka11");		/* KA11 */

  else if (strcmp (arg, "21") == 0)		/* 11/21 */
    return set_cpu_model ("t11");		/* T11 */

  else if (strcmp (arg, "23") == 0 ||		/* 11/23 or 11/24 */
	   strcmp (arg, "24") == 0)
    return set_cpu_model ("f11");		/* F11 */

  else if (strcmp (arg, "34") == 0 ||		/* 11/34 or 11/34a */
           strcmp (arg, "34a") == 0)
    return set_cpu_model ("kd11e");		/* KD11-E */

  else if (strcmp (arg, "35") == 0 ||		/* 11/35 or 11/40 */
	   strcmp (arg, "40") == 0)
    return set_cpu_model ("kd11da");		/* KD11-A */

  else if (strcmp (arg, "44") == 0)		/* 11/44 */
    return set_cpu_model ("kd11dz");		/* KD11-Z */

  else if (strcmp (arg, "45") == 0 ||		/* 11/45/50/55/70 */
	   strcmp (arg, "50") == 0 ||
	   strcmp (arg, "55") == 0 ||
	   strcmp (arg, "70") == 0)
    return set_cpu_model ("kb11");		/* KB11 */

  else if (strcmp (arg, "60") == 0)		/* 11/60 */
    return set_cpu_model ("kd11k");		/* KD11-K */ /* FPP? */

  else if (strcmp (arg, "53") == 0 ||		/* 11/53/73/83/84/93/94 */
	   strcmp (arg, "73") == 0 ||
	   strcmp (arg, "83") == 0 ||
	   strcmp (arg, "84") == 0 ||
	   strcmp (arg, "93") == 0 ||
	   strcmp (arg, "94") == 0)
    return set_cpu_model ("j11") &&		/* J11 */
           set_option ("fpp");			/* All J11 machines come */
						/* with FPP installed.  */
  else
    return 0;
}

const char *md_shortopts = "m:";

struct option md_longopts[] =
{
#define OPTION_CPU 257
  { "cpu", required_argument, NULL, OPTION_CPU },
#define OPTION_MACHINE 258
  { "machine", required_argument, NULL, OPTION_MACHINE },
#define OPTION_PIC 259
  { "pic", no_argument, NULL, OPTION_PIC },
  { NULL, no_argument, NULL, 0 }
};

size_t md_longopts_size = sizeof (md_longopts);

/*
 * md_parse_option
 *	Invocation line includes a switch not recognized by the base assembler.
 *	See if it's a processor-specific option.
 */

int
md_parse_option (c, arg)
     int c;
     char *arg;
{
  init_defaults ();

  switch (c)
    {
    case 'm':
      if (set_option (arg))
	return 1;
      if (set_cpu_model (arg))
	return 1;
      if (set_machine_model (arg))
	return 1;
      break;

    case OPTION_CPU:
      if (set_cpu_model (arg))
	return 1;
      break;

    case OPTION_MACHINE:
      if (set_machine_model (arg))
	return 1;
      break;

    case OPTION_PIC:
      if (set_option ("pic"))
	return 1;
      break;

    default:
      break;
    }

  as_bad ("unrecognized option `-%c%s'", c, arg ? arg : "");

  return 0;
}

/*
One possible way of parsing options.

enum
{
  OPTION_CSM,
  OPTION_CIS,
  ...
};

struct
{
  const char *pattern;
  int opt;
  const char *description;
} options;

static struct options extension_opts[] =
{
  { "Ncsm", OPTION_CSM,
			"allow (disallow) CSM instruction" },
  { "Ncis", OPTION_CIS,
			"allow (disallow) commersial instruction set" },
  { "Neis", OPTION_EIS,
			"allow (disallow) extended instruction set" },
  ...
  { "all-extensions", OPTION_ALL_EXTENSIONS,
			"allow all instruction set extensions\n\
			(this is the default)" },
  { "no-extensions", OPTION_NO_EXTENSIONS,
			"disallow all instruction set extensions" },
  { "pic", OPTION_PIC,
			"position-independent code" },
};

static struct options cpu_opts[] =
{
  { "Ka_11_*", OPTION_KA11, "KA11 CPU. ..." },
  { "Kb_11_*", OPTION_KB11, "KB11 CPU. ..." },
  { "Kd_11_a*", OPTION_KD11A, "KD11-A CPU. ..." },
  { "Kd_11_b*", OPTION_KD11B, "KD11-B CPU. ..." },
  { "Kd_11_d*", OPTION_KD11D, "KD11-D CPU. ..." },
  { "Kd_11_e*", OPTION_KD11E, "KD11-E CPU. ..." },
  { "Kd_11_f*", OPTION_KD11F, "KD11-F CPU. ..." },
  { "Kd_11_h*", OPTION_KD11H, "KD11-H CPU. ..." },
  { "Kd_11_q*", OPTION_KD11Q, "KD11-Q CPU. ..." },
  { "Kd_11_z*", OPTION_KD11Z, "KD11-Z CPU. ..." },
  { "Df_11_*", OPTION_F11, "F11 CPU. ..." },
  { "Dj_11_*", OPTION_J11, "J11 CPU. ..." },
  { "Dt_11_*", OPTION_T11, "T11 CPU. ..." },
};

static struct options model_opts[] =
{
  { "P03", OPTION_PDP11_03, "same as ..." },
  { "P04", OPTION_PDP11_04, "same as ..." },
  { "P05", OPTION_PDP11_05, "same as ..." },
  { "P10", OPTION_PDP11_10, "same as ..." },
  { "P15", OPTION_PDP11_15, "same as ..." },
  { "P20", OPTION_PDP11_20, "same as ..." },
  { "P21", OPTION_PDP11_21, "same as ..." },
  { "P24", OPTION_PDP11_24, "same as ..." },
  { "P34", OPTION_PDP11_34, "same as ..." },
  { "P34a", OPTION_PDP11_34A, "same as ..." },
  { "P40", OPTION_PDP11_40, "same as ..." },
  { "P44", OPTION_PDP11_44, "same as ..." },
  { "P45", OPTION_PDP11_45, "same as ..." },
  { "P50", OPTION_PDP11_50, "same as ..." },
  { "P53", OPTION_PDP11_53, "same as ..." },
  { "P55", OPTION_PDP11_55, "same as ..." },
  { "P60", OPTION_PDP11_60, "same as ..." },
  { "P70", OPTION_PDP11_70, "same as ..." },
  { "P73", OPTION_PDP11_73, "same as ..." },
  { "P83", OPTION_PDP11_83, "same as ..." },
  { "P84", OPTION_PDP11_84, "same as ..." },
  { "P93", OPTION_PDP11_93, "same as ..." },
  { "P94", OPTION_PDP11_94, "same as ..." },
};

struct
{
  const char *title;
  struct options *opts;
  int num;
} all_opts[] =
{
  { "PDP-11 instruction set extentions",
    extension_opts,
    sizeof extension_opts / sizeof extension_opts[0] },
  { "PDP-11 CPU model options",
    cpu_opts,
    sizeof cpu_opts / sizeof cpu_opts[0] },
  { "PDP-11 machine model options",
    model_opts,
    sizeof model_opts / sizeof model_opts[0] },
};

int
parse_match (char *arg, char *pattern)
{
  int yes = 1;

  while (*pattern)
    {
      switch (*pattern++)
	{
	case 'N':
	  if (strncmp (arg, "no-") == 0)
	    {
	      yes = 0;
	      arg += 3;
	    }
	  break;

	case 'K':
	  if (arg[0] == 'k')
	    arg++;
	  break;

	case 'D':
	  if (strncmp (arg, "kd", 2) == 0)
	    arg +=2;
	  break;

	case 'P':
	  if (strncmp (arg, "pdp-11/", 7) == 0)
	    arg += 7;
	  else if (strncmp (arg, "pdp11/", 6) == 0)
	    arg += 6;
	  else if (strncmp (arg, "11/", 3) == 0)
	    arg += 3;
	  break;

	case '_':
	  if (arg[0] == "-")
	    {
	      if (*++arg == 0)
		return 0;
	    }
	  break;

	case '*':
	  return 1;

	default:
	  if (*arg++ != pattern[-1])
	    return 0;
	}
    }

  return arg[0] == 0;
}

int
fprint_opt (stream, pattern)
     FILE *stream;
     const char *pattern;
{
  int n;

  while (*pattern)
    {
      switch (*pattern++)
	{
	case 'N':
	  n += fprintf (stream, "(no-)");
	  break;

	case 'K':
	  n += fprintf (stream, "k");
	  break;

	case 'P':
	  n += fprintf (stream "11/");
	  break;

	case 'D':
	case '_':
	case '*':
	  break;

	default:
	  fputc (pattern[-1], stream);
	  n++;
	}
    }

  return n;
}

int
parse_option (char *arg)
{
  int i, j;

  for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
    {
      for (j = 0; j < all_opts[i].num; j++)
	{
	  if (parse_match (arg, all_opts[i].opts[j].pattern))
	    {
	      set_option (all_opts[i].opts[j].opt);
	      return 1;
	    }
	}
    }

  return 0;
}

static void
fprint_space (stream, n)
     FILE *stream;
     int n;
{
  while (n--)
    fputc (' ', stream);
}

void
md_show_usage (stream)
     FILE *stream;
{
  int i, j, n;

  for (i = 0; i < sizeof all_opts / sizeof all_opts[0]; i++)
    {
      fprintf (stream "\n%s:\n\n", all_opts[i].title);

      for (j = 0; j < all_opts[i].num; j++)
	{
	  fprintf (stream, "-m");
	  n = fprintf_opt (stream, all_opts[i].opts[j].pattern);
	  fprint_space (stream, 22 - n);
	  fprintf (stream, "%s\n", all_opts[i].opts[j].description);
	}
    }
}
*/

void
md_show_usage (stream)
     FILE *stream;
{
  fprintf (stream, "\
\n\
PDP-11 instruction set extentions:\n\
\n\
-m(no-)cis		allow (disallow) commersial instruction set\n\
-m(no-)csm		allow (disallow) CSM instruction\n\
-m(no-)eis		allow (disallow) full extended instruction set\n\
-m(no-)fis		allow (disallow) KEV11 floating-point instructions\n\
-m(no-)fpp		allow (disallow) FP-11 floating-point instructions\n\
-m(no-)fpu		allow (disallow) FP-11 floating-point instructions\n\
-m(no-)limited-eis	allow (disallow) limited extended instruction set\n\
-m(no-)mfpt		allow (disallow) processor type instruction\n\
-m(no-)multiproc	allow (disallow) multiprocessor instructions\n\
-m(no-)mxps		allow (disallow) processor status instructions\n\
-m(no-)spl		allow (disallow) SPL instruction\n\
-m(no-)ucode		allow (disallow) microcode instructions\n\
-mall-extensions	allow all instruction set extensions\n\
			(this is the default)\n\
-mno-extentions		disallow all instruction set extensions\n\
-pic			generate position-indepenent code\n\
\n\
PDP-11 CPU model options:\n\
\n\
-mka11*			KA11 CPU.  base line instruction set only\n\
-mkb11*			KB11 CPU.  enable full EIS and SPL\n\
-mkd11a*		KD11-A CPU.  enable limited EIS\n\
-mkd11b*		KD11-B CPU.  base line instruction set only\n\
-mkd11d*		KD11-D CPU.  base line instruction set only\n\
-mkd11e*		KD11-E CPU.  enable full EIS, MTPS, and MFPS\n\
-mkd11f*		KD11-F CPU.  enable limited EIS, MTPS, and MFPS\n\
-mkd11h*		KD11-H CPU.  enable limited EIS, MTPS, and MFPS\n\
-mkd11q*		KD11-Q CPU.  enable limited EIS, MTPS, and MFPS\n\
-mkd11k*		KD11-K CPU.  enable full EIS, MTPS, MFPS, LDUB, MED,\n\
			XFC, and MFPT\n\
-mkd11z*		KD11-Z CPU.  enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
			and CSM\n\
-mf11*			F11 CPU.  enable full EIS, MFPS, MTPS, and MFPT\n\
-mj11*			J11 CPU.  enable full EIS, MTPS, MFPS, MFPT, SPL,\n\
			CSM, TSTSET, and WRTLCK\n\
-mt11*			T11 CPU.  enable limited EIS, MTPS, and MFPS\n\
\n\
PDP-11 machine model options:\n\
\n\
-m11/03			same as -mkd11f\n\
-m11/04			same as -mkd11d\n\
-m11/05			same as -mkd11b\n\
-m11/10			same as -mkd11b\n\
-m11/15			same as -mka11\n\
-m11/20			same as -mka11\n\
-m11/21			same as -mt11\n\
-m11/23			same as -mf11\n\
-m11/24			same as -mf11\n\
-m11/34			same as -mkd11e\n\
-m11/34a		same as -mkd11e -mfpp\n\
-m11/35			same as -mkd11a\n\
-m11/40			same as -mkd11a\n\
-m11/44			same as -mkd11z\n\
-m11/45			same as -mkb11\n\
-m11/50			same as -mkb11\n\
-m11/53			same as -mj11\n\
-m11/55			same as -mkb11\n\
-m11/60			same as -mkd11k\n\
-m11/70			same as -mkb11\n\
-m11/73			same as -mj11\n\
-m11/83			same as -mj11\n\
-m11/84			same as -mj11\n\
-m11/93			same as -mj11\n\
-m11/94			same as -mj11\n\
");
}

symbolS *
md_undefined_symbol (name)
     char *name ATTRIBUTE_UNUSED;
{
  return 0;
}

valueT
md_section_align (segment, size)
     segT segment ATTRIBUTE_UNUSED;
     valueT size;
{
  return (size + 1) & ~1;
}

long
md_pcrel_from (fixP)
     fixS *fixP;
{
  return fixP->fx_frag->fr_address + fixP->fx_where + fixP->fx_size;
}

/* Translate internal representation of relocation info to BFD target
   format.  */
arelent *
tc_gen_reloc (section, fixp)
     asection *section ATTRIBUTE_UNUSED;
     fixS *fixp;
{
  arelent *reloc;
  bfd_reloc_code_real_type code;

  reloc = (arelent *) xmalloc (sizeof (arelent));

  reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;

  /* This is taken account for in md_apply_fix3().  */
  reloc->addend = -symbol_get_bfdsym (fixp->fx_addsy)->section->vma;

  switch (fixp->fx_r_type)
    {
    case BFD_RELOC_16:
      if (fixp->fx_pcrel)
	code = BFD_RELOC_16_PCREL;
      else
	code = BFD_RELOC_16;
      break;

    case BFD_RELOC_16_PCREL:
      code = BFD_RELOC_16_PCREL;
      break;

    default:
      BAD_CASE (fixp->fx_r_type);
      return NULL;
    }

  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);

  if (reloc->howto == NULL)
    {
      as_bad_where (fixp->fx_file, fixp->fx_line,
		    "Can not represent %s relocation in this object file format",
		    bfd_get_reloc_code_name (code));
      return NULL;
    }

  return reloc;
}

void
pseudo_bss (c)
     int c ATTRIBUTE_UNUSED;
{
  int temp;

  temp = get_absolute_expression ();
  subseg_set (bss_section, temp);
  demand_empty_rest_of_line ();
}

void
pseudo_even (c)
     int c ATTRIBUTE_UNUSED;
{
  int alignment = 1; /* 2^1 */
  frag_align (alignment, 0, 1);
  record_alignment (now_seg, alignment);
}

/* end of tc-pdp11.c */