Handle EV5 (21164/66/68) PALcode support.

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

/* tc-alpha.c - Processor-specific code for the DEC Alpha CPU.
   Copyright (C) 1989, 1993, 1994 Free Software Foundation, Inc.
   Contributed by Carnegie Mellon University, 1993.
   Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
   Modified by Ken Raeburn for gas-2.x and ECOFF support.

   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, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
 * Mach Operating System
 * Copyright (c) 1993 Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */
/*
 * HISTORY
 *  5-Oct-93  Alessandro Forin (af) at Carnegie-Mellon University
 *      First Checkin
 *
 *    Author:   Alessandro Forin, Carnegie Mellon University
 *    Date:     Jan 1993
 */

#include "as.h"
#include "alpha-opcode.h"
#include "subsegs.h"

/* @@ Will a simple 0x8000 work here?  If not, why not?  */
#define GP_ADJUSTMENT   (0x8000 - 0x10)

/* Which machine type is this?  Currently stores an integer for the
   model, one of: 21064, 21066, 21164.  */
static unsigned long machine;

/* These are exported to relaxing code, even though we don't do any
   relaxing on this processor currently.  */
const relax_typeS md_relax_table[1];
int md_short_jump_size = 4;
int md_long_jump_size = 4;

/* handle of the OPCODE hash table */
static struct hash_control *op_hash;

/* Sections and symbols we'll want to keep track of.  */
static segT lita_sec, rdata, sdata, lit8_sec, lit4_sec;
static symbolS *lit8_sym, *lit4_sym;

/* Setting for ".set [no]{at,macro}".  */
static int at_ok = 1, macro_ok = 1;

/* Keep track of global pointer.  */
valueT alpha_gp_value;
static symbolS *gp;

/* We'll probably be using this relocation frequently, and we
   will want to compare for it.  */
static reloc_howto_type *gpdisp_hi16_howto;

/* These are exported to ECOFF code.  */
unsigned long alpha_gprmask, alpha_fprmask;

/* Used for LITUSE relocations.  */
static expressionS lituse_basereg, lituse_byteoff, lituse_jsr;

/* Address size: In OSF/1 1.3, an undocumented "-32addr" option will
   cause all addresses to be treated as 32-bit values in memory.  (The
   in-register versions are all sign-extended to 64 bits, of course.)
   Some other systems may want this option too.  */
static int addr32;

/* Imported functions -- they should be defined in header files somewhere.  */
extern segT subseg_get ();
extern PTR bfd_alloc_by_size_t ();
extern void s_globl (), s_long (), s_short (), s_space (), cons (), s_text (),
  s_data (), float_cons ();

/* Static functions, needing forward declarations.  */
static void s_mask (), s_base (), s_proc (), s_alpha_set ();
static void s_gprel32 (), s_rdata (), s_sdata (), s_alpha_comm ();
static int alpha_ip ();

const pseudo_typeS md_pseudo_table[] =
{
  {"common", s_comm, 0},        /* is this used? */
  {"comm", s_alpha_comm, 0},    /* osf1 compiler does this */
  {"rdata", s_rdata, 0},
  {"sdata", s_sdata, 0},
  {"gprel32", s_gprel32, 0},
  {"t_floating", float_cons, 'd'},
  {"s_floating", float_cons, 'f'},
  {"f_floating", float_cons, 'F'},
  {"g_floating", float_cons, 'G'},
  {"d_floating", float_cons, 'D'},

  {"proc", s_proc, 0},
  {"aproc", s_proc, 1},
  {"set", s_alpha_set, 0},
  {"reguse", s_ignore, 0},
  {"livereg", s_ignore, 0},
  {"extern", s_ignore, 0},      /*??*/
  {"base", s_base, 0},          /*??*/
  {"option", s_ignore, 0},
  {"prologue", s_ignore, 0},
  {"aent", s_ignore, 0},
  {"ugen", s_ignore, 0},

/* We don't do any optimizing, so we can safely ignore these.  */
  {"noalias", s_ignore, 0},
  {"alias", s_ignore, 0},

  {NULL, 0, 0},
};

#define SA      21              /* shift for register Ra */
#define SB      16              /* shift for register Rb */
#define SC      0               /* shift for register Rc */
#define SN      13              /* shift for 8 bit immediate # */

#define T9      23
#define T10     24
#define T11     25
#define T12     26
#define RA      26              /* note: same as T12 */
#define PV      27
#define AT      28
#define GP      29
#define SP      30
#define ZERO    31

#define OPCODE(X)       (((X) >> 26) & 0x3f)
#define OP_FCN(X)       (((X) >> 5) & 0x7f)

#ifndef FIRST_32BIT_QUADRANT
#define FIRST_32BIT_QUADRANT 0
#endif

int first_32bit_quadrant = FIRST_32BIT_QUADRANT;
int base_register = FIRST_32BIT_QUADRANT ? ZERO : GP;

int no_mixed_code = 0;
int nofloats = 0;

/* This array holds the chars that always start a comment.  If the
    pre-processor is disabled, these aren't very useful */
const char comment_chars[] = "#";

/* This array holds the chars that only start a comment at the beginning of
   a line.  If the line seems to have the form '# 123 filename'
   .line and .file directives will appear in the pre-processed output */
/* Note that input_file.c hand checks for '#' at the beginning of the
   first line of the input file.  This is because the compiler outputs
   #NO_APP at the beginning of its output. */
/* Also note that '/*' will always start a comment */
const char line_comment_chars[] = "#!";

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

const char line_separator_chars[1];

/* Chars that mean this number is a floating point constant, as in
   "0f12.456" or "0d1.2345e12".  */
/* @@ Do all of these really get used on the alpha??  */
char FLT_CHARS[] = "rRsSfFdDxXpP";

/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
   changed in read.c.  Ideally it shouldn't have to know about it at all,
   but nothing is ideal around here.  */

struct reloc_data {
  expressionS exp;
  int pcrel;
  bfd_reloc_code_real_type code;
};

/* Occasionally, two relocations will be desired for one address.
   Mainly only in cases like "jsr $r,foo" where we want both a LITUSE
   and a HINT reloc.  */
#define MAX_RELOCS 2

struct alpha_it {
  unsigned long opcode; /* need at least 32 bits */
  struct reloc_data reloc[MAX_RELOCS];
};

static void getExpression (char *str, struct alpha_it *insn);
static char *expr_end;

#define note_gpreg(R)           (alpha_gprmask |= (1 << (R)))
#define note_fpreg(R)           (alpha_fprmask |= (1 << (R)))

int
tc_get_register (frame)
     int frame;
{
  int reg;
  int framereg = SP;

  SKIP_WHITESPACE ();
  if (*input_line_pointer == '$')
    {
      input_line_pointer++;
      if (input_line_pointer[0] == 's'
          && input_line_pointer[1] == 'p')
        {
          input_line_pointer += 2;
          framereg = SP;
        }
      else
        framereg = get_absolute_expression ();
      framereg &= 31;           /* ? */
    }
  else
    as_warn ("frame reg expected, using $%d.", framereg);

  note_gpreg (framereg);
  return framereg;
}

static void
s_rdata (ignore)
     int ignore;
{
  int temp;

  temp = get_absolute_expression ();
#if 0
  if (!rdata)
    rdata = subseg_get (".rdata", 0);
  subseg_set (rdata, (subsegT) temp);
#else
  rdata = subseg_new (".rdata", 0);
#endif
  demand_empty_rest_of_line ();
}

static void
s_sdata (ignore)
     int ignore;
{
  int temp;

  temp = get_absolute_expression ();
#if 0
  if (!sdata)
    sdata = subseg_get (".sdata", 0);
  subseg_set (sdata, (subsegT) temp);
#else
  sdata = subseg_new (".sdata", 0);
#endif
  demand_empty_rest_of_line ();
}

static void
s_alpha_comm (ignore)
     int ignore;
{
  register char *name;
  register char c;
  register char *p;
  offsetT temp;
  register symbolS *symbolP;

  name = input_line_pointer;
  c = get_symbol_end ();
  /* just after name is now '\0' */
  p = input_line_pointer;
  *p = c;
  SKIP_WHITESPACE ();
  /* Alpha OSF/1 compiler doesn't provide the comma, gcc does.  */
  if (*input_line_pointer == ',')
    {
      input_line_pointer++;
      SKIP_WHITESPACE ();
    }
  if ((temp = get_absolute_expression ()) < 0)
    {
      as_warn (".COMMon length (%ld.) <0! Ignored.", (long) temp);
      ignore_rest_of_line ();
      return;
    }
  *p = 0;
  symbolP = symbol_find_or_make (name);
  *p = c;
  if (S_IS_DEFINED (symbolP))
    {
      as_bad ("Ignoring attempt to re-define symbol");
      ignore_rest_of_line ();
      return;
    }
  if (S_GET_VALUE (symbolP))
    {
      if (S_GET_VALUE (symbolP) != (valueT) temp)
        as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
                S_GET_NAME (symbolP),
                (long) S_GET_VALUE (symbolP),
                (long) temp);
    }
  else
    {
      S_SET_VALUE (symbolP, (valueT) temp);
      S_SET_EXTERNAL (symbolP);
    }

  know (symbolP->sy_frag == &zero_address_frag);
  demand_empty_rest_of_line ();
}

arelent *
tc_gen_reloc (sec, fixp)
     asection *sec;
     fixS *fixp;
{
  arelent *reloc;

  reloc = (arelent *) bfd_alloc_by_size_t (stdoutput, sizeof (arelent));
  reloc->sym_ptr_ptr = &fixp->fx_addsy->bsym;
  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;

  if (fixp->fx_r_type > BFD_RELOC_UNUSED || fixp->fx_r_type < 0)
    abort ();

  if (fixp->fx_r_type == BFD_RELOC_ALPHA_GPDISP_HI16)
    {
      if (!gpdisp_hi16_howto)
        gpdisp_hi16_howto = bfd_reloc_type_lookup (stdoutput,
                                                   fixp->fx_r_type);
      reloc->howto = gpdisp_hi16_howto;
    }
  else
    reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
  assert (reloc->howto != 0);
  if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
    {
      as_fatal ("bug in handling type-%d relocs", fixp->fx_r_type);
      abort ();
    }
  assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);

  if (fixp->fx_r_type == BFD_RELOC_ALPHA_LITERAL)
    {
      /* fake out bfd_perform_relocation. sigh */
      reloc->addend = -alpha_gp_value;
    }
  else if (reloc->howto->pc_relative && reloc->howto->pcrel_offset)
    {
      reloc->addend = fixp->fx_offset - reloc->address;
    }
  else
    reloc->addend = fixp->fx_offset;
  return reloc;
}

static void
s_base ()
{
  if (first_32bit_quadrant)
    {
      /* not fatal, but it might not work in the end */
      as_warn ("File overrides no-base-register option.");
      first_32bit_quadrant = 0;
    }

  SKIP_WHITESPACE ();
  if (*input_line_pointer == '$')
    {                           /* $rNN form */
      input_line_pointer++;
      if (*input_line_pointer == 'r')
        input_line_pointer++;
    }

  base_register = get_absolute_expression ();
  if (base_register < 0 || base_register > 31)
    {
      base_register = GP;
      as_warn ("Bad base register, using $r.", base_register);
    }
  demand_empty_rest_of_line ();
}

static void
s_gprel32 ()
{
  expressionS e;
  char *p;

  SKIP_WHITESPACE ();
  expression (&e);
  switch (e.X_op)
    {
    case O_constant:
      e.X_add_symbol = section_symbol (absolute_section);
      /* fall through */
    case O_symbol:
      e.X_op = O_subtract;
      e.X_op_symbol = gp;
      break;
    default:
      abort ();
    }
  p = frag_more (4);
  memset (p, 0, 4);
  fix_new_exp (frag_now, p - frag_now->fr_literal, 4, &e, 0,
               BFD_RELOC_GPREL32);
}

static void
create_literal_section (secp, name)
     segT *secp;
     const char *name;
{
  segT current_section = now_seg;
  int current_subsec = now_subseg;
  segT new_sec;

  *secp = new_sec = subseg_new (name, 0);
  subseg_set (current_section, current_subsec);
  bfd_set_section_alignment (stdoutput, new_sec, 3);
  bfd_set_section_flags (stdoutput, new_sec,
                         SEC_RELOC | SEC_ALLOC | SEC_LOAD | SEC_READONLY
                         | SEC_DATA);
}

#define create_lita_section() create_literal_section (&lita_sec, ".lita")

static valueT
get_lit8_offset (val)
     bfd_vma val;
{
  valueT retval;
  if (lit8_sec == 0)
    {
      create_literal_section (&lit8_sec, ".lit8");
      lit8_sym = section_symbol (lit8_sec);
    }
  retval = add_to_literal_pool ((symbolS *) 0, val, lit8_sec, 8);
  if (retval >= 0xfff0)
    as_fatal ("overflow in fp literal (.lit8) table");
  return retval;
}

static valueT
get_lit4_offset (val)
     bfd_vma val;
{
  valueT retval;
  if (lit4_sec == 0)
    {
      create_literal_section (&lit4_sec, ".lit4");
      lit4_sym = section_symbol (lit4_sec);
    }
  retval = add_to_literal_pool ((symbolS *) 0, val, lit4_sec, 4);
  if (retval >= 0xfff0)
    as_fatal ("overflow in fp literal (.lit4) table");
  return retval;
}

#define load_insn(NAME, OP)     (hash_insert (op_hash, (NAME), (PTR) (OP)))

static void
load_insn_table (ops, size)
     struct alpha_opcode *ops;
     int size;
{
  struct alpha_opcode *end = ops + size;
  struct alpha_opcode *op;
  const char *name;

  for (op = ops; op < end; )
    {
      const char *retval;

      name = op->name;

      retval = load_insn (op->name, op);
      if (retval)
        as_fatal ("internal error: can't hash opcode `%s': %s",
                  op->name, retval);

      do
        op++;
      while (op < end
             && (op->name == name
                 || !strcmp (op->name, name)));
    }
  /* Some opcodes include modifiers of various sorts with a "/mod"
     syntax, like the architecture documentation suggests.  However,
     for use with gcc at least, we also need to access those same
     opcodes without the "/".  */
  for (op = ops; op < end; )
    {
      name = op->name;

      if (strchr (name, '/'))
        {
          const char *name2, *p, *q;

          name2 = xmalloc (strlen (name));
          p = name2;
          q = name;

          while (*q)
            if (*q == '/')
              q++;
            else
              *p++ = *q++;
          *p = 0;
          /* Ignore failures -- the opcode table does duplicate some
             variants in different forms, like "hw_stq" and "hw_st/q".
             Maybe the variants can be eliminated, and this error checking
             restored.  */
          load_insn (name2, op);
        }

      do
        op++;
      while (op < end
             && (op->name == name
                 || !strcmp (op->name, name)));
    }
}

/* This function is called once, at assembler startup time.  It should
   set up all the tables, etc. that the MD part of the assembler will
   need, that can be determined before arguments are parsed.  */
void
md_begin ()
{
  const char *retval;
  int lose = 0;
  unsigned int i = 0;

  op_hash = hash_new ();
  load_insn_table (alpha_opcodes, NUMOPCODES);

  /* Default to 21064 PAL instructions.  */
  if (machine == 0)
    machine = 21064;

  switch (machine)
    {
    case 21064:
    case 21066:
      load_insn_table (alpha_pal21064_opcodes, NUM21064OPCODES);
      break;
    case 21164:
      load_insn_table (alpha_pal21164_opcodes, NUM21164OPCODES);
      break;
    default:
      as_fatal ("palcode set unknown (internal error)");
    }

  lituse_basereg.X_op = O_constant;
  lituse_basereg.X_add_number = 1;
  lituse_byteoff.X_op = O_constant;
  lituse_byteoff.X_add_number = 2;
  lituse_jsr.X_op = O_constant;
  lituse_jsr.X_add_number = 3;

  /* So .sbss will get used for tiny objects.  */
  bfd_set_gp_size (stdoutput, 8);
  create_lita_section ();
  /* For handling the GP, create a symbol that won't be output in the
     symbol table.  We'll edit it out of relocs later.  */
  gp = symbol_new ("<GP value>", lita_sec, 0x8000, &zero_address_frag);
  symbol_remove (gp, &symbol_rootP, &symbol_lastP);
}

int optnum = 1;

static void
emit_insn (insn)
     struct alpha_it *insn;
{
  char *toP;
  int j;

  toP = frag_more (4);

  /* put out the opcode */
  md_number_to_chars (toP, insn->opcode, 4);

  /* put out the symbol-dependent stuff */
  for (j = 0; j < MAX_RELOCS; j++)
    {
      struct reloc_data *r = &insn->reloc[j];
      fixS *f;

      if (r->code != BFD_RELOC_NONE)
        {
          if (r->exp.X_op == O_constant)
            {
              r->exp.X_add_symbol = section_symbol (absolute_section);
              r->exp.X_op = O_symbol;
            }
          f = fix_new_exp (frag_now, (toP - frag_now->fr_literal), 4,
                           &r->exp, r->pcrel, r->code);
        }
      if (r->code == BFD_RELOC_ALPHA_GPDISP_LO16)
        {
          static bit_fixS cookie;
          /* @@ This'll make the range checking in write.c shut up.  */
          f->fx_bit_fixP = &cookie;
        }
    }
}

void
md_assemble (str)
     char *str;
{
  int i, count;
#define MAX_INSNS       5
  struct alpha_it insns[MAX_INSNS];

  count = alpha_ip (str, insns);
  if (count <= 0)
    return;

  for (i = 0; i < count; i++)
    emit_insn (&insns[i]);
}

static inline void
maybe_set_gp (sec)
     asection *sec;
{
  bfd_vma vma;
  if (!sec)
    return;
  vma = bfd_get_section_vma (foo, sec);
  if (vma && vma < alpha_gp_value)
    alpha_gp_value = vma;
}

static void
select_gp_value ()
{
  if (alpha_gp_value != 0)
    abort ();

  /* Get minus-one in whatever width...  */
  alpha_gp_value = 0; alpha_gp_value--;

  /* Select the smallest VMA of these existing sections.  */
  maybe_set_gp (lita_sec);
/* maybe_set_gp (sdata);   Was disabled before -- should we use it?  */
#if 0
  maybe_set_gp (lit8_sec);
  maybe_set_gp (lit4_sec);
#endif

  alpha_gp_value += GP_ADJUSTMENT;

  S_SET_VALUE (gp, alpha_gp_value);

#ifdef DEBUG1
  printf ("Chose GP value of %lx\n", alpha_gp_value);
#endif
}

int
alpha_force_relocation (f)
     fixS *f;
{
  switch (f->fx_r_type)
    {
    case BFD_RELOC_ALPHA_GPDISP_HI16:
    case BFD_RELOC_ALPHA_GPDISP_LO16:
    case BFD_RELOC_ALPHA_LITERAL:
    case BFD_RELOC_ALPHA_LITUSE:
    case BFD_RELOC_GPREL32:
      return 1;
    case BFD_RELOC_ALPHA_HINT:
    case BFD_RELOC_64:
    case BFD_RELOC_32:
    case BFD_RELOC_16:
    case BFD_RELOC_8:
    case BFD_RELOC_23_PCREL_S2:
    case BFD_RELOC_14:
    case BFD_RELOC_26:
      return 0;
    default:
      abort ();
      return 0;
    }
}

int
alpha_fix_adjustable (f)
     fixS *f;
{
  /* Are there any relocation types for which we must generate a reloc
     but we can adjust the values contained within it?  */
  switch (f->fx_r_type)
    {
    case BFD_RELOC_ALPHA_GPDISP_HI16:
    case BFD_RELOC_ALPHA_GPDISP_LO16:
      return 0;
    case BFD_RELOC_GPREL32:
      return 1;
    }
  return !alpha_force_relocation (f);
}

valueT
md_section_align (seg, size)
     segT seg;
     valueT size;
{
#ifdef OBJ_ECOFF
  /* This should probably be handled within BFD, or by pulling the
     number from BFD at least.  */
#define MIN 15
  size += MIN;
  size &= ~MIN;
#endif
  return size;
}

/* Add this thing to the .lita section and produce a LITERAL reloc referring
   to it.  */

/* Are we currently eligible to emit a LITUSE reloc for the literal
   references just generated?  */
static int lituse_pending;

static void
load_symbol_address (reg, insn)
     int reg;
     struct alpha_it *insn;
{
  static symbolS *lita_sym;

  int x;
  addressT reloc_addr;
  valueT retval;
  char *p;
  symbolS *sym;
  valueT addend;

  if (!lita_sym)
    {
      lita_sym = section_symbol (lita_sec);
      S_CLEAR_EXTERNAL (lita_sym);
    }

  retval = add_to_literal_pool (insn->reloc[0].exp.X_add_symbol,
                                insn->reloc[0].exp.X_add_number,
                                lita_sec, 8);

  /* Now emit a LITERAL relocation for the original section.  */
  insn->reloc[0].exp.X_op = O_symbol;
  insn->reloc[0].exp.X_add_symbol = lita_sym;
  insn->reloc[0].exp.X_add_number = retval;
  insn->reloc[0].code = BFD_RELOC_ALPHA_LITERAL;
  lituse_pending = 1;

  if (retval == 0x8000)
    /* Overflow? */
    as_fatal ("overflow in literal (.lita) table");
  x = retval;
  if (addr32)
    insn->opcode = (0xa0000000  /* ldl */
                    | (reg << SA)
                    | (base_register << SB)
                    | (x & 0xffff));
  else
    insn->opcode = (0xa4000000  /* ldq */
                    | (reg << SA)
                    | (base_register << SB)
                    | (x & 0xffff));
  note_gpreg (base_register);
}

/* To load an address with a single instruction,
   emit a LITERAL reloc in this section, and a REFQUAD
   for the .lita section, so that we'll be able to access
   it via $gp:
                lda REG, xx     ->      ldq REG, -32752(gp)
                lda REG, xx+4   ->      ldq REG, -32752(gp)
                                        lda REG, 4(REG)

   The offsets need to start near -0x8000, and the generated LITERAL
   relocations should negate the offset.  I don't completely grok the
   scheme yet.  */

static int
load_expression (reg, insn)
     int reg;
     struct alpha_it *insn;
{
  valueT addend;
  int num_insns = 1;

  if (insn->reloc[0].exp.X_add_symbol->bsym->flags & BSF_SECTION_SYM)
    {
      addend = 0;
    }
  else
    {
      addend = insn->reloc[0].exp.X_add_number;
      insn->reloc[0].exp.X_add_number = 0;
    }
  load_symbol_address (reg, insn);
  if (addend)
    {
      num_insns++;
      {
        valueT x = addend;
        if ((x & ~0x7fff) != 0
            && (x & ~0x7fff) + 0x8000 != 0)
          {
            as_bad ("assembler not prepared to handle constants >16 bits yet");
            addend = 0;
          }
      }
      insn[1].opcode = (0x20000000      /* lda */
                        | (reg << SA)
                        | (reg << SB)
                        | (addend & 0xffff));
      insn[1].reloc[0].code = BFD_RELOC_ALPHA_LITUSE;
      insn[1].reloc[0].exp = lituse_basereg;
      lituse_pending = 0;
    }
  return num_insns;
}

static inline void
getExpression (str, this_insn)
     char *str;
     struct alpha_it *this_insn;
{
  char *save_in;
  segT seg;

#if 0 /* Not converted to bfd yet, and I don't think we need them
         for ECOFF.  Re-adding a.out support will probably require
         them though.  */
  static const struct am {
    char *name;
    bfd_reloc_code_real_type reloc;
  } macro[] = {
    { "hi", RELOC_48_63 },
    { "lo", RELOC_0_15 },
    { "ml", RELOC_16_31 },
    { "mh", RELOC_32_47 },
    { "uhi", RELOC_U_48_63 },
    { "uml", RELOC_U_16_31 },
    { "umh", RELOC_U_32_47 },
    { 0, }
  };

  /* Handle macros: "%macroname(expr)" */
  if (*str == '%')
    {
      struct am *m;
      char *p, *q;

      str++;
      m = &macro[0];
      while (q = m->name)
        {
          p = str;
          while (*q && *p == *q)
            p++, q++;
          if (*q == 0)
            break;
          m++;
        }
      if (q)
        {
          str = p;              /* keep the '(' */
          this_insn->reloc = m->reloc;
        }
    }
#endif

  save_in = input_line_pointer;
  input_line_pointer = str;

  seg = expression (&this_insn->reloc[0].exp);
  /* XXX validate seg and exp, make sure they're reasonable */
  expr_end = input_line_pointer;
  input_line_pointer = save_in;
}

/* All of these should soon be changed to just emit words to the
   output frag...  */
static void
emit_unaligned_io (dir, addr_reg, addr_offset, reg)
     char *dir;
     int addr_reg, reg;
     valueT addr_offset;
{
  char buf[90];
  sprintf (buf, "%sq_u $%d,%ld($%d)", dir, reg, (long) addr_offset, addr_reg);
  md_assemble (buf);
}

static void
emit_load_unal (addr_reg, addr_offset, reg)
     int addr_reg, reg;
     valueT addr_offset;
{
  emit_unaligned_io ("ld", addr_reg, addr_offset, reg);
}

static void
emit_store_unal (addr_reg, addr_offset, reg)
     int addr_reg, reg;
     valueT addr_offset;
{
  emit_unaligned_io ("st", addr_reg, addr_offset, reg);
}

static void
emit_byte_manip_r (op, in, mask, out, mode, which)
     char *op;
{
  char buf[90];
  sprintf (buf, "%s%c%c $%d,$%d,$%d", op, mode, which, in, mask, out);
  md_assemble (buf);
}

static void
emit_extract_r (in, mask, out, mode, which)
{
  emit_byte_manip_r ("ext", in, mask, out, mode, which);
}

static void
emit_insert_r (in, mask, out, mode, which)
{
  emit_byte_manip_r ("ins", in, mask, out, mode, which);
}

static void
emit_mask_r (in, mask, out, mode, which)
{
  emit_byte_manip_r ("msk", in, mask, out, mode, which);
}

static void
emit_sign_extend (reg, size)
{
  char buf[90];
  sprintf (buf, "sll $%d,0x%x,$%d", reg, 64 - size, reg);
  md_assemble (buf);
  sprintf (buf, "sra $%d,0x%x,$%d", reg, 64 - size, reg);
  md_assemble (buf);
}

static void
emit_bis_r (in1, in2, out)
{
  char buf[90];
  sprintf (buf, "bis $%d,$%d,$%d", in1, in2, out);
  md_assemble (buf);
}

/* Note that for now, this function is called recursively (by way of
   calling md_assemble again).  Some of the macros defined as part of
   the assembly language are currently rewritten as sequences of
   strings to be assembled.  See, for example, the handling of "divq".

   For efficiency, this should be fixed someday.  */
static int
alpha_ip (str, insns)
     char *str;
     struct alpha_it insns[];
{
  char *s;
  const char *args;
  char c;
  unsigned long i;
  struct alpha_opcode *pattern;
  char *argsStart;
  unsigned int opcode;
  unsigned int mask;
  int match = 0, num_gen = 1;
  int comma = 0;

  for (s = str;
       islower (*s) || *s == '_' || *s == '/' || *s == '4' || *s == '8';
       ++s)
    ;
  switch (*s)
    {

    case '\0':
      break;

    case ',':
      comma = 1;

      /*FALLTHROUGH*/

    case ' ':
      *s++ = '\0';
      break;

    default:
      as_warn ("Unknown opcode: `%s'", str);
      exit (1);
    }
  if ((pattern = (struct alpha_opcode *) hash_find (op_hash, str)) == NULL)
    {
      as_warn ("Unknown opcode: `%s'", str);
      return -1;
    }
  if (comma)
    *--s = ',';

  argsStart = s;
  for (;;)
    {
      opcode = pattern->match;
      num_gen = 1;
      memset (insns, 0, sizeof (*insns));
      for (i = 0; i < MAX_RELOCS; i++)
        insns[0].reloc[i].code = BFD_RELOC_NONE;
      for (i = 1; i < MAX_INSNS; i++)
        insns[i] = insns[0];

      /* Build the opcode, checking as we go to make sure that the
         operands match.  */
      for (args = pattern->args;; ++args)
        {
          switch (*args)
            {

            case '\0':          /* end of args */
              if (*s == '\0')
                {
                  match = 1;
                }
              break;

            case '+':
              if (*s == '+')
                {
                  ++s;
                  continue;
                }
              if (*s == '-')
                {
                  continue;
                }
              break;

            case '(':           /* these must match exactly */
            case ')':
            case ',':
            case ' ':
            case '0':
              if (*s++ == *args)
                continue;
              break;

            case '1':           /* next operand must be a register */
            case '2':
            case '3':
            case 'r':
            case 'R':
              if (*s++ == '$')
                {
                  switch (c = *s++)
                    {

                    case 'a':   /* $at: as temporary */
                      if (*s++ != 't')
                        goto error;
                      mask = AT;
                      break;

                    case 'g':   /* $gp: base register */
                      if (*s++ != 'p')
                        goto error;
                      mask = base_register;
                      break;

                    case 's':   /* $sp: stack pointer */
                      if (*s++ != 'p')
                        goto error;
                      mask = SP;
                      break;


                    case 'r':   /* any register */
                      if (!isdigit (c = *s++))
                        {
                          goto error;
                        }
                      /* FALLTHROUGH */
                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                      if (isdigit (*s))
                        {
                          if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
                            {
                              goto error;
                            }
                        }
                      else
                        {
                          c -= '0';
                        }
                      if ((c == GP) && first_32bit_quadrant)
                        c = ZERO;

                      mask = c;
                      break;

                    default:
                      goto error;
                    }
                  note_gpreg (mask);
                  /* Got the register, now figure out where it goes in
                     the opcode.  */
                doregister:
                  switch (*args)
                    {

                    case '1':
                    case 'e':
                      opcode |= mask << SA;
                      continue;

                    case '2':
                    case 'f':
                      opcode |= mask << SB;
                      continue;

                    case '3':
                    case 'g':
                      opcode |= mask;
                      continue;

                    case 'r':
                      opcode |= (mask << SA) | mask;
                      continue;

                    case 'R':   /* ra and rb are the same */
                      opcode |= (mask << SA) | (mask << SB);
                      continue;

                    case 'E':
                      opcode |= (mask << SA) | (mask << SB) | (mask);
                      continue;
                    }
                }
              break;

            case 'e':           /* next operand is a floating point register */
            case 'f':
            case 'g':
            case 'E':
              if (*s++ == '$' && *s++ == 'f' && isdigit (*s))
                {
                  mask = *s++;
                  if (isdigit (*s))
                    {
                      mask = 10 * (mask - '0') + (*s++ - '0');
                      if (mask >= 32)
                        {
                          break;
                        }
                    }
                  else
                    {
                      mask -= '0';
                    }
                  note_fpreg (mask);
                  /* same encoding as gp registers */
                  goto doregister;
                }
              break;

#if 0
            case 'h':           /* bits 16..31 */
              insns[0].reloc = RELOC_16_31;
              goto immediate;
#endif

            case 'l':           /* bits 0..15 */
              insns[0].reloc[0].code = BFD_RELOC_16;
              goto immediate;

            case 'L':           /* 21 bit PC relative immediate */
              insns[0].reloc[0].code = BFD_RELOC_23_PCREL_S2;
              insns[0].reloc[0].pcrel = 1;
              goto immediate;

            case 'i':           /* 14 bit immediate */
              if (OPCODE (opcode) != 0x1a)
                /* Not a jmp variant?? */
                abort ();
              else if (opcode & 0x8000)
                /* ret or jsr_coroutine */
                {
                  insns[0].reloc[0].code = BFD_RELOC_14;
                  insns[0].reloc[0].pcrel = 0;
                }
              else
                /* jmp or jsr */
                {
                  insns[0].reloc[0].code = BFD_RELOC_ALPHA_HINT;
                  insns[0].reloc[0].pcrel = 1;
                }
              goto immediate;

            case 'b':           /* 8 bit immediate */
              insns[0].reloc[0].code = BFD_RELOC_8;
              goto immediate;

            case 'I':           /* 26 bit immediate, for PALcode */
              insns[0].reloc[0].code = BFD_RELOC_26;
              goto immediate;

#if 0
            case 't':           /* 12 bit 0...11 */
              insns[0].reloc = RELOC_0_12;
              goto immediate;

            case '8':           /* 8 bit 0...7 */
              insns[0].reloc = RELOC_0_8;
              goto immediate;

            case 'I':           /* 26 bit immediate */
              insns[0].reloc = RELOC_0_25;
#else
            case 't':
            case '8':
              abort ();
#endif
              /*FALLTHROUGH*/

            immediate:
              if (*s == ' ')
                s++;
              getExpression (s, &insns[0]);
              s = expr_end;
              /* Handle overflow in certain instructions by converting
                 to other instructions.  */
              if (insns[0].reloc[0].code == BFD_RELOC_8
                  && insns[0].reloc[0].exp.X_op == O_constant
                  && (insns[0].reloc[0].exp.X_add_number < 0
                      || insns[0].reloc[0].exp.X_add_number > 0xff))
                {
                  if (OPCODE (opcode) == 0x10
                      && (OP_FCN (opcode) == 0x00       /* addl */
                          || OP_FCN (opcode) == 0x40    /* addl/v */
                          || OP_FCN (opcode) == 0x20    /* addq */
                          || OP_FCN (opcode) == 0x60    /* addq/v */
                          || OP_FCN (opcode) == 0x09    /* subl */
                          || OP_FCN (opcode) == 0x49    /* subl/v */
                          || OP_FCN (opcode) == 0x29    /* subq */
                          || OP_FCN (opcode) == 0x69    /* subq/v */
                          || OP_FCN (opcode) == 0x02    /* s4addl */
                          || OP_FCN (opcode) == 0x22    /* s4addq */
                          || OP_FCN (opcode) == 0x0b    /* s4subl */
                          || OP_FCN (opcode) == 0x2b    /* s4subq */
                          || OP_FCN (opcode) == 0x12    /* s8addl */
                          || OP_FCN (opcode) == 0x32    /* s8addq */
                          || OP_FCN (opcode) == 0x1b    /* s8subl */
                          || OP_FCN (opcode) == 0x3b    /* s8subq */
                      )
                      /* Can we make it fit by negating?  */
                      && -insns[0].reloc[0].exp.X_add_number < 0xff
                      && -insns[0].reloc[0].exp.X_add_number > 0)
                    {
                      opcode ^= 0x120;  /* convert add<=>sub */
                      insns[0].reloc[0].exp.X_add_number *= -1;
                    }
                  else if (at_ok && macro_ok)
                    {
                      /* Constant value supplied, but it's too large.  */
                      char expansion[64];
                      sprintf (expansion, "lda $%d,%d($%d)", AT,
                               insns[0].reloc[0].exp.X_add_number, ZERO);
                      md_assemble (expansion);
                      opcode |= 0x1000 /* use reg */  | (AT << SB);
                      insns[0].reloc[0].code = BFD_RELOC_NONE;
                    }
                  else
                    as_bad ("overflow in 8-bit literal field in `operate' format insn");
                }
              continue;

            case 'F':
              {
                int format, length, mode, i, size;
                char temp[20 /*MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT*/];
                char *err;
                static const char formats[4] = "FGfd";
                bfd_vma bits, offset;
                char *old_input_line_pointer = input_line_pointer;

                input_line_pointer = s;
                SKIP_WHITESPACE ();
                memset (temp, 0, sizeof (temp));
                mode = (opcode >> 26) & 3;
                format = formats[mode];
                err = md_atof (format, temp, &length);
                if (err)
                  {
                    as_bad ("Bad floating literal: %s", err);
                    bits = 0;
                  }
                else
                  {
                    /* Generate little-endian number from byte sequence.  */
                    bits = 0;
                    for (i = length - 1; i >= 0; i--)
                      bits += ((bfd_vma)(temp[i] & 0xff)) << (i * 8);
                  }
                switch (length)
                  {
                  case 8:
                    offset = get_lit8_offset (bits) - 0x8000;
                    insns[0].reloc[0].exp.X_add_symbol = lit8_sym;
                    insns[0].reloc[0].exp.X_add_number = 0x8000;
                    break;
                  case 4:
                    offset = get_lit4_offset (bits) - 0x8000;
                    insns[0].reloc[0].exp.X_add_symbol = lit4_sym;
                    insns[0].reloc[0].exp.X_add_number = 0x8000;
                    break;
                  default:
                    abort ();
                  }
                insns[0].reloc[0].exp.X_op = O_symbol;
                offset &= 0xffff;
                num_gen = load_expression (AT, &insns[0]);
                if (lituse_pending)
                  {
                    insns[num_gen].reloc[0].code = BFD_RELOC_ALPHA_LITUSE;
                    insns[num_gen].reloc[0].exp = lituse_basereg;
                    lituse_pending = 0;
                  }
                insns[num_gen++].opcode = opcode | (AT << SB) | offset;
                opcode = insns[0].opcode;
                s = input_line_pointer;
                input_line_pointer = old_input_line_pointer;
              }
              continue;

              /* The following two.. take advantage of the fact that
                 opcode already contains most of what we need to know.
                 We just prepend to the instr an "ldah
                 $r,%ml(expr)($base)" and turn this one (done later
                 after we return) into something like "stq
                 $r,%lo(expr)(at)" or "ldq $r,%lo(expr)($r)".

                 NOTE: This can fail later on at link time if the
                 offset from $base actually turns out to be more than
                 2**31 or 2**47 if use_large_offsets is set.  */
            case 'P':           /* Addressing macros: PUT */
              mask = AT;        /* register 'at' */
              /* fall through */

            case 'G':           /* Addressing macros: GET */
            get_macro:
              /* All it is missing is the expression, which is what we
                 will get now */

              if (*s == ' ')
                s++;
              getExpression (s, &insns[0]);
              s = expr_end;

              /* Must check for "lda ..,number" too */
              if (insns[0].reloc[0].exp.X_op == O_big)
                {
                  as_warn ("Sorry, not yet. Put bignums in .data section yourself.");
                  return -1;
                }
              if (insns[0].reloc[0].exp.X_op == O_constant)
                {
                  /* This only handles 32bit numbers */
                  register int val = insns[0].reloc[0].exp.X_add_number;
                  register short sval;

                  insns[0].reloc[0].code = BFD_RELOC_NONE;
                  insns[1].reloc[0].code = BFD_RELOC_NONE;

                  sval = val;
                  if ((sval != val) && (val & 0x8000))
                    {
                      val += 0x10000;
                      sval = val;
                    }

                  if (optnum && (sval == val))
                    {
                      /* optimize away the ldah */
                      num_gen = 1;
                      opcode |= (ZERO << SB) | (val & 0xffff);
                    }
                  else
                    {
                      num_gen = 2;
                      insns[1].opcode = opcode | (mask << SB) | (val & 0xffff);
                      opcode = 0x24000000 /*ldah*/  |
                        mask << SA | (ZERO << SB) |
                        ((val >> 16) & 0xffff);
                    }
                }
              else if (insns[0].reloc[0].exp.X_op == O_symbol)
                {
                  unsigned long old_opcode = opcode;
                  int tmp_reg;

                  if (!macro_ok)
                    as_bad ("insn requires expansion but `nomacro' specified");
                  else if (*args == 'G')
                    tmp_reg = mask;
                  else if (!at_ok)
                    as_bad ("insn expansion requires AT use, but `noat' specified");
                  else
                    tmp_reg = AT;
                  num_gen = load_expression (tmp_reg, insns);
                  opcode = insns[0].opcode;
                  /* lda is opcode 8, 0x20000000, and the macros that use
                     this code have an opcode field of 0.  The latter
                     require further processing, and we don't have the
                     true opcode here.  */
                  if (OPCODE (old_opcode) != 0
                      && OPCODE (old_opcode) != 0x08)
                    {
                      struct alpha_it *i;
                      i = &insns[num_gen++];
                      i->opcode = old_opcode | (tmp_reg << SB);

                      if (lituse_pending)
                        {
                          i->reloc[0].code = BFD_RELOC_ALPHA_LITUSE;
                          i->reloc[0].exp = lituse_basereg;
                          lituse_pending = 0;
                        }
                    }
                }
              else
                {
                  /* Not a number */
                  num_gen = 2;
                  insns[1].reloc[0].exp = insns[0].reloc[0].exp;

                  /* Generate: ldah REG,x1(GP); OP ?,x0(REG) */

                  abort ();     /* relocs need fixing */
#if 0
                  insns[1].reloc = RELOC_0_15;
                  insns[1].opcode = opcode | mask << SB;

                  insns[0].reloc = RELOC_16_31;
                  opcode = 0x24000000 /*ldah*/  | mask << SA | (base_register << SB);
#endif
                }

              continue;

              /* Same failure modes as above, actually most of the
                 same code shared.  */
            case 'B':           /* Builtins */
              args++;
              switch (*args)
                {

                case 'a':       /* ldgp */

                  if (first_32bit_quadrant || no_mixed_code)
                    return -1;
                  switch (OUTPUT_FLAVOR)
                    {
                    case bfd_target_aout_flavour:
                      /* this is cmu's a.out version */
                      insns[0].reloc[0].code = BFD_RELOC_NONE;
                      /* generate "zap %r,0xf,%r" to take high 32 bits */
                      opcode |= 0x48001600 /* zap ?,#,?*/  | (0xf << SN);
                      break;
                    case bfd_target_ecoff_flavour:
                      /* Given "ldgp R1,N(R2)", turn it into something
                         like "ldah R1,###(R2) ; lda R1,###(R1)" with
                         appropriate constants and relocations.  */
                      {
                        unsigned long r1, r2;
                        unsigned long addend = 0;

                        num_gen = 2;
                        r2 = mask;
                        r1 = opcode & 0x3f;
                        insns[0].reloc[0].code = BFD_RELOC_ALPHA_GPDISP_HI16;
                        insns[0].reloc[0].pcrel = 1;
                        insns[0].reloc[0].exp.X_op = O_symbol;
                        insns[0].reloc[0].exp.X_add_symbol = gp;
                        insns[0].reloc[0].exp.X_add_number = 0;
                        insns[0].opcode = (0x24000000   /* ldah */
                                           | (r1 << SA)
                                           | (r2 << SB));
                        insns[1].reloc[0].code = BFD_RELOC_ALPHA_GPDISP_LO16;
                        insns[1].reloc[0].exp.X_op = O_symbol;
                        insns[1].reloc[0].exp.X_add_symbol = gp;
                        insns[1].reloc[0].exp.X_add_number = 4;
                        insns[1].reloc[0].pcrel = 1;
                        insns[1].opcode = 0x20000000 | (r1 << SA) | (r1 << SB);
                        opcode = insns[0].opcode;
                        /* merge in addend */
                        insns[1].opcode |= addend & 0xffff;
                        insns[0].opcode |= ((addend >> 16)
                                            + (addend & 0x8000 ? 1 : 0));
                        if (r2 == PV)
                          ecoff_set_gp_prolog_size (0);
                      }
                      break;
                    default:
                      abort ();
                    }
                  continue;


                case 'b':       /* setgp */
                  switch (OUTPUT_FLAVOR)
                    {
                    case bfd_target_aout_flavour:
                      /* generate "zap %r,0xf,$gp" to take high 32 bits */
                      opcode |= 0x48001600      /* zap ?,#,?*/
                        | (0xf << SN) | (base_register);
                      break;
                    default:
                      abort ();
                    }
                  continue;

                case 'c':       /* jsr $r,foo  becomes
                                        lda $27,foo
                                        jsr $r,($27),foo
                                   Register 27, t12, is used by convention
                                   here.  */
                  {
                    struct alpha_it *jsr;
                    expressionS etmp;
                    struct reloc_data *r;

                    /* We still have to parse the function name */
                    if (*s == ' ')
                      s++;
                    getExpression (s, &insns[0]);
                    etmp = insns[0].reloc[0].exp;
                    s = expr_end;
                    num_gen = load_expression (PV, &insns[0]);
                    note_gpreg (PV);

                    jsr = &insns[num_gen++];
                    jsr->opcode = (0x68004000   /* jsr */
                                   | (mask << SA)
                                   | (PV << SB)
                                   | 0);
                    if (lituse_pending)
                      {
                        /* LITUSE wasn't emitted yet */
                        jsr->reloc[0].code = BFD_RELOC_ALPHA_LITUSE;
                        jsr->reloc[0].exp = lituse_jsr;
                        r = &jsr->reloc[1];
                        lituse_pending = 0;
                      }
                    else
                      r = &jsr->reloc[0];
                    r->exp = etmp;
                    r->code = BFD_RELOC_ALPHA_HINT;
                    r->pcrel = 1;
                    opcode = insns[0].opcode;
                  }
                  continue;

                case 'd':
                  /* Sub-word loads and stores.  We load the address into
                     $at, which might involve using the `P' parameter
                     processing too, then emit a sequence to get the job
                     done, using unaligned memory accesses and byte
                     manipulation, with t9 and t10 as temporaries.  */
                  {
                    /* Characteristics of access.  */
                    int is_load, is_unsigned = 0, is_unaligned = 0;
                    int mode_size, mode;
                    /* Register operand.  */
                    int reg;
                    /* Addend for loads and stores.  */
                    valueT addend;
                    /* Which register do we use for the address?  */
                    int addr;

                    {
                      /* Pick apart name and set flags.  */
                      char *s = pattern->name;

                      if (*s == 'u')
                        {
                          is_unaligned = 1;
                          s++;
                        }

                      if (s[0] == 'l' && s[1] == 'd')
                        is_load = 1;
                      else if (s[0] == 's' && s[1] == 't')
                        is_load = 0;
                      else
                        as_fatal ("unrecognized sub-word access insn `%s'",
                                  str);
                      s += 2;

                      mode = *s++;
                      if (mode == 'b') mode_size = 1;
                      else if (mode == 'w') mode_size = 2;
                      else if (mode == 'l') mode_size = 4;
                      else if (mode == 'q') mode_size = 8;
                      else abort ();

                      if (*s == 'u')
                        {
                          is_unsigned = 1;
                          s++;
                        }

                      assert (*s == 0);

                      /* Longwords are always kept sign-extended.  */
                      if (mode == 'l' && is_unsigned)
                        abort ();
                      /* There's no special unaligned byte handling.  */
                      if (mode == 'b' && is_unaligned)
                        abort ();
                      /* Stores don't care about signedness.  */
                      if (!is_load && is_unsigned)
                        abort ();
                    }

                    if (args[-2] == 'P')
                      {
                        addr = AT;
                        addend = 0;
                      }
                    else
                      {
                        /* foo r1,num(r2)
                           r2 -> mask
                           r1 -> (opcode >> SA) & 31
                           num -> insns->reloc[0].*

                           We want to emit "lda at,num(r2)", since these
                           operations require the use of a single register
                           with the starting address of the memory operand
                           we want to access.

                           We could probably get away without doing this
                           (and use r2 below, with the addend for the
                           actual reads and writes) in cases where the
                           addend is known to be a multiple of 8.  */
                        int r2 = mask;
                        int r1 = (opcode >> SA) & 31;

                        if (insns[0].reloc[0].code == BFD_RELOC_NONE)
                          addend = 0;
                        else if (insns[0].reloc[0].code == BFD_RELOC_16)
                          {
                            if (insns[0].reloc[0].exp.X_op != O_constant)
                              abort ();
                            addend = insns[0].reloc[0].exp.X_add_number;
                          }
                        else
                          abort ();

                        if (addend + mode_size - 1 < 0x7fff
                            && (addend % 8) == 0
                            && (r2 < T9 || r2 > T12))
                          {
                            addr = r2;
                            num_gen = 0;
                          }
                        else
                          {
                            /* Let later relocation processing deal
                               with the addend field.  */
                            insns[num_gen-1].opcode = (0x20000000 /* lda */
                                                       | (AT << SA)
                                                       | (r2 << SB));
                            addr = AT;
                            addend = 0;
                          }
                        reg = r1;
                      }

                    /* Because the emit_* routines append directly to
                       the current frag, we now need to flush any
                       pending insns.  */
                    {
                      int i;
                      for (i = 0; i < num_gen; i++)
                        emit_insn (&insns[i]);
                      num_gen = 0;
                    }

                    if (is_load)
                      {
                        int reg2, reg3;

                        if (is_unaligned)
                          reg2 = T9, reg3 = T10;
                        else
                          reg2 = reg;

                        emit_load_unal (addr, addend, T9);
                        if (is_unaligned)
                          emit_load_unal (addr, addend + mode_size - 1, T10);
                        emit_extract_r (T9, addr, reg2, mode, 'l');
                        if (is_unaligned)
                          {
                            emit_extract_r (T10, addr, reg3, mode, 'h');
                            emit_bis_r (T9, T10, reg);
                          }
                        if (!is_unsigned)
                          emit_sign_extend (reg, mode_size * 8);
                      }
                    else
                      {
                        /* The second word gets processed first
                           because if the address does turn out to be
                           aligned, the processing for the second word
                           will be pushing around all-zeros, and the
                           entire value will be handled as the `first'
                           word.  So we want to store the `first' word
                           last.  */
                        /* Pair these up so that the memory loads get
                           separated from each other, as well as being
                           well in advance of the uses of the values
                           loaded.  */
                        if (is_unaligned)
                          {
                            emit_load_unal (addr, addend + mode_size - 1, T11);
                            emit_insert_r (reg, addr, T12, mode, 'h');
                          }
                        emit_load_unal (addr, addend, T9);
                        emit_insert_r (reg, addr, T10, mode, 'l');
                        if (is_unaligned)
                          emit_mask_r (T12, addr, T12, mode, 'h');
                        emit_mask_r (T10, addr, T10, mode, 'l');
                        if (is_unaligned)
                          emit_bis_r (T11, T12, T11);
                        emit_bis_r (T9, T10, T9);
                        if (is_unaligned)
                          emit_store_unal (addr, addend + mode_size - 1, T11);
                        emit_store_unal (addr, addend, T9);
                      }
                  }
                  return 0;

                  /* DIVISION and MODULUS. Yech.
                       Convert  OP x,y,result
                       to       mov x,t10
                                mov y,t11
                                jsr t9, __OP
                                mov t12,result

                       with appropriate optimizations if t10,t11,t12
                       are the registers specified by the compiler.
                       We are missing an obvious optimization
                       opportunity here; if the ldq generated by the
                       jsr assembly requires a cycle or two to make
                       the value available, initiating it before one
                       or two of the mov instructions would result in
                       faster execution.  */
                case '0':       /* reml */
                case '1':       /* divl */
                case '2':       /* remq */
                case '3':       /* divq */
                case '4':       /* remlu */
                case '5':       /* divlu */
                case '6':       /* remqu */
                case '7':       /* divqu */
                  {
                    static char func[8][6] = {
                      "reml", "divl", "remq", "divq",
                      "remlu", "divlu", "remqu", "divqu"
                    };
                    char expansion[64];
                    int reg;

                    /* All regs parsed, in opcode */

                    /* Do the expansions, one instr at a time */

                    reg = (opcode >> SA) & 31;
                    if (reg != T10)
                      {
                        /* x->t10 */
                        sprintf (expansion, "mov $%d,$%d", reg, T10);
                        md_assemble (expansion);
                      }
                    reg = (opcode >> SB) & 31;
                    if (reg == T10)
                      /* we already overwrote it! */
                      abort ();
                    else if (reg != T11)
                      {
                        /* y->t11 */
                        sprintf (expansion, "mov $%d,$%d", reg, T11);
                        md_assemble (expansion);
                      }
                    sprintf (expansion, "lda $%d,__%s", PV, func[*args - '0']);
                    md_assemble (expansion);
                    sprintf (expansion, "jsr $%d,($%d),__%s", T9, PV,
                             func[*args - '0']);
                    md_assemble (expansion);
#if 0 /* huh? */
                    if (!first_32bit_quadrant)
                      {
                        sprintf (expansion,
                                 "zap $%d,0xf,$%d",
                                 T9, base_register);
                        md_assemble (expansion);
                      }
#endif
                    sprintf (expansion, "ldgp $%d,0($%d)",
                             base_register, T9);
                    md_assemble (expansion);

                    /* Use insns[0] to get at the result */
                    if ((reg = (opcode & 31)) != PV)
                      opcode = (0x47e00400      /* or zero,zero,zero */
                                | (PV << SB)
                                | reg /* Rc */ );       /* pv->z */
                    else
                      num_gen = 0;
                  }
                  continue;
                }
              /* fall through */

            default:
              abort ();
            }
          break;
        }
    error:
      if (match == 0)
        {
          /* Args don't match.  */
          if (&pattern[1] - alpha_opcodes < NUMOPCODES
              && !strcmp (pattern->name, pattern[1].name))
            {
              ++pattern;
              s = argsStart;
              continue;
            }
          else
            {
              as_warn ("Illegal operands");
              return -1;
            }
        }
      else
        {
          /* Args match, see if a float instructions and -nofloats */
          if (nofloats && pattern->isa_float)
            return -1;
        }
      break;
    }

  insns[0].opcode = opcode;
  return num_gen;
}

/* 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 (), *vax_md_atof ();

  switch (type)
    {
      /* VAX floats */
    case 'G':
      /* VAX md_atof doesn't like "G" for some reason.  */
      type = 'g';
    case 'F':
    case 'D':
      return vax_md_atof (type, litP, sizeP);

      /* IEEE floats */
    case 'f':
      prec = 2;
      break;

    case 'd':
      prec = 4;
      break;

    case 'x':
    case 'X':
      prec = 6;
      break;

    case 'p':
    case 'P':
      prec = 6;
      break;

    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 (wordP = words + prec - 1; prec--;)
    {
      md_number_to_chars (litP, (long) (*wordP--), sizeof (LITTLENUM_TYPE));
      litP += sizeof (LITTLENUM_TYPE);
    }

  return 0;
}

void
md_bignum_to_chars (buf, bignum, nchars)
     char *buf;
     LITTLENUM_TYPE *bignum;
     int nchars;
{
  while (nchars)
    {
      LITTLENUM_TYPE work = *bignum++;
      int nb = CHARS_PER_LITTLENUM;

      do
        {
          *buf++ = work & ((1 << BITS_PER_CHAR) - 1);
          if (--nchars == 0)
            return;
          work >>= BITS_PER_CHAR;
        }
      while (--nb);
    }
}

int
md_parse_option (argP, cntP, vecP)
     char **argP;
     int *cntP;
     char ***vecP;
{
  if (**argP == 'F')
    {
      nofloats = 1;
      return 1;
    }
#if 0 /* I have no idea if this stuff would work any more.  And it's
         probably not right for ECOFF anyways.  */
  /* Use base-register addressing, e.g. PIC code */
  if (**argP == 'B')
    {
      if (first_32bit_quadrant)
        {
          first_32bit_quadrant = 0;
          base_register = GP;
        }
      else
        {
          first_32bit_quadrant = 1;
          base_register = ZERO;
        }
      if (argP[0][1] == 'k')
        no_mixed_code = 1;
      argP[0][1] = 0;
      return 1;
    }
#endif
  if (!strcmp (*argP, "32addr"))
    {
      addr32 = 1;
      *argP += 6;
      return 1;
    }
  if (!strcmp (*argP, "nocpp"))
    {
      *argP += 5;
      return 1;
    }
  if (**argP == 'm')
    {
      unsigned long mach;

      (*argP)++;
      if (!strcmp (*argP, "21064"))
        mach = 21064;
      else if (!strcmp (*argP, "21066"))
        mach = 21066;
      else if (!strcmp (*argP, "21164"))
        mach = 21164;
      else
        {
          mach = 0;
          (*argP)--;
          return 0;
        }
      (*argP) += 5;

      if (machine != 0 && machine != mach)
        {
          as_warn ("machine type %lu already chosen, overriding with %lu",
                   machine, mach);
        }
      machine = mach;

      return 1;
    }
  return 0;
}

static void
s_proc (is_static)
{
  /* XXXX Align to cache linesize XXXXX */
  char *name;
  char c;
  char *p;
  symbolS *symbolP;
  int temp;

  /* Takes ".proc name,nargs"  */
  name = input_line_pointer;
  c = get_symbol_end ();
  p = input_line_pointer;
  symbolP = symbol_find_or_make (name);
  *p = c;
  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      *p = 0;
      as_warn ("Expected comma after name \"%s\"", name);
      *p = c;
      temp = 0;
      ignore_rest_of_line ();
    }
  else
    {
      input_line_pointer++;
      temp = get_absolute_expression ();
    }
  /*  symbolP->sy_other = (signed char) temp; */
  as_warn ("unhandled: .proc %s,%d", name, temp);
  demand_empty_rest_of_line ();
}

static void
s_alpha_set (x)
     int x;
{
  char *name = input_line_pointer, ch, *s;
  int yesno = 1;

  while (!is_end_of_line[(unsigned char) *input_line_pointer])
    input_line_pointer++;
  ch = *input_line_pointer;
  *input_line_pointer = '\0';

  s = name;
  if (s[0] == 'n' && s[1] == 'o')
    {
      yesno = 0;
      s += 2;
    }
  if (!strcmp ("reorder", s))
    /* ignore */ ;
  else if (!strcmp ("at", s))
    at_ok = yesno;
  else if (!strcmp ("macro", s))
    macro_ok = yesno;
  else
    as_warn ("Tried to set unrecognized symbol: %s", name);
  *input_line_pointer = ch;
  demand_empty_rest_of_line ();
}

/* @@ Is this right?? */
long
md_pcrel_from (fixP)
     fixS *fixP;
{
  valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
  switch (fixP->fx_r_type)
    {
    case BFD_RELOC_ALPHA_GPDISP_HI16:
    case BFD_RELOC_ALPHA_GPDISP_LO16:
      return addr;
    default:
      return fixP->fx_size + addr;
    }
}

int
alpha_do_align (n, fill)
     int n;
     char *fill;
{
  if (!fill
      && (now_seg == text_section
          || !strcmp (now_seg->name, ".init")
          || !strcmp (now_seg->name, ".fini")))
    {
      static const unsigned char nop_pattern[] = { 0x1f, 0x04, 0xff, 0x47 };
      frag_align_pattern (n, nop_pattern, sizeof (nop_pattern));
      return 1;
    }
  return 0;
}

int
md_apply_fix (fixP, valueP)
     fixS *fixP;
     valueT *valueP;
{
  valueT value;
  int size;
  valueT addend;
  char *p = fixP->fx_frag->fr_literal + fixP->fx_where;

  value = *valueP;

  switch (fixP->fx_r_type)
    {
      /* The GPDISP relocations are processed internally with a symbol
         referring to the current function; we need to drop in a value
         which, when added to the address of the start of the function,
         gives the desired GP.  */
    case BFD_RELOC_ALPHA_GPDISP_HI16:
    case BFD_RELOC_ALPHA_GPDISP_LO16:
      addend = value;
      if (fixP->fx_r_type == BFD_RELOC_ALPHA_GPDISP_HI16)
        {
          assert (fixP->fx_next->fx_r_type == BFD_RELOC_ALPHA_GPDISP_LO16);
#ifdef DEBUG1
          printf ("hi16: ");
          fprintf_vma (stdout, addend);
          printf ("\n");
#endif
          if (addend & 0x8000)
            addend += 0x10000;
          addend >>= 16;
          fixP->fx_offset = 4;  /* @@ Compute this using fx_next.  */
        }
      else
        {
#ifdef DEBUG1
          printf ("lo16: ");
          fprintf_vma (stdout, addend);
          printf ("\n");
#endif
          addend &= 0xffff;
          fixP->fx_offset = 0;
        }
      md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
                          addend, 2);
      fixP->fx_addsy = section_symbol (absolute_section);
      fixP->fx_offset += fixP->fx_frag->fr_address + fixP->fx_where;
      break;

    case BFD_RELOC_8:
      /* Write 8 bits, shifted left 13 bit positions.  */
      value &= 0xff;
      p++;
      *p &= 0x1f;
      *p |= (value << 5) & 0xe0;
      value >>= 3;
      p++;
      *p &= 0xe0;
      *p |= value;
      value >>= 5;
      fixP->fx_done = 1;
    check_zov:
      if (value != 0)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                      "overflow in type-%d reloc", (int) fixP->fx_r_type);
      return 3;

    case BFD_RELOC_32:
      size = 4;
      goto do_it;
    case BFD_RELOC_64:
      size = 8;
      goto do_it;
    case BFD_RELOC_16:
      /* Don't want overflow checking.  */
      size = 2;
    do_it:
      if (fixP->fx_pcrel == 0
          && fixP->fx_addsy == 0)
        {
          md_number_to_chars (p, value, size);
          /* @@ Overflow checks??  */
          goto done;
        }
      break;

    case BFD_RELOC_26:
      if (fixP->fx_addsy != 0
          && fixP->fx_addsy->bsym->section != absolute_section)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                      "PALcode instructions require immediate constant function code");
      else if (value >> 26 != 0)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                      "overflow in 26-bit PALcode function field");
      *p++ = value & 0xff;
      value >>= 8;
      *p++ = value & 0xff;
      value >>= 8;
      *p++ = value & 0xff;
      value >>= 8;
      {
        char x = *p;
        x &= ~3;
        x |= (value & 3);
        *p++ = x;
      }
      goto done;

    case BFD_RELOC_14:
      if (fixP->fx_addsy != 0
          && fixP->fx_addsy->bsym->section != absolute_section)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                  "ret/jsr_coroutine requires constant in displacement field");
      else if (value >> 14 != 0)
        as_bad_where (fixP->fx_file, fixP->fx_line,
                  "overflow in 14-bit operand field of ret or jsr_coroutine");
      *p++ = value & 0xff;
      value >>= 8;
      *p = (*p & 0xc0) | (value & 0x3f);
      goto done;

    case BFD_RELOC_23_PCREL_S2:
      /* Write 21 bits only.  */
      value >>= 2;
      *p++ = value & 0xff;
      value >>= 8;
      *p++ = value & 0xff;
      value >>= 8;
      *p &= 0xe0;
      *p |= (value & 0x1f);
      goto done;

    case BFD_RELOC_ALPHA_LITERAL:
    case BFD_RELOC_ALPHA_LITUSE:
      return 2;

    case BFD_RELOC_GPREL32:
      assert (fixP->fx_subsy == gp);
      value = - alpha_gp_value; /* huh?  this works... */
      fixP->fx_subsy = 0;
      md_number_to_chars (p, value, 4);
      break;

    case BFD_RELOC_ALPHA_HINT:
      if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
        {
          size = 2;
          goto do_it;
        }
      return 2;

    default:
      as_fatal ("unknown relocation type %d?", fixP->fx_r_type);
      return 9;
    }

  if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
    {
      printf ("type %d reloc done?\n", fixP->fx_r_type);
    done:
      fixP->fx_done = 1;
      return 42;
    }

  return 0x12345678;
}

void
alpha_frob_ecoff_data ()
{
  select_gp_value ();
  /* $zero and $f31 are read-only */
  alpha_gprmask &= ~1;
  alpha_fprmask &= ~1;
}

/* The Alpha has support for some VAX floating point types, as well as for
   IEEE floating point.  We consider IEEE to be the primary floating point
   format, and sneak in the VAX floating point support here.  */
#define md_atof vax_md_atof
#include "config/atof-vax.c"