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

/* tc-i960.c - All the i80960-specific stuff
   Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   1999, 2000, 2001, 2002
   Free Software Foundation, Inc.

   This file is part of GAS.

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

/* See comment on md_parse_option for 80960-specific invocation options.  */

/* There are 4 different lengths of (potentially) symbol-based displacements
   in the 80960 instruction set, each of which could require address fix-ups
   and (in the case of external symbols) emission of relocation directives:

   32-bit (MEMB)
        This is a standard length for the base assembler and requires no
        special action.

   13-bit (COBR)
        This is a non-standard length, but the base assembler has a
        hook for bit field address fixups: the fixS structure can
        point to a descriptor of the field, in which case our
        md_number_to_field() routine gets called to process it.

        I made the hook a little cleaner by having fix_new() (in the base
        assembler) return a pointer to the fixS in question.  And I made it a
        little simpler by storing the field size (in this case 13) instead of
        of a pointer to another structure:  80960 displacements are ALWAYS
        stored in the low-order bits of a 4-byte word.

        Since the target of a COBR cannot be external, no relocation
        directives for this size displacement have to be generated.
        But the base assembler had to be modified to issue error
        messages if the symbol did turn out to be external.

   24-bit (CTRL)
        Fixups are handled as for the 13-bit case (except that 24 is stored
        in the fixS).

        The relocation directive generated is the same as that for the 32-bit
        displacement, except that it's PC-relative (the 32-bit displacement
        never is).   The i80960 version of the linker needs a mod to
        distinguish and handle the 24-bit case.

   12-bit (MEMA)
        MEMA formats are always promoted to MEMB (32-bit) if the displacement
        is based on a symbol, because it could be relocated at link time.
        The only time we use the 12-bit format is if an absolute value of
        less than 4096 is specified, in which case we need neither a fixup nor
        a relocation directive.  */

#include <stdio.h>

#include "as.h"

#include "safe-ctype.h"
#include "obstack.h"

#include "opcode/i960.h"

#if defined (OBJ_AOUT) || defined (OBJ_BOUT)

#define TC_S_IS_SYSPROC(s)      ((1<=S_GET_OTHER(s)) && (S_GET_OTHER(s)<=32))
#define TC_S_IS_BALNAME(s)      (S_GET_OTHER(s) == N_BALNAME)
#define TC_S_IS_CALLNAME(s)     (S_GET_OTHER(s) == N_CALLNAME)
#define TC_S_IS_BADPROC(s)      ((S_GET_OTHER(s) != 0) && !TC_S_IS_CALLNAME(s) && !TC_S_IS_BALNAME(s) && !TC_S_IS_SYSPROC(s))

#define TC_S_SET_SYSPROC(s, p)  (S_SET_OTHER((s), (p)+1))
#define TC_S_GET_SYSPROC(s)     (S_GET_OTHER(s)-1)

#define TC_S_FORCE_TO_BALNAME(s)        (S_SET_OTHER((s), N_BALNAME))
#define TC_S_FORCE_TO_CALLNAME(s)       (S_SET_OTHER((s), N_CALLNAME))
#define TC_S_FORCE_TO_SYSPROC(s)        {;}

#else /* ! OBJ_A/BOUT */
#ifdef OBJ_COFF

#define TC_S_IS_SYSPROC(s)      (S_GET_STORAGE_CLASS(s) == C_SCALL)
#define TC_S_IS_BALNAME(s)      (SF_GET_BALNAME(s))
#define TC_S_IS_CALLNAME(s)     (SF_GET_CALLNAME(s))
#define TC_S_IS_BADPROC(s)      (TC_S_IS_SYSPROC(s) && TC_S_GET_SYSPROC(s) < 0 && 31 < TC_S_GET_SYSPROC(s))

#define TC_S_SET_SYSPROC(s, p)  ((s)->sy_symbol.ost_auxent[1].x_sc.x_stindx = (p))
#define TC_S_GET_SYSPROC(s)     ((s)->sy_symbol.ost_auxent[1].x_sc.x_stindx)

#define TC_S_FORCE_TO_BALNAME(s)        (SF_SET_BALNAME(s))
#define TC_S_FORCE_TO_CALLNAME(s)       (SF_SET_CALLNAME(s))
#define TC_S_FORCE_TO_SYSPROC(s)        (S_SET_STORAGE_CLASS((s), C_SCALL))

#else /* ! OBJ_COFF */
#ifdef OBJ_ELF
#define TC_S_IS_SYSPROC(s)      0

#define TC_S_IS_BALNAME(s)      0
#define TC_S_IS_CALLNAME(s)     0
#define TC_S_IS_BADPROC(s)      0

#define TC_S_SET_SYSPROC(s, p)
#define TC_S_GET_SYSPROC(s) 0

#define TC_S_FORCE_TO_BALNAME(s)
#define TC_S_FORCE_TO_CALLNAME(s)
#define TC_S_FORCE_TO_SYSPROC(s)
#else
 #error COFF, a.out, b.out, and ELF are the only supported formats.
#endif /* ! OBJ_ELF */
#endif /* ! OBJ_COFF */
#endif /* ! OBJ_A/BOUT */

extern char *input_line_pointer;

#if !defined (BFD_ASSEMBLER) && !defined (BFD)
#ifdef OBJ_COFF
const int md_reloc_size = sizeof (struct reloc);
#else /* OBJ_COFF */
const int md_reloc_size = sizeof (struct relocation_info);
#endif /* OBJ_COFF */
#endif

/* Local i80960 routines.  */
struct memS;
struct regop;

/* Emit branch-prediction instrumentation code */
static void brcnt_emit PARAMS ((void));
/* Return next branch local label */
static char *brlab_next PARAMS ((void));
/* Generate COBR instruction */
static void cobr_fmt PARAMS ((char *[], long, struct i960_opcode *));
/* Generate CTRL instruction */
static void ctrl_fmt PARAMS ((char *, long, int));
/* Emit (internally) binary */
static char *emit PARAMS ((long));
/* Break arguments out of comma-separated list */
static int get_args PARAMS ((char *, char *[]));
/* Handle COBR or CTRL displacement */
static void get_cdisp PARAMS ((char *, char *, long, int, int, int));
/* Find index specification string */
static char *get_ispec PARAMS ((char *));
/* Translate text to register number */
static int get_regnum PARAMS ((char *));
/* Lexical scan of instruction source */
static int i_scan PARAMS ((char *, char *[]));
/* Generate MEMA or MEMB instruction */
static void mem_fmt PARAMS ((char *[], struct i960_opcode *, int));
/* Convert MEMA instruction to MEMB format */
static void mema_to_memb PARAMS ((char *));
/* Parse an expression */
static void parse_expr PARAMS ((char *, expressionS *));
/* Parse and replace a 'ldconst' pseudo-op */
static int parse_ldconst PARAMS ((char *[]));
/* Parse a memory operand */
static void parse_memop PARAMS ((struct memS *, char *, int));
/* Parse machine-dependent pseudo-op */
static void parse_po PARAMS ((int));
/* Parse a register operand */
static void parse_regop PARAMS ((struct regop *, char *, char));
/* Generate a REG format instruction */
static void reg_fmt PARAMS ((char *[], struct i960_opcode *));
/* "De-optimize" cobr into compare/branch */
static void relax_cobr PARAMS ((fragS *));
/* Process '.leafproc' pseudo-op */
static void s_leafproc PARAMS ((int, char *[]));
/* Process '.sysproc' pseudo-op */
static void s_sysproc PARAMS ((int, char *[]));
/* Will a 'shlo' substiture for a 'ldconst'? */
static int shift_ok PARAMS ((int));
/* Give syntax error */
static void syntax PARAMS ((void));
/* Target chip supports spec-func register? */
static int targ_has_sfr PARAMS ((int));
/* Target chip supports instruction set? */
static int targ_has_iclass PARAMS ((int));

/* See md_parse_option() for meanings of these options */
static char norelax;            /* True if -norelax switch seen */
static char instrument_branches;        /* True if -b switch seen */

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

/* Characters 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 comments started like this one will always work.  */

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 0f12.456 or 0d1.2345e12
 */
const char FLT_CHARS[] = "fFdDtT";

/* Table used by base assembler to relax addresses based on varying length
   instructions.  The fields are:
     1) most positive reach of this state,
     2) most negative reach of this state,
     3) how many bytes this mode will add to the size of the current frag
     4) which index into the table to try if we can't fit into this one.

   For i80960, the only application is the (de-)optimization of cobr
   instructions into separate compare and branch instructions when a 13-bit
   displacement won't hack it.
 */
const relax_typeS md_relax_table[] =
{
  {0, 0, 0, 0},                 /* State 0 => no more relaxation possible */
  {4088, -4096, 0, 2},          /* State 1: conditional branch (cobr) */
  {0x800000 - 8, -0x800000, 4, 0},      /* State 2: compare (reg) & branch (ctrl) */
};

static void s_endian PARAMS ((int));

/* These are the machine dependent pseudo-ops.

   This table describes all the machine specific pseudo-ops the assembler
   has to support.  The fields are:
        pseudo-op name without dot
        function to call to execute this pseudo-op
        integer arg to pass to the function
 */
#define S_LEAFPROC      1
#define S_SYSPROC       2

const pseudo_typeS md_pseudo_table[] =
{
  {"bss", s_lcomm, 1},
  {"endian", s_endian, 0},
  {"extended", float_cons, 't'},
  {"leafproc", parse_po, S_LEAFPROC},
  {"sysproc", parse_po, S_SYSPROC},

  {"word", cons, 4},
  {"quad", cons, 16},

  {0, 0, 0}
};
\f
/* Macros to extract info from an 'expressionS' structure 'e' */
#define adds(e) e.X_add_symbol
#define offs(e) e.X_add_number

/* Branch-prediction bits for CTRL/COBR format opcodes */
#define BP_MASK         0x00000002      /* Mask for branch-prediction bit */
#define BP_TAKEN        0x00000000      /* Value to OR in to predict branch */
#define BP_NOT_TAKEN    0x00000002      /* Value to OR in to predict no branch */

/* Some instruction opcodes that we need explicitly */
#define BE      0x12000000
#define BG      0x11000000
#define BGE     0x13000000
#define BL      0x14000000
#define BLE     0x16000000
#define BNE     0x15000000
#define BNO     0x10000000
#define BO      0x17000000
#define CHKBIT  0x5a002700
#define CMPI    0x5a002080
#define CMPO    0x5a002000

#define B       0x08000000
#define BAL     0x0b000000
#define CALL    0x09000000
#define CALLS   0x66003800
#define RET     0x0a000000

/* These masks are used to build up a set of MEMB mode bits.  */
#define A_BIT           0x0400
#define I_BIT           0x0800
#define MEMB_BIT        0x1000
#define D_BIT           0x2000

/* Mask for the only mode bit in a MEMA instruction (if set, abase reg is
   used).  */
#define MEMA_ABASE      0x2000

/* Info from which a MEMA or MEMB format instruction can be generated */
typedef struct memS
  {
    /* (First) 32 bits of instruction */
    long opcode;
    /* 0-(none), 12- or, 32-bit displacement needed */
    int disp;
    /* The expression in the source instruction from which the
       displacement should be determined.  */
    char *e;
  }
memS;

/* The two pieces of info we need to generate a register operand */
struct regop
  {
    int mode;                   /* 0 =>local/global/spec reg; 1=> literal or fp reg */
    int special;                /* 0 =>not a sfr;  1=> is a sfr (not valid w/mode=0) */
    int n;                      /* Register number or literal value */
  };

/* Number and assembler mnemonic for all registers that can appear in
   operands.  */
static const struct
  {
    char *reg_name;
    int reg_num;
  }
regnames[] =
{
  { "pfp", 0 },
  { "sp", 1 },
  { "rip", 2 },
  { "r3", 3 },
  { "r4", 4 },
  { "r5", 5 },
  { "r6", 6 },
  { "r7", 7 },
  { "r8", 8 },
  { "r9", 9 },
  { "r10", 10 },
  { "r11", 11 },
  { "r12", 12 },
  { "r13", 13 },
  { "r14", 14 },
  { "r15", 15 },
  { "g0", 16 },
  { "g1", 17 },
  { "g2", 18 },
  { "g3", 19 },
  { "g4", 20 },
  { "g5", 21 },
  { "g6", 22 },
  { "g7", 23 },
  { "g8", 24 },
  { "g9", 25 },
  { "g10", 26 },
  { "g11", 27 },
  { "g12", 28 },
  { "g13", 29 },
  { "g14", 30 },
  { "fp", 31 },

  /* Numbers for special-function registers are for assembler internal
     use only: they are scaled back to range [0-31] for binary output.  */
#define SF0     32

  { "sf0", 32 },
  { "sf1", 33 },
  { "sf2", 34 },
  { "sf3", 35 },
  { "sf4", 36 },
  { "sf5", 37 },
  { "sf6", 38 },
  { "sf7", 39 },
  { "sf8", 40 },
  { "sf9", 41 },
  { "sf10", 42 },
  { "sf11", 43 },
  { "sf12", 44 },
  { "sf13", 45 },
  { "sf14", 46 },
  { "sf15", 47 },
  { "sf16", 48 },
  { "sf17", 49 },
  { "sf18", 50 },
  { "sf19", 51 },
  { "sf20", 52 },
  { "sf21", 53 },
  { "sf22", 54 },
  { "sf23", 55 },
  { "sf24", 56 },
  { "sf25", 57 },
  { "sf26", 58 },
  { "sf27", 59 },
  { "sf28", 60 },
  { "sf29", 61 },
  { "sf30", 62 },
  { "sf31", 63 },

  /* Numbers for floating point registers are for assembler internal
     use only: they are scaled back to [0-3] for binary output.  */
#define FP0     64

  { "fp0", 64 },
  { "fp1", 65 },
  { "fp2", 66 },
  { "fp3", 67 },

  { NULL, 0 },                          /* END OF LIST */
};

#define IS_RG_REG(n)    ((0 <= (n)) && ((n) < SF0))
#define IS_SF_REG(n)    ((SF0 <= (n)) && ((n) < FP0))
#define IS_FP_REG(n)    ((n) >= FP0)

/* Number and assembler mnemonic for all registers that can appear as
   'abase' (indirect addressing) registers.  */
static const struct
  {
    char *areg_name;
    int areg_num;
  }
aregs[] =
{
  { "(pfp)", 0 },
  { "(sp)", 1 },
  { "(rip)", 2 },
  { "(r3)", 3 },
  { "(r4)", 4 },
  { "(r5)", 5 },
  { "(r6)", 6 },
  { "(r7)", 7 },
  { "(r8)", 8 },
  { "(r9)", 9 },
  { "(r10)", 10 },
  { "(r11)", 11 },
  { "(r12)", 12 },
  { "(r13)", 13 },
  { "(r14)", 14 },
  { "(r15)", 15 },
  { "(g0)", 16 },
  { "(g1)", 17 },
  { "(g2)", 18 },
  { "(g3)", 19 },
  { "(g4)", 20 },
  { "(g5)", 21 },
  { "(g6)", 22 },
  { "(g7)", 23 },
  { "(g8)", 24 },
  { "(g9)", 25 },
  { "(g10)", 26 },
  { "(g11)", 27 },
  { "(g12)", 28 },
  { "(g13)", 29 },
  { "(g14)", 30 },
  { "(fp)", 31 },

#define IPREL   32
  /* For assembler internal use only: this number never appears in binary
     output.  */
  { "(ip)", IPREL },

  { NULL, 0 },                          /* END OF LIST */
};

/* Hash tables */
static struct hash_control *op_hash;    /* Opcode mnemonics */
static struct hash_control *reg_hash;   /* Register name hash table */
static struct hash_control *areg_hash;  /* Abase register hash table */

/* Architecture for which we are assembling */
#define ARCH_ANY        0       /* Default: no architecture checking done */
#define ARCH_KA         1
#define ARCH_KB         2
#define ARCH_MC         3
#define ARCH_CA         4
#define ARCH_JX         5
#define ARCH_HX         6
int architecture = ARCH_ANY;    /* Architecture requested on invocation line */
int iclasses_seen;              /* OR of instruction classes (I_* constants)
                                 *    for which we've actually assembled
                                 *      instructions.
                                 */

/* BRANCH-PREDICTION INSTRUMENTATION

        The following supports generation of branch-prediction instrumentation
        (turned on by -b switch).  The instrumentation collects counts
        of branches taken/not-taken for later input to a utility that will
        set the branch prediction bits of the instructions in accordance with
        the behavior observed.  (Note that the KX series does not have
        brach-prediction.)

        The instrumentation consists of:

        (1) before and after each conditional branch, a call to an external
            routine that increments and steps over an inline counter.  The
            counter itself, initialized to 0, immediately follows the call
            instruction.  For each branch, the counter following the branch
            is the number of times the branch was not taken, and the difference
            between the counters is the number of times it was taken.  An
            example of an instrumented conditional branch:

                                call    BR_CNT_FUNC
                                .word   0
                LBRANCH23:      be      label
                                call    BR_CNT_FUNC
                                .word   0

        (2) a table of pointers to the instrumented branches, so that an
            external postprocessing routine can locate all of the counters.
            the table begins with a 2-word header: a pointer to the next in
            a linked list of such tables (initialized to 0);  and a count
            of the number of entries in the table (exclusive of the header.

            Note that input source code is expected to already contain calls
            an external routine that will link the branch local table into a
            list of such tables.
 */

/* Number of branches instrumented so far.  Also used to generate
   unique local labels for each instrumented branch.  */
static int br_cnt;

#define BR_LABEL_BASE   "LBRANCH"
/* Basename of local labels on instrumented branches, to avoid
   conflict with compiler- generated local labels.  */

#define BR_CNT_FUNC     "__inc_branch"
/* Name of the external routine that will increment (and step over) an
   inline counter.  */

#define BR_TAB_NAME     "__BRANCH_TABLE__"
/* Name of the table of pointers to branches.  A local (i.e.,
   non-external) symbol.  */
\f
/*****************************************************************************
   md_begin:  One-time initialization.

        Set up hash tables.

  *************************************************************************** */
void
md_begin ()
{
  int i;                        /* Loop counter */
  const struct i960_opcode *oP; /* Pointer into opcode table */
  const char *retval;           /* Value returned by hash functions */

  op_hash = hash_new ();
  reg_hash = hash_new ();
  areg_hash = hash_new ();

  /* For some reason, the base assembler uses an empty string for "no
     error message", instead of a NULL pointer.  */
  retval = 0;

  for (oP = i960_opcodes; oP->name && !retval; oP++)
    retval = hash_insert (op_hash, oP->name, (PTR) oP);

  for (i = 0; regnames[i].reg_name && !retval; i++)
    retval = hash_insert (reg_hash, regnames[i].reg_name,
                          (char *) &regnames[i].reg_num);

  for (i = 0; aregs[i].areg_name && !retval; i++)
    retval = hash_insert (areg_hash, aregs[i].areg_name,
                          (char *) &aregs[i].areg_num);

  if (retval)
    as_fatal (_("Hashing returned \"%s\"."), retval);
}

/*****************************************************************************
   md_assemble:  Assemble an instruction

   Assumptions about the passed-in text:
        - all comments, labels removed
        - text is an instruction
        - all white space compressed to single blanks
        - all character constants have been replaced with decimal

  *************************************************************************** */
void
md_assemble (textP)
     char *textP;               /* Source text of instruction */
{
  /* Parsed instruction text, containing NO whitespace: arg[0]->opcode
     mnemonic arg[1-3]->operands, with char constants replaced by
     decimal numbers.  */
  char *args[4];

  int n_ops;                    /* Number of instruction operands */
  /* Pointer to instruction description */
  struct i960_opcode *oP;
  /* TRUE iff opcode mnemonic included branch-prediction suffix (".f"
     or ".t").  */
  int branch_predict;
  /* Setting of branch-prediction bit(s) to be OR'd into instruction
     opcode of CTRL/COBR format instructions.  */
  long bp_bits;

  int n;                        /* Offset of last character in opcode mnemonic */

  const char *bp_error_msg = _("branch prediction invalid on this opcode");

  /* Parse instruction into opcode and operands */
  memset (args, '\0', sizeof (args));
  n_ops = i_scan (textP, args);
  if (n_ops == -1)
    {
      return;                   /* Error message already issued */
    }

  /* Do "macro substitution" (sort of) on 'ldconst' pseudo-instruction */
  if (!strcmp (args[0], "ldconst"))
    {
      n_ops = parse_ldconst (args);
      if (n_ops == -1)
        {
          return;
        }
    }

  /* Check for branch-prediction suffix on opcode mnemonic, strip it off */
  n = strlen (args[0]) - 1;
  branch_predict = 0;
  bp_bits = 0;
  if (args[0][n - 1] == '.' && (args[0][n] == 't' || args[0][n] == 'f'))
    {
      /* We could check here to see if the target architecture
         supports branch prediction, but why bother?  The bit will
         just be ignored by processors that don't use it.  */
      branch_predict = 1;
      bp_bits = (args[0][n] == 't') ? BP_TAKEN : BP_NOT_TAKEN;
      args[0][n - 1] = '\0';    /* Strip suffix from opcode mnemonic */
    }

  /* Look up opcode mnemonic in table and check number of operands.
     Check that opcode is legal for the target architecture.  If all
     looks good, assemble instruction.  */
  oP = (struct i960_opcode *) hash_find (op_hash, args[0]);
  if (!oP || !targ_has_iclass (oP->iclass))
    {
      as_bad (_("invalid opcode, \"%s\"."), args[0]);

    }
  else if (n_ops != oP->num_ops)
    {
      as_bad (_("improper number of operands.  expecting %d, got %d"),
              oP->num_ops, n_ops);
    }
  else
    {
      switch (oP->format)
        {
        case FBRA:
        case CTRL:
          ctrl_fmt (args[1], oP->opcode | bp_bits, oP->num_ops);
          if (oP->format == FBRA)
            {
              /* Now generate a 'bno' to same arg */
              ctrl_fmt (args[1], BNO | bp_bits, 1);
            }
          break;
        case COBR:
        case COJ:
          cobr_fmt (args, oP->opcode | bp_bits, oP);
          break;
        case REG:
          if (branch_predict)
            {
              as_warn (bp_error_msg);
            }
          reg_fmt (args, oP);
          break;
        case MEM1:
          if (args[0][0] == 'c' && args[0][1] == 'a')
            {
              if (branch_predict)
                {
                  as_warn (bp_error_msg);
                }
              mem_fmt (args, oP, 1);
              break;
            }
        case MEM2:
        case MEM4:
        case MEM8:
        case MEM12:
        case MEM16:
          if (branch_predict)
            {
              as_warn (bp_error_msg);
            }
          mem_fmt (args, oP, 0);
          break;
        case CALLJ:
          if (branch_predict)
            {
              as_warn (bp_error_msg);
            }
          /* Output opcode & set up "fixup" (relocation); flag
             relocation as 'callj' type.  */
          know (oP->num_ops == 1);
          get_cdisp (args[1], "CTRL", oP->opcode, 24, 0, 1);
          break;
        default:
          BAD_CASE (oP->format);
          break;
        }
    }
}                               /* md_assemble() */

/*****************************************************************************
   md_number_to_chars:  convert a number to target byte order

  *************************************************************************** */
void
md_number_to_chars (buf, value, n)
     char *buf;
     valueT value;
     int n;
{
  number_to_chars_littleendian (buf, value, n);
}

/*****************************************************************************
   md_chars_to_number:  convert from target byte order to host byte order.

  *************************************************************************** */
static int md_chars_to_number PARAMS ((unsigned char *, int));

static int
md_chars_to_number (val, n)
     unsigned char *val;        /* Value in target byte order */
     int n;                     /* Number of bytes in the input */
{
  int retval;

  for (retval = 0; n--;)
    {
      retval <<= 8;
      retval |= val[n];
    }
  return retval;
}

#define MAX_LITTLENUMS  6
#define LNUM_SIZE       sizeof (LITTLENUM_TYPE)

/*****************************************************************************
   md_atof:     convert ascii to floating point

   Turn a string at input_line_pointer into a floating point constant of type
   'type', and store the appropriate bytes at *litP.  The number of LITTLENUMS
   emitted is returned at 'sizeP'.  An error message is returned, or a pointer
   to an empty message if OK.

   Note we call the i386 floating point routine, rather than complicating
   things with more files or symbolic links.

  *************************************************************************** */
char *
md_atof (type, litP, sizeP)
     int type;
     char *litP;
     int *sizeP;
{
  LITTLENUM_TYPE words[MAX_LITTLENUMS];
  LITTLENUM_TYPE *wordP;
  int prec;
  char *t;

  switch (type)
    {
    case 'f':
    case 'F':
      prec = 2;
      break;

    case 'd':
    case 'D':
      prec = 4;
      break;

    case 't':
    case 'T':
      prec = 5;
      type = 'x';               /* That's what atof_ieee() understands */
      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 * LNUM_SIZE;

  /* Output the LITTLENUMs in REVERSE order in accord with i80960
     word-order.  (Dunno why atof_ieee doesn't do it in the right
     order in the first place -- probably because it's a hack of
     atof_m68k.)  */

  for (wordP = words + prec - 1; prec--;)
    {
      md_number_to_chars (litP, (long) (*wordP--), LNUM_SIZE);
      litP += sizeof (LITTLENUM_TYPE);
    }

  return 0;
}

/*****************************************************************************
   md_number_to_imm

  *************************************************************************** */
static void md_number_to_imm PARAMS ((char *, long, int));

static void
md_number_to_imm (buf, val, n)
     char *buf;
     long val;
     int n;
{
  md_number_to_chars (buf, val, n);
}

/*****************************************************************************
   md_number_to_field:

        Stick a value (an address fixup) into a bit field of
        previously-generated instruction.

  *************************************************************************** */
static void md_number_to_field PARAMS ((char *, long, bit_fixS *));

static void
md_number_to_field (instrP, val, bfixP)
     char *instrP;              /* Pointer to instruction to be fixed */
     long val;                  /* Address fixup value */
     bit_fixS *bfixP;           /* Description of bit field to be fixed up */
{
  int numbits;                  /* Length of bit field to be fixed */
  long instr;                   /* 32-bit instruction to be fixed-up */
  long sign;                    /* 0 or -1, according to sign bit of 'val' */

  /* Convert instruction back to host byte order.  */
  instr = md_chars_to_number (instrP, 4);

  /* Surprise! -- we stored the number of bits to be modified rather
     than a pointer to a structure.  */
  numbits = (int) bfixP;
  if (numbits == 1)
    {
      /* This is a no-op, stuck here by reloc_callj() */
      return;
    }

  know ((numbits == 13) || (numbits == 24));

  /* Propagate sign bit of 'val' for the given number of bits.  Result
     should be all 0 or all 1.  */
  sign = val >> ((int) numbits - 1);
  if (((val < 0) && (sign != -1))
      || ((val > 0) && (sign != 0)))
    {
      as_bad (_("Fixup of %ld too large for field width of %d"),
              val, numbits);
    }
  else
    {
      /* Put bit field into instruction and write back in target
         * byte order.
       */
      val &= ~(-1 << (int) numbits);    /* Clear unused sign bits */
      instr |= val;
      md_number_to_chars (instrP, instr, 4);
    }
}                               /* md_number_to_field() */
\f

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

        -norelax:
                Conditional branch instructions that require displacements
                greater than 13 bits (or that have external targets) should
                generate errors.  The default is to replace each such
                instruction with the corresponding compare (or chkbit) and
                branch instructions.  Note that the Intel "j" cobr directives
                are ALWAYS "de-optimized" in this way when necessary,
                regardless of the setting of this option.

        -b:
                Add code to collect information about branches taken, for
                later optimization of branch prediction bits by a separate
                tool.  COBR and CNTL format instructions have branch
                prediction bits (in the CX architecture);  if "BR" represents
                an instruction in one of these classes, the following rep-
                resents the code generated by the assembler:

                        call    <increment routine>
                        .word   0       # pre-counter
                Label:  BR
                        call    <increment routine>
                        .word   0       # post-counter

                A table of all such "Labels" is also generated.

        -AKA, -AKB, -AKC, -ASA, -ASB, -AMC, -ACA:
                Select the 80960 architecture.  Instructions or features not
                supported by the selected architecture cause fatal errors.
                The default is to generate code for any instruction or feature
                that is supported by SOME version of the 960 (even if this
                means mixing architectures!).

  ****************************************************************************/

const char *md_shortopts = "A:b";
struct option md_longopts[] =
{
#define OPTION_LINKRELAX (OPTION_MD_BASE)
  {"linkrelax", no_argument, NULL, OPTION_LINKRELAX},
  {"link-relax", no_argument, NULL, OPTION_LINKRELAX},
#define OPTION_NORELAX (OPTION_MD_BASE + 1)
  {"norelax", no_argument, NULL, OPTION_NORELAX},
  {"no-relax", no_argument, NULL, OPTION_NORELAX},
  {NULL, no_argument, NULL, 0}
};
size_t md_longopts_size = sizeof (md_longopts);

struct tabentry
  {
    char *flag;
    int arch;
  };
static const struct tabentry arch_tab[] =
{
  {"KA", ARCH_KA},
  {"KB", ARCH_KB},
  {"SA", ARCH_KA},              /* Synonym for KA */
  {"SB", ARCH_KB},              /* Synonym for KB */
  {"KC", ARCH_MC},              /* Synonym for MC */
  {"MC", ARCH_MC},
  {"CA", ARCH_CA},
  {"JX", ARCH_JX},
  {"HX", ARCH_HX},
  {NULL, 0}
};

int
md_parse_option (c, arg)
     int c;
     char *arg;
{
  switch (c)
    {
    case OPTION_LINKRELAX:
      linkrelax = 1;
      flag_keep_locals = 1;
      break;

    case OPTION_NORELAX:
      norelax = 1;
      break;

    case 'b':
      instrument_branches = 1;
      break;

    case 'A':
      {
        const struct tabentry *tp;
        char *p = arg;

        for (tp = arch_tab; tp->flag != NULL; tp++)
          if (!strcmp (p, tp->flag))
            break;

        if (tp->flag == NULL)
          {
            as_bad (_("invalid architecture %s"), p);
            return 0;
          }
        else
          architecture = tp->arch;
      }
      break;

    default:
      return 0;
    }

  return 1;
}

void
md_show_usage (stream)
     FILE *stream;
{
  int i;
  fprintf (stream, _("I960 options:\n"));
  for (i = 0; arch_tab[i].flag; i++)
    fprintf (stream, "%s-A%s", i ? " | " : "", arch_tab[i].flag);
  fprintf (stream, _("\n\
                        specify variant of 960 architecture\n\
-b                      add code to collect statistics about branches taken\n\
-link-relax             preserve individual alignment directives so linker\n\
                        can do relaxing (b.out format only)\n\
-no-relax               don't alter compare-and-branch instructions for\n\
                        long displacements\n"));
}
\f

/*****************************************************************************
   md_convert_frag:
        Called by base assembler after address relaxation is finished:  modify
        variable fragments according to how much relaxation was done.

        If the fragment substate is still 1, a 13-bit displacement was enough
        to reach the symbol in question.  Set up an address fixup, but otherwise
        leave the cobr instruction alone.

        If the fragment substate is 2, a 13-bit displacement was not enough.
        Replace the cobr with a two instructions (a compare and a branch).

  *************************************************************************** */
#ifndef BFD_ASSEMBLER
void
md_convert_frag (headers, seg, fragP)
     object_headers *headers ATTRIBUTE_UNUSED;
     segT seg ATTRIBUTE_UNUSED;
     fragS *fragP;
#else
void
md_convert_frag (abfd, sec, fragP)
     bfd *abfd ATTRIBUTE_UNUSED;
     segT sec ATTRIBUTE_UNUSED;
     fragS *fragP;
#endif
{
  fixS *fixP;                   /* Structure describing needed address fix */

  switch (fragP->fr_subtype)
    {
    case 1:
      /* LEAVE SINGLE COBR INSTRUCTION */
      fixP = fix_new (fragP,
                      fragP->fr_opcode - fragP->fr_literal,
                      4,
                      fragP->fr_symbol,
                      fragP->fr_offset,
                      1,
                      NO_RELOC);

      fixP->fx_bit_fixP = (bit_fixS *) 13;      /* size of bit field */
      break;
    case 2:
      /* REPLACE COBR WITH COMPARE/BRANCH INSTRUCTIONS */
      relax_cobr (fragP);
      break;
    default:
      BAD_CASE (fragP->fr_subtype);
      break;
    }
}

/*****************************************************************************
   md_estimate_size_before_relax:  How much does it look like *fragP will grow?

        Called by base assembler just before address relaxation.
        Return the amount by which the fragment will grow.

        Any symbol that is now undefined will not become defined; cobr's
        based on undefined symbols will have to be replaced with a compare
        instruction and a branch instruction, and the code fragment will grow
        by 4 bytes.

  *************************************************************************** */
int
md_estimate_size_before_relax (fragP, segment_type)
     register fragS *fragP;
     register segT segment_type;
{
  /* If symbol is undefined in this segment, go to "relaxed" state
     (compare and branch instructions instead of cobr) right now.  */
  if (S_GET_SEGMENT (fragP->fr_symbol) != segment_type)
    {
      relax_cobr (fragP);
      return 4;
    }

  return md_relax_table[fragP->fr_subtype].rlx_length;
}                               /* md_estimate_size_before_relax() */

#if defined(OBJ_AOUT) | defined(OBJ_BOUT)

/*****************************************************************************
   md_ri_to_chars:
        This routine exists in order to overcome machine byte-order problems
        when dealing with bit-field entries in the relocation_info struct.

        But relocation info will be used on the host machine only (only
        executable code is actually downloaded to the i80960).  Therefore,
        we leave it in host byte order.

        The above comment is no longer true.  This routine now really
        does do the reordering (Ian Taylor 28 Aug 92).

  *************************************************************************** */

static void
md_ri_to_chars (where, ri)
     char *where;
     struct relocation_info *ri;
{
  md_number_to_chars (where, ri->r_address,
                      sizeof (ri->r_address));
  where[4] = ri->r_index & 0x0ff;
  where[5] = (ri->r_index >> 8) & 0x0ff;
  where[6] = (ri->r_index >> 16) & 0x0ff;
  where[7] = ((ri->r_pcrel << 0)
              | (ri->r_length << 1)
              | (ri->r_extern << 3)
              | (ri->r_bsr << 4)
              | (ri->r_disp << 5)
              | (ri->r_callj << 6));
}

#endif /* defined(OBJ_AOUT) | defined(OBJ_BOUT) */

\f
/* FOLLOWING ARE THE LOCAL ROUTINES, IN ALPHABETICAL ORDER  */

/*****************************************************************************
   brcnt_emit:  Emit code to increment inline branch counter.

        See the comments above the declaration of 'br_cnt' for details on
        branch-prediction instrumentation.
  *************************************************************************** */
static void
brcnt_emit ()
{
  ctrl_fmt (BR_CNT_FUNC, CALL, 1);      /* Emit call to "increment" routine */
  emit (0);                     /* Emit inline counter to be incremented */
}

/*****************************************************************************
   brlab_next:  generate the next branch local label

        See the comments above the declaration of 'br_cnt' for details on
        branch-prediction instrumentation.
  *************************************************************************** */
static char *
brlab_next ()
{
  static char buf[20];

  sprintf (buf, "%s%d", BR_LABEL_BASE, br_cnt++);
  return buf;
}

/*****************************************************************************
   brtab_emit:  generate the fetch-prediction branch table.

        See the comments above the declaration of 'br_cnt' for details on
        branch-prediction instrumentation.

        The code emitted here would be functionally equivalent to the following
        example assembler source.

                        .data
                        .align  2
           BR_TAB_NAME:
                        .word   0               # link to next table
                        .word   3               # length of table
                        .word   LBRANCH0        # 1st entry in table proper
                        .word   LBRANCH1
                        .word   LBRANCH2
  **************************************************************************** */
void
brtab_emit ()
{
  int i;
  char buf[20];
  char *p;                      /* Where the binary was output to */
  /* Pointer to description of deferred address fixup.  */
  fixS *fixP;

  if (!instrument_branches)
    {
      return;
    }

  subseg_set (data_section, 0); /*      .data */
  frag_align (2, 0, 0);         /*      .align 2 */
  record_alignment (now_seg, 2);
  colon (BR_TAB_NAME);          /* BR_TAB_NAME: */
  emit (0);                     /*      .word 0 #link to next table */
  emit (br_cnt);                /*      .word n #length of table */

  for (i = 0; i < br_cnt; i++)
    {
      sprintf (buf, "%s%d", BR_LABEL_BASE, i);
      p = emit (0);
      fixP = fix_new (frag_now,
                      p - frag_now->fr_literal,
                      4,
                      symbol_find (buf),
                      0,
                      0,
                      NO_RELOC);
    }
}

/*****************************************************************************
   cobr_fmt:    generate a COBR-format instruction

  *************************************************************************** */
static void
cobr_fmt (arg, opcode, oP)
     /* arg[0]->opcode mnemonic, arg[1-3]->operands (ascii) */
     char *arg[];
     /* Opcode, with branch-prediction bits already set if necessary.  */
     long opcode;
     /* Pointer to description of instruction.  */
     struct i960_opcode *oP;
{
  long instr;                   /* 32-bit instruction */
  struct regop regop;           /* Description of register operand */
  int n;                        /* Number of operands */
  int var_frag;                 /* 1 if varying length code fragment should
                                 *    be emitted;  0 if an address fix
                                 *      should be emitted.
                                 */

  instr = opcode;
  n = oP->num_ops;

  if (n >= 1)
    {
      /* First operand (if any) of a COBR is always a register
         operand.  Parse it.  */
      parse_regop (&regop, arg[1], oP->operand[0]);
      instr |= (regop.n << 19) | (regop.mode << 13);
    }
  if (n >= 2)
    {
      /* Second operand (if any) of a COBR is always a register
         operand.  Parse it.  */
    parse_regop (&regop, arg[2], oP->operand[1]);
      instr |= (regop.n << 14) | regop.special;
    }

  if (n < 3)
    {
      emit (instr);

    }
  else
    {
      if (instrument_branches)
        {
          brcnt_emit ();
          colon (brlab_next ());
        }

      /* A third operand to a COBR is always a displacement.  Parse
         it; if it's relaxable (a cobr "j" directive, or any cobr
         other than bbs/bbc when the "-norelax" option is not in use)
         set up a variable code fragment; otherwise set up an address
         fix.  */
      var_frag = !norelax || (oP->format == COJ);       /* TRUE or FALSE */
      get_cdisp (arg[3], "COBR", instr, 13, var_frag, 0);

      if (instrument_branches)
        {
          brcnt_emit ();
        }
    }
}                               /* cobr_fmt() */

/*****************************************************************************
   ctrl_fmt:    generate a CTRL-format instruction

  *************************************************************************** */
static void
ctrl_fmt (targP, opcode, num_ops)
     char *targP;               /* Pointer to text of lone operand (if any) */
     long opcode;               /* Template of instruction */
     int num_ops;               /* Number of operands */
{
  int instrument;               /* TRUE iff we should add instrumentation to track
                                   * how often the branch is taken
                                 */

  if (num_ops == 0)
    {
      emit (opcode);            /* Output opcode */
    }
  else
    {

      instrument = instrument_branches && (opcode != CALL)
        && (opcode != B) && (opcode != RET) && (opcode != BAL);

      if (instrument)
        {
          brcnt_emit ();
          colon (brlab_next ());
        }

      /* The operand MUST be an ip-relative displacment. Parse it
         * and set up address fix for the instruction we just output.
       */
      get_cdisp (targP, "CTRL", opcode, 24, 0, 0);

      if (instrument)
        {
          brcnt_emit ();
        }
    }

}

/*****************************************************************************
   emit:        output instruction binary

        Output instruction binary, in target byte order, 4 bytes at a time.
        Return pointer to where it was placed.

  *************************************************************************** */
static char *
emit (instr)
     long instr;                /* Word to be output, host byte order */
{
  char *toP;                    /* Where to output it */

  toP = frag_more (4);          /* Allocate storage */
  md_number_to_chars (toP, instr, 4);   /* Convert to target byte order */
  return toP;
}

/*****************************************************************************
   get_args:    break individual arguments out of comma-separated list

   Input assumptions:
        - all comments and labels have been removed
        - all strings of whitespace have been collapsed to a single blank.
        - all character constants ('x') have been replaced with decimal

   Output:
        args[0] is untouched. args[1] points to first operand, etc. All args:
        - are NULL-terminated
        - contain no whitespace

   Return value:
        Number of operands (0,1,2, or 3) or -1 on error.

  *************************************************************************** */
static int
get_args (p, args)
     /* Pointer to comma-separated operands; MUCKED BY US */
     register char *p;
     /* Output arg: pointers to operands placed in args[1-3].  MUST
        ACCOMMODATE 4 ENTRIES (args[0-3]).  */
     char *args[];
{
  register int n;               /* Number of operands */
  register char *to;

  /* Skip lead white space */
  while (*p == ' ')
    {
      p++;
    }

  if (*p == '\0')
    {
      return 0;
    }

  n = 1;
  args[1] = p;

  /* Squeze blanks out by moving non-blanks toward start of string.
     * Isolate operands, whenever comma is found.
   */
  to = p;
  while (*p != '\0')
    {

      if (*p == ' '
          && (! ISALNUM (p[1])
              || ! ISALNUM (p[-1])))
        {
          p++;

        }
      else if (*p == ',')
        {

          /* Start of operand */
          if (n == 3)
            {
              as_bad (_("too many operands"));
              return -1;
            }
          *to++ = '\0';         /* Terminate argument */
          args[++n] = to;       /* Start next argument */
          p++;

        }
      else
        {
          *to++ = *p++;
        }
    }
  *to = '\0';
  return n;
}

/*****************************************************************************
   get_cdisp:   handle displacement for a COBR or CTRL instruction.

        Parse displacement for a COBR or CTRL instruction.

        If successful, output the instruction opcode and set up for it,
        depending on the arg 'var_frag', either:
            o an address fixup to be done when all symbol values are known, or
            o a varying length code fragment, with address fixup info.  This
                will be done for cobr instructions that may have to be relaxed
                in to compare/branch instructions (8 bytes) if the final
                address displacement is greater than 13 bits.

  ****************************************************************************/
static void
get_cdisp (dispP, ifmtP, instr, numbits, var_frag, callj)
     /* displacement as specified in source instruction */
     char *dispP;
     /* "COBR" or "CTRL" (for use in error message) */
     char *ifmtP;
     /* Instruction needing the displacement */
     long instr;
     /* # bits of displacement (13 for COBR, 24 for CTRL) */
     int numbits;
     /* 1 if varying length code fragment should be emitted;
      *       0 if an address fix should be emitted.
      */
     int var_frag;
     /* 1 if callj relocation should be done; else 0 */
     int callj;
{
  expressionS e;                /* Parsed expression */
  fixS *fixP;                   /* Structure describing needed address fix */
  char *outP;                   /* Where instruction binary is output to */

  fixP = NULL;

  parse_expr (dispP, &e);
  switch (e.X_op)
    {
    case O_illegal:
      as_bad (_("expression syntax error"));

    case O_symbol:
      if (S_GET_SEGMENT (e.X_add_symbol) == now_seg
          || S_GET_SEGMENT (e.X_add_symbol) == undefined_section)
        {
          if (var_frag)
            {
              outP = frag_more (8);     /* Allocate worst-case storage */
              md_number_to_chars (outP, instr, 4);
              frag_variant (rs_machine_dependent, 4, 4, 1,
                            adds (e), offs (e), outP);
            }
          else
            {
              /* Set up a new fix structure, so address can be updated
               * when all symbol values are known.
               */
              outP = emit (instr);
              fixP = fix_new (frag_now,
                              outP - frag_now->fr_literal,
                              4,
                              adds (e),
                              offs (e),
                              1,
                              NO_RELOC);

              fixP->fx_tcbit = callj;

              /* We want to modify a bit field when the address is
               * known.  But we don't need all the garbage in the
               * bit_fix structure.  So we're going to lie and store
               * the number of bits affected instead of a pointer.
               */
              fixP->fx_bit_fixP = (bit_fixS *) numbits;
            }
        }
      else
        as_bad (_("attempt to branch into different segment"));
      break;

    default:
      as_bad (_("target of %s instruction must be a label"), ifmtP);
      break;
    }
}

/*****************************************************************************
   get_ispec:   parse a memory operand for an index specification

        Here, an "index specification" is taken to be anything surrounded
        by square brackets and NOT followed by anything else.

        If it's found, detach it from the input string, remove the surrounding
        square brackets, and return a pointer to it.  Otherwise, return NULL.

  *************************************************************************** */
static char *
get_ispec (textP)
     /* Pointer to memory operand from source instruction, no white space.  */
     char *textP;
{
  /* Points to start of index specification.  */
  char *start;
  /* Points to end of index specification.  */
  char *end;

  /* Find opening square bracket, if any.  */
  start = strchr (textP, '[');

  if (start != NULL)
    {

      /* Eliminate '[', detach from rest of operand */
      *start++ = '\0';

      end = strchr (start, ']');

      if (end == NULL)
        {
          as_bad (_("unmatched '['"));

        }
      else
        {
          /* Eliminate ']' and make sure it was the last thing
             * in the string.
           */
          *end = '\0';
          if (*(end + 1) != '\0')
            {
              as_bad (_("garbage after index spec ignored"));
            }
        }
    }
  return start;
}

/*****************************************************************************
   get_regnum:

        Look up a (suspected) register name in the register table and return the
        associated register number (or -1 if not found).

  *************************************************************************** */
static int
get_regnum (regname)
     char *regname;             /* Suspected register name */
{
  int *rP;

  rP = (int *) hash_find (reg_hash, regname);
  return (rP == NULL) ? -1 : *rP;
}

/*****************************************************************************
   i_scan:      perform lexical scan of ascii assembler instruction.

   Input assumptions:
        - input string is an i80960 instruction (not a pseudo-op)
        - all comments and labels have been removed
        - all strings of whitespace have been collapsed to a single blank.

   Output:
        args[0] points to opcode, other entries point to operands. All strings:
        - are NULL-terminated
        - contain no whitespace
        - have character constants ('x') replaced with a decimal number

   Return value:
        Number of operands (0,1,2, or 3) or -1 on error.

  *************************************************************************** */
static int
i_scan (iP, args)
     /* Pointer to ascii instruction;  MUCKED BY US.  */
     register char *iP;
     /* Output arg: pointers to opcode and operands placed here.  MUST
        ACCOMMODATE 4 ENTRIES.  */
     char *args[];
{

  /* Isolate opcode */
  if (*(iP) == ' ')
    {
      iP++;
    }                           /* Skip lead space, if any */
  args[0] = iP;
  for (; *iP != ' '; iP++)
    {
      if (*iP == '\0')
        {
          /* There are no operands */
          if (args[0] == iP)
            {
              /* We never moved: there was no opcode either! */
              as_bad (_("missing opcode"));
              return -1;
            }
          return 0;
        }
    }
  *iP++ = '\0';                 /* Terminate opcode */
  return (get_args (iP, args));
}                               /* i_scan() */

/*****************************************************************************
   mem_fmt:     generate a MEMA- or MEMB-format instruction

  *************************************************************************** */
static void
mem_fmt (args, oP, callx)
     char *args[];              /* args[0]->opcode mnemonic, args[1-3]->operands */
     struct i960_opcode *oP;    /* Pointer to description of instruction */
     int callx;                 /* Is this a callx opcode */
{
  int i;                        /* Loop counter */
  struct regop regop;           /* Description of register operand */
  char opdesc;                  /* Operand descriptor byte */
  memS instr;                   /* Description of binary to be output */
  char *outP;                   /* Where the binary was output to */
  expressionS expr;             /* Parsed expression */
  /* ->description of deferred address fixup */
  fixS *fixP;

#ifdef OBJ_COFF
  /* COFF support isn't in place yet for callx relaxing.  */
  callx = 0;
#endif

  memset (&instr, '\0', sizeof (memS));
  instr.opcode = oP->opcode;

  /* Process operands.  */
  for (i = 1; i <= oP->num_ops; i++)
    {
      opdesc = oP->operand[i - 1];

      if (MEMOP (opdesc))
        {
          parse_memop (&instr, args[i], oP->format);
        }
      else
        {
          parse_regop (&regop, args[i], opdesc);
          instr.opcode |= regop.n << 19;
        }
    }

  /* Parse the displacement; this must be done before emitting the
     opcode, in case it is an expression using `.'.  */
  parse_expr (instr.e, &expr);

  /* Output opcode */
  outP = emit (instr.opcode);

  if (instr.disp == 0)
    {
      return;
    }

  /* Process the displacement */
  switch (expr.X_op)
    {
    case O_illegal:
      as_bad (_("expression syntax error"));
      break;

    case O_constant:
      if (instr.disp == 32)
        {
          (void) emit (offs (expr));    /* Output displacement */
        }
      else
        {
          /* 12-bit displacement */
          if (offs (expr) & ~0xfff)
            {
              /* Won't fit in 12 bits: convert already-output
               * instruction to MEMB format, output
               * displacement.
               */
              mema_to_memb (outP);
              (void) emit (offs (expr));
            }
          else
            {
              /* WILL fit in 12 bits:  OR into opcode and
               * overwrite the binary we already put out
               */
              instr.opcode |= offs (expr);
              md_number_to_chars (outP, instr.opcode, 4);
            }
        }
      break;

    default:
      if (instr.disp == 12)
        {
          /* Displacement is dependent on a symbol, whose value
           * may change at link time.  We HAVE to reserve 32 bits.
           * Convert already-output opcode to MEMB format.
           */
          mema_to_memb (outP);
        }

      /* Output 0 displacement and set up address fixup for when
       * this symbol's value becomes known.
       */
      outP = emit ((long) 0);
      fixP = fix_new_exp (frag_now,
                          outP - frag_now->fr_literal,
                          4,
                          &expr,
                          0,
                          NO_RELOC);
      /* Steve's linker relaxing hack.  Mark this 32-bit relocation as
         being in the instruction stream, specifically as part of a callx
         instruction.  */
      fixP->fx_bsr = callx;
      break;
    }
}                               /* memfmt() */

/*****************************************************************************
   mema_to_memb:        convert a MEMA-format opcode to a MEMB-format opcode.

   There are 2 possible MEMA formats:
        - displacement only
        - displacement + abase

   They are distinguished by the setting of the MEMA_ABASE bit.

  *************************************************************************** */
static void
mema_to_memb (opcodeP)
     char *opcodeP;             /* Where to find the opcode, in target byte order */
{
  long opcode;                  /* Opcode in host byte order */
  long mode;                    /* Mode bits for MEMB instruction */

  opcode = md_chars_to_number (opcodeP, 4);
  know (!(opcode & MEMB_BIT));

  mode = MEMB_BIT | D_BIT;
  if (opcode & MEMA_ABASE)
    {
      mode |= A_BIT;
    }

  opcode &= 0xffffc000;         /* Clear MEMA offset and mode bits */
  opcode |= mode;               /* Set MEMB mode bits */

  md_number_to_chars (opcodeP, opcode, 4);
}                               /* mema_to_memb() */

/*****************************************************************************
   parse_expr:          parse an expression

        Use base assembler's expression parser to parse an expression.
        It, unfortunately, runs off a global which we have to save/restore
        in order to make it work for us.

        An empty expression string is treated as an absolute 0.

        Sets O_illegal regardless of expression evaluation if entire input
        string is not consumed in the evaluation -- tolerate no dangling junk!

  *************************************************************************** */
static void
parse_expr (textP, expP)
     char *textP;               /* Text of expression to be parsed */
     expressionS *expP;         /* Where to put the results of parsing */
{
  char *save_in;                /* Save global here */
  symbolS *symP;

  know (textP);

  if (*textP == '\0')
    {
      /* Treat empty string as absolute 0 */
      expP->X_add_symbol = expP->X_op_symbol = NULL;
      expP->X_add_number = 0;
      expP->X_op = O_constant;
    }
  else
    {
      save_in = input_line_pointer;     /* Save global */
      input_line_pointer = textP;       /* Make parser work for us */

      (void) expression (expP);
      if ((size_t) (input_line_pointer - textP) != strlen (textP))
        {
          /* Did not consume all of the input */
          expP->X_op = O_illegal;
        }
      symP = expP->X_add_symbol;
      if (symP && (hash_find (reg_hash, S_GET_NAME (symP))))
        {
          /* Register name in an expression */
          /* FIXME: this isn't much of a check any more.  */
          expP->X_op = O_illegal;
        }

      input_line_pointer = save_in;     /* Restore global */
    }
}

/*****************************************************************************
   parse_ldcont:
        Parse and replace a 'ldconst' pseudo-instruction with an appropriate
        i80960 instruction.

        Assumes the input consists of:
                arg[0]  opcode mnemonic ('ldconst')
                arg[1]  first operand (constant)
                arg[2]  name of register to be loaded

        Replaces opcode and/or operands as appropriate.

        Returns the new number of arguments, or -1 on failure.

  *************************************************************************** */
static int
parse_ldconst (arg)
     char *arg[];               /* See above */
{
  int n;                        /* Constant to be loaded */
  int shift;                    /* Shift count for "shlo" instruction */
  static char buf[5];           /* Literal for first operand */
  static char buf2[5];          /* Literal for second operand */
  expressionS e;                /* Parsed expression */

  arg[3] = NULL;                /* So we can tell at the end if it got used or not */

  parse_expr (arg[1], &e);
  switch (e.X_op)
    {
    default:
      /* We're dependent on one or more symbols -- use "lda" */
      arg[0] = "lda";
      break;

    case O_constant:
      /* Try the following mappings:
       *      ldconst 0,<reg>  ->mov  0,<reg>
       *        ldconst 31,<reg> ->mov  31,<reg>
       *        ldconst 32,<reg> ->addo 1,31,<reg>
       *        ldconst 62,<reg> ->addo 31,31,<reg>
       *        ldconst 64,<reg> ->shlo 8,3,<reg>
       *        ldconst -1,<reg> ->subo 1,0,<reg>
       *        ldconst -31,<reg>->subo 31,0,<reg>
       *
       * anthing else becomes:
       *        lda xxx,<reg>
       */
      n = offs (e);
      if ((0 <= n) && (n <= 31))
        {
          arg[0] = "mov";

        }
      else if ((-31 <= n) && (n <= -1))
        {
          arg[0] = "subo";
          arg[3] = arg[2];
          sprintf (buf, "%d", -n);
          arg[1] = buf;
          arg[2] = "0";

        }
      else if ((32 <= n) && (n <= 62))
        {
          arg[0] = "addo";
          arg[3] = arg[2];
          arg[1] = "31";
          sprintf (buf, "%d", n - 31);
          arg[2] = buf;

        }
      else if ((shift = shift_ok (n)) != 0)
        {
          arg[0] = "shlo";
          arg[3] = arg[2];
          sprintf (buf, "%d", shift);
          arg[1] = buf;
          sprintf (buf2, "%d", n >> shift);
          arg[2] = buf2;

        }
      else
        {
          arg[0] = "lda";
        }
      break;

    case O_illegal:
      as_bad (_("invalid constant"));
      return -1;
      break;
    }
  return (arg[3] == 0) ? 2 : 3;
}

/*****************************************************************************
   parse_memop: parse a memory operand

        This routine is based on the observation that the 4 mode bits of the
        MEMB format, taken individually, have fairly consistent meaning:

                 M3 (bit 13): 1 if displacement is present (D_BIT)
                 M2 (bit 12): 1 for MEMB instructions (MEMB_BIT)
                 M1 (bit 11): 1 if index is present (I_BIT)
                 M0 (bit 10): 1 if abase is present (A_BIT)

        So we parse the memory operand and set bits in the mode as we find
        things.  Then at the end, if we go to MEMB format, we need only set
        the MEMB bit (M2) and our mode is built for us.

        Unfortunately, I said "fairly consistent".  The exceptions:

                 DBIA
                 0100   Would seem illegal, but means "abase-only".

                 0101   Would seem to mean "abase-only" -- it means IP-relative.
                        Must be converted to 0100.

                 0110   Would seem to mean "index-only", but is reserved.
                        We turn on the D bit and provide a 0 displacement.

        The other thing to observe is that we parse from the right, peeling
        things * off as we go:  first any index spec, then any abase, then
        the displacement.

  *************************************************************************** */
static void
parse_memop (memP, argP, optype)
     memS *memP;                /* Where to put the results */
     char *argP;                /* Text of the operand to be parsed */
     int optype;                /* MEM1, MEM2, MEM4, MEM8, MEM12, or MEM16 */
{
  char *indexP;                 /* Pointer to index specification with "[]" removed */
  char *p;                      /* Temp char pointer */
  char iprel_flag;              /* True if this is an IP-relative operand */
  int regnum;                   /* Register number */
  /* Scale factor: 1,2,4,8, or 16.  Later converted to internal format
     (0,1,2,3,4 respectively).  */
  int scale;
  int mode;                     /* MEMB mode bits */
  int *intP;                    /* Pointer to register number */

  /* The following table contains the default scale factors for each
     type of memory instruction.  It is accessed using (optype-MEM1)
     as an index -- thus it assumes the 'optype' constants are
     assigned consecutive values, in the order they appear in this
     table.  */
  static const int def_scale[] =
  {
    1,                          /* MEM1 */
    2,                          /* MEM2 */
    4,                          /* MEM4 */
    8,                          /* MEM8 */
    -1,                         /* MEM12 -- no valid default */
    16                          /* MEM16 */
  };

  iprel_flag = mode = 0;

  /* Any index present? */
  indexP = get_ispec (argP);
  if (indexP)
    {
      p = strchr (indexP, '*');
      if (p == NULL)
        {
          /* No explicit scale -- use default for this instruction
             type and assembler mode.  */
          if (flag_mri)
            scale = 1;
          else
            /* GNU960 compatibility */
            scale = def_scale[optype - MEM1];
        }
      else
        {
          *p++ = '\0';          /* Eliminate '*' */

          /* Now indexP->a '\0'-terminated register name,
             * and p->a scale factor.
           */

          if (!strcmp (p, "16"))
            {
              scale = 16;
            }
          else if (strchr ("1248", *p) && (p[1] == '\0'))
            {
              scale = *p - '0';
            }
          else
            {
              scale = -1;
            }
        }

      regnum = get_regnum (indexP);     /* Get index reg. # */
      if (!IS_RG_REG (regnum))
        {
          as_bad (_("invalid index register"));
          return;
        }

      /* Convert scale to its binary encoding */
      switch (scale)
        {
        case 1:
          scale = 0 << 7;
          break;
        case 2:
          scale = 1 << 7;
          break;
        case 4:
          scale = 2 << 7;
          break;
        case 8:
          scale = 3 << 7;
          break;
        case 16:
          scale = 4 << 7;
          break;
        default:
          as_bad (_("invalid scale factor"));
          return;
        };

      memP->opcode |= scale | regnum;   /* Set index bits in opcode */
      mode |= I_BIT;            /* Found a valid index spec */
    }

  /* Any abase (Register Indirect) specification present? */
  if ((p = strrchr (argP, '(')) != NULL)
    {
      /* "(" is there -- does it start a legal abase spec?  If not, it
         could be part of a displacement expression.  */
      intP = (int *) hash_find (areg_hash, p);
      if (intP != NULL)
        {
          /* Got an abase here */
          regnum = *intP;
          *p = '\0';            /* discard register spec */
          if (regnum == IPREL)
            {
              /* We have to specialcase ip-rel mode */
              iprel_flag = 1;
            }
          else
            {
              memP->opcode |= regnum << 14;
              mode |= A_BIT;
            }
        }
    }

  /* Any expression present? */
  memP->e = argP;
  if (*argP != '\0')
    {
      mode |= D_BIT;
    }

  /* Special-case ip-relative addressing */
  if (iprel_flag)
    {
      if (mode & I_BIT)
        {
          syntax ();
        }
      else
        {
          memP->opcode |= 5 << 10;      /* IP-relative mode */
          memP->disp = 32;
        }
      return;
    }

  /* Handle all other modes */
  switch (mode)
    {
    case D_BIT | A_BIT:
      /* Go with MEMA instruction format for now (grow to MEMB later
         if 12 bits is not enough for the displacement).  MEMA format
         has a single mode bit: set it to indicate that abase is
         present.  */
      memP->opcode |= MEMA_ABASE;
      memP->disp = 12;
      break;

    case D_BIT:
      /* Go with MEMA instruction format for now (grow to MEMB later
         if 12 bits is not enough for the displacement).  */
      memP->disp = 12;
      break;

    case A_BIT:
      /* For some reason, the bit string for this mode is not
         consistent: it should be 0 (exclusive of the MEMB bit), so we
         set it "by hand" here.  */
      memP->opcode |= MEMB_BIT;
      break;

    case A_BIT | I_BIT:
      /* set MEMB bit in mode, and OR in mode bits */
      memP->opcode |= mode | MEMB_BIT;
      break;

    case I_BIT:
      /* Treat missing displacement as displacement of 0.  */
      mode |= D_BIT;
      /* Fall into next case.  */
    case D_BIT | A_BIT | I_BIT:
    case D_BIT | I_BIT:
      /* set MEMB bit in mode, and OR in mode bits */
      memP->opcode |= mode | MEMB_BIT;
      memP->disp = 32;
      break;

    default:
      syntax ();
      break;
    }
}

/*****************************************************************************
   parse_po:    parse machine-dependent pseudo-op

        This is a top-level routine for machine-dependent pseudo-ops.  It slurps
        up the rest of the input line, breaks out the individual arguments,
        and dispatches them to the correct handler.
  *************************************************************************** */
static void
parse_po (po_num)
     int po_num;                /* Pseudo-op number:  currently S_LEAFPROC or S_SYSPROC */
{
  /* Pointers operands, with no embedded whitespace.
     arg[0] unused, arg[1-3]->operands */
  char *args[4];
  int n_ops;                    /* Number of operands */
  char *p;                      /* Pointer to beginning of unparsed argument string */
  char eol;                     /* Character that indicated end of line */

  extern char is_end_of_line[];

  /* Advance input pointer to end of line.  */
  p = input_line_pointer;
  while (!is_end_of_line[(unsigned char) *input_line_pointer])
    {
      input_line_pointer++;
    }
  eol = *input_line_pointer;    /* Save end-of-line char */
  *input_line_pointer = '\0';   /* Terminate argument list */

  /* Parse out operands */
  n_ops = get_args (p, args);
  if (n_ops == -1)
    {
      return;
    }

  /* Dispatch to correct handler */
  switch (po_num)
    {
    case S_SYSPROC:
      s_sysproc (n_ops, args);
      break;
    case S_LEAFPROC:
      s_leafproc (n_ops, args);
      break;
    default:
      BAD_CASE (po_num);
      break;
    }

  /* Restore eol, so line numbers get updated correctly.  Base
     assembler assumes we leave input pointer pointing at char
     following the eol.  */
  *input_line_pointer++ = eol;
}

/*****************************************************************************
   parse_regop: parse a register operand.

        In case of illegal operand, issue a message and return some valid
        information so instruction processing can continue.
  *************************************************************************** */
static void
parse_regop (regopP, optext, opdesc)
     struct regop *regopP;      /* Where to put description of register operand */
     char *optext;              /* Text of operand */
     char opdesc;               /* Descriptor byte:  what's legal for this operand */
{
  int n;                        /* Register number */
  expressionS e;                /* Parsed expression */

  /* See if operand is a register */
  n = get_regnum (optext);
  if (n >= 0)
    {
      if (IS_RG_REG (n))
        {
          /* global or local register */
          if (!REG_ALIGN (opdesc, n))
            {
              as_bad (_("unaligned register"));
            }
          regopP->n = n;
          regopP->mode = 0;
          regopP->special = 0;
          return;
        }
      else if (IS_FP_REG (n) && FP_OK (opdesc))
        {
          /* Floating point register, and it's allowed */
          regopP->n = n - FP0;
          regopP->mode = 1;
          regopP->special = 0;
          return;
        }
      else if (IS_SF_REG (n) && SFR_OK (opdesc))
        {
          /* Special-function register, and it's allowed */
          regopP->n = n - SF0;
          regopP->mode = 0;
          regopP->special = 1;
          if (!targ_has_sfr (regopP->n))
            {
              as_bad (_("no such sfr in this architecture"));
            }
          return;
        }
    }
  else if (LIT_OK (opdesc))
    {
      /* How about a literal?  */
      regopP->mode = 1;
      regopP->special = 0;
      if (FP_OK (opdesc))
        {                       /* floating point literal acceptable */
          /* Skip over 0f, 0d, or 0e prefix */
          if ((optext[0] == '0')
              && (optext[1] >= 'd')
              && (optext[1] <= 'f'))
            {
              optext += 2;
            }

          if (!strcmp (optext, "0.0") || !strcmp (optext, "0"))
            {
              regopP->n = 0x10;
              return;
            }
          if (!strcmp (optext, "1.0") || !strcmp (optext, "1"))
            {
              regopP->n = 0x16;
              return;
            }

        }
      else
        {                       /* fixed point literal acceptable */
          parse_expr (optext, &e);
          if (e.X_op != O_constant
              || (offs (e) < 0) || (offs (e) > 31))
            {
              as_bad (_("illegal literal"));
              offs (e) = 0;
            }
          regopP->n = offs (e);
          return;
        }
    }

  /* Nothing worked */
  syntax ();
  regopP->mode = 0;             /* Register r0 is always a good one */
  regopP->n = 0;
  regopP->special = 0;
}                               /* parse_regop() */

/*****************************************************************************
   reg_fmt:     generate a REG-format instruction

  *************************************************************************** */
static void
reg_fmt (args, oP)
     char *args[];              /* args[0]->opcode mnemonic, args[1-3]->operands */
     struct i960_opcode *oP;    /* Pointer to description of instruction */
{
  long instr;                   /* Binary to be output */
  struct regop regop;           /* Description of register operand */
  int n_ops;                    /* Number of operands */

  instr = oP->opcode;
  n_ops = oP->num_ops;

  if (n_ops >= 1)
    {
      parse_regop (&regop, args[1], oP->operand[0]);

      if ((n_ops == 1) && !(instr & M3))
        {
          /* 1-operand instruction in which the dst field should
             * be used (instead of src1).
           */
          regop.n <<= 19;
          if (regop.special)
            {
              regop.mode = regop.special;
            }
          regop.mode <<= 13;
          regop.special = 0;
        }
      else
        {
          /* regop.n goes in bit 0, needs no shifting */
          regop.mode <<= 11;
          regop.special <<= 5;
        }
      instr |= regop.n | regop.mode | regop.special;
    }

  if (n_ops >= 2)
    {
      parse_regop (&regop, args[2], oP->operand[1]);

      if ((n_ops == 2) && !(instr & M3))
        {
          /* 2-operand instruction in which the dst field should
             * be used instead of src2).
           */
          regop.n <<= 19;
          if (regop.special)
            {
              regop.mode = regop.special;
            }
          regop.mode <<= 13;
          regop.special = 0;
        }
      else
        {
          regop.n <<= 14;
          regop.mode <<= 12;
          regop.special <<= 6;
        }
      instr |= regop.n | regop.mode | regop.special;
    }
  if (n_ops == 3)
    {
      parse_regop (&regop, args[3], oP->operand[2]);
      if (regop.special)
        {
          regop.mode = regop.special;
        }
      instr |= (regop.n <<= 19) | (regop.mode <<= 13);
    }
  emit (instr);
}

/*****************************************************************************
   relax_cobr:
        Replace cobr instruction in a code fragment with equivalent branch and
        compare instructions, so it can reach beyond a 13-bit displacement.
        Set up an address fix/relocation for the new branch instruction.

  *************************************************************************** */

/* This "conditional jump" table maps cobr instructions into
   equivalent compare and branch opcodes.  */
static const
struct
{
  long compare;
  long branch;
}

coj[] =
{                               /* COBR OPCODE: */
  { CHKBIT, BNO },              /*      0x30 - bbc */
  { CMPO, BG },                 /*      0x31 - cmpobg */
  { CMPO, BE },                 /*      0x32 - cmpobe */
  { CMPO, BGE },                /*      0x33 - cmpobge */
  { CMPO, BL },                 /*      0x34 - cmpobl */
  { CMPO, BNE },                /*      0x35 - cmpobne */
  { CMPO, BLE },                /*      0x36 - cmpoble */
  { CHKBIT, BO },               /*      0x37 - bbs */
  { CMPI, BNO },                /*      0x38 - cmpibno */
  { CMPI, BG },                 /*      0x39 - cmpibg */
  { CMPI, BE },                 /*      0x3a - cmpibe */
  { CMPI, BGE },                /*      0x3b - cmpibge */
  { CMPI, BL },                 /*      0x3c - cmpibl */
  { CMPI, BNE },                /*      0x3d - cmpibne */
  { CMPI, BLE },                /*      0x3e - cmpible */
  { CMPI, BO },                 /*      0x3f - cmpibo */
};

static void
relax_cobr (fragP)
     register fragS *fragP;     /* fragP->fr_opcode is assumed to point to
                                 * the cobr instruction, which comes at the
                                 * end of the code fragment.
                                 */
{
  int opcode, src1, src2, m1, s2;
  /* Bit fields from cobr instruction */
  long bp_bits;                 /* Branch prediction bits from cobr instruction */
  long instr;                   /* A single i960 instruction */
  /* ->instruction to be replaced */
  char *iP;
  fixS *fixP;                   /* Relocation that can be done at assembly time */

  /* PICK UP & PARSE COBR INSTRUCTION */
  iP = fragP->fr_opcode;
  instr = md_chars_to_number (iP, 4);
  opcode = ((instr >> 24) & 0xff) - 0x30;       /* "-0x30" for table index */
  src1 = (instr >> 19) & 0x1f;
  m1 = (instr >> 13) & 1;
  s2 = instr & 1;
  src2 = (instr >> 14) & 0x1f;
  bp_bits = instr & BP_MASK;

  /* GENERATE AND OUTPUT COMPARE INSTRUCTION */
  instr = coj[opcode].compare
    | src1 | (m1 << 11) | (s2 << 6) | (src2 << 14);
  md_number_to_chars (iP, instr, 4);

  /* OUTPUT BRANCH INSTRUCTION */
  md_number_to_chars (iP + 4, coj[opcode].branch | bp_bits, 4);

  /* SET UP ADDRESS FIXUP/RELOCATION */
  fixP = fix_new (fragP,
                  iP + 4 - fragP->fr_literal,
                  4,
                  fragP->fr_symbol,
                  fragP->fr_offset,
                  1,
                  NO_RELOC);

  fixP->fx_bit_fixP = (bit_fixS *) 24;  /* Store size of bit field */

  fragP->fr_fix += 4;
  frag_wane (fragP);
}

/*****************************************************************************
   reloc_callj: Relocate a 'callj' instruction

        This is a "non-(GNU)-standard" machine-dependent hook.  The base
        assembler calls it when it decides it can relocate an address at
        assembly time instead of emitting a relocation directive.

        Check to see if the relocation involves a 'callj' instruction to a:
            sysproc:    Replace the default 'call' instruction with a 'calls'
            leafproc:   Replace the default 'call' instruction with a 'bal'.
            other proc: Do nothing.

        See b.out.h for details on the 'n_other' field in a symbol structure.

   IMPORTANT!:
        Assumes the caller has already figured out, in the case of a leafproc,
        to use the 'bal' entry point, and has substituted that symbol into the
        passed fixup structure.

  *************************************************************************** */
int
reloc_callj (fixP)
     /* Relocation that can be done at assembly time */
     fixS *fixP;
{
  /* Points to the binary for the instruction being relocated.  */
  char *where;

  if (!fixP->fx_tcbit)
    {
      /* This wasn't a callj instruction in the first place */
      return 0;
    }

  where = fixP->fx_frag->fr_literal + fixP->fx_where;

  if (TC_S_IS_SYSPROC (fixP->fx_addsy))
    {
      /* Symbol is a .sysproc: replace 'call' with 'calls'.  System
         procedure number is (other-1).  */
      md_number_to_chars (where, CALLS | TC_S_GET_SYSPROC (fixP->fx_addsy), 4);

      /* Nothing else needs to be done for this instruction.  Make
         sure 'md_number_to_field()' will perform a no-op.  */
      fixP->fx_bit_fixP = (bit_fixS *) 1;
    }
  else if (TC_S_IS_CALLNAME (fixP->fx_addsy))
    {
      /* Should not happen: see block comment above */
      as_fatal (_("Trying to 'bal' to %s"), S_GET_NAME (fixP->fx_addsy));
    }
  else if (TC_S_IS_BALNAME (fixP->fx_addsy))
    {
      /* Replace 'call' with 'bal'; both instructions have the same
         format, so calling code should complete relocation as if
         nothing happened here.  */
      md_number_to_chars (where, BAL, 4);
    }
  else if (TC_S_IS_BADPROC (fixP->fx_addsy))
    {
      as_bad (_("Looks like a proc, but can't tell what kind.\n"));
    }                           /* switch on proc type */

  /* else Symbol is neither a sysproc nor a leafproc */
  return 0;
}

/*****************************************************************************
   s_leafproc:  process .leafproc pseudo-op

        .leafproc takes two arguments, the second one is optional:
                arg[1]: name of 'call' entry point to leaf procedure
                arg[2]: name of 'bal' entry point to leaf procedure

        If the two arguments are identical, or if the second one is missing,
        the first argument is taken to be the 'bal' entry point.

        If there are 2 distinct arguments, we must make sure that the 'bal'
        entry point immediately follows the 'call' entry point in the linked
        list of symbols.

  *************************************************************************** */
static void
s_leafproc (n_ops, args)
     int n_ops;                 /* Number of operands */
     char *args[];              /* args[1]->1st operand, args[2]->2nd operand */
{
  symbolS *callP;               /* Pointer to leafproc 'call' entry point symbol */
  symbolS *balP;                /* Pointer to leafproc 'bal' entry point symbol */

  if ((n_ops != 1) && (n_ops != 2))
    {
      as_bad (_("should have 1 or 2 operands"));
      return;
    }                           /* Check number of arguments */

  /* Find or create symbol for 'call' entry point.  */
  callP = symbol_find_or_make (args[1]);

  if (TC_S_IS_CALLNAME (callP))
    {
      as_warn (_("Redefining leafproc %s"), S_GET_NAME (callP));
    }                           /* is leafproc */

  /* If that was the only argument, use it as the 'bal' entry point.
     * Otherwise, mark it as the 'call' entry point and find or create
     * another symbol for the 'bal' entry point.
   */
  if ((n_ops == 1) || !strcmp (args[1], args[2]))
    {
      TC_S_FORCE_TO_BALNAME (callP);

    }
  else
    {
      TC_S_FORCE_TO_CALLNAME (callP);

      balP = symbol_find_or_make (args[2]);
      if (TC_S_IS_CALLNAME (balP))
        {
          as_warn (_("Redefining leafproc %s"), S_GET_NAME (balP));
        }
      TC_S_FORCE_TO_BALNAME (balP);

#ifndef OBJ_ELF
      tc_set_bal_of_call (callP, balP);
#endif
    }                           /* if only one arg, or the args are the same */
}

/*
   s_sysproc: process .sysproc pseudo-op

        .sysproc takes two arguments:
                arg[1]: name of entry point to system procedure
                arg[2]: 'entry_num' (index) of system procedure in the range
                        [0,31] inclusive.

        For [ab].out, we store the 'entrynum' in the 'n_other' field of
        the symbol.  Since that entry is normally 0, we bias 'entrynum'
        by adding 1 to it.  It must be unbiased before it is used.  */
static void
s_sysproc (n_ops, args)
     int n_ops;                 /* Number of operands */
     char *args[];              /* args[1]->1st operand, args[2]->2nd operand */
{
  expressionS exp;
  symbolS *symP;

  if (n_ops != 2)
    {
      as_bad (_("should have two operands"));
      return;
    }                           /* bad arg count */

  /* Parse "entry_num" argument and check it for validity.  */
  parse_expr (args[2], &exp);
  if (exp.X_op != O_constant
      || (offs (exp) < 0)
      || (offs (exp) > 31))
    {
      as_bad (_("'entry_num' must be absolute number in [0,31]"));
      return;
    }

  /* Find/make symbol and stick entry number (biased by +1) into it */
  symP = symbol_find_or_make (args[1]);

  if (TC_S_IS_SYSPROC (symP))
    {
      as_warn (_("Redefining entrynum for sysproc %s"), S_GET_NAME (symP));
    }                           /* redefining */

  TC_S_SET_SYSPROC (symP, offs (exp));  /* encode entry number */
  TC_S_FORCE_TO_SYSPROC (symP);
}

/*****************************************************************************
   shift_ok:
        Determine if a "shlo" instruction can be used to implement a "ldconst".
        This means that some number X < 32 can be shifted left to produce the
        constant of interest.

        Return the shift count, or 0 if we can't do it.
        Caller calculates X by shifting original constant right 'shift' places.

  *************************************************************************** */
static int
shift_ok (n)
     int n;                     /* The constant of interest */
{
  int shift;                    /* The shift count */

  if (n <= 0)
    {
      /* Can't do it for negative numbers */
      return 0;
    }

  /* Shift 'n' right until a 1 is about to be lost */
  for (shift = 0; (n & 1) == 0; shift++)
    {
      n >>= 1;
    }

  if (n >= 32)
    {
      return 0;
    }
  return shift;
}

/* syntax: issue syntax error */

static void
syntax ()
{
  as_bad (_("syntax error"));
}                               /* syntax() */

/* targ_has_sfr:

   Return TRUE iff the target architecture supports the specified
   special-function register (sfr).  */

static int
targ_has_sfr (n)
     int n;                     /* Number (0-31) of sfr */
{
  switch (architecture)
    {
    case ARCH_KA:
    case ARCH_KB:
    case ARCH_MC:
    case ARCH_JX:
      return 0;
    case ARCH_HX:
      return ((0 <= n) && (n <= 4));
    case ARCH_CA:
    default:
      return ((0 <= n) && (n <= 2));
    }
}

/* targ_has_iclass:

   Return TRUE iff the target architecture supports the indicated
   class of instructions.  */
static int
targ_has_iclass (ic)
     /* Instruction class;  one of:
        I_BASE, I_CX, I_DEC, I_KX, I_FP, I_MIL, I_CASIM, I_CX2, I_HX, I_HX2
      */
     int ic;
{
  iclasses_seen |= ic;
  switch (architecture)
    {
    case ARCH_KA:
      return ic & (I_BASE | I_KX);
    case ARCH_KB:
      return ic & (I_BASE | I_KX | I_FP | I_DEC);
    case ARCH_MC:
      return ic & (I_BASE | I_KX | I_FP | I_DEC | I_MIL);
    case ARCH_CA:
      return ic & (I_BASE | I_CX | I_CX2 | I_CASIM);
    case ARCH_JX:
      return ic & (I_BASE | I_CX2 | I_JX);
    case ARCH_HX:
      return ic & (I_BASE | I_CX2 | I_JX | I_HX);
    default:
      if ((iclasses_seen & (I_KX | I_FP | I_DEC | I_MIL))
          && (iclasses_seen & (I_CX | I_CX2)))
        {
          as_warn (_("architecture of opcode conflicts with that of earlier instruction(s)"));
          iclasses_seen &= ~ic;
        }
      return 1;
    }
}

/* Handle the MRI .endian pseudo-op.  */

static void
s_endian (ignore)
     int ignore ATTRIBUTE_UNUSED;
{
  char *name;
  char c;

  name = input_line_pointer;
  c = get_symbol_end ();
  if (strcasecmp (name, "little") == 0)
    ;
  else if (strcasecmp (name, "big") == 0)
    as_bad (_("big endian mode is not supported"));
  else
    as_warn (_("ignoring unrecognized .endian type `%s'"), name);

  *input_line_pointer = c;

  demand_empty_rest_of_line ();
}

/* We have no need to default values of symbols.  */

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

/* Exactly what point is a PC-relative offset relative TO?
   On the i960, they're relative to the address of the instruction,
   which we have set up as the address of the fixup too.  */
long
md_pcrel_from (fixP)
     fixS *fixP;
{
  return fixP->fx_where + fixP->fx_frag->fr_address;
}

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

  if (!fixP->fx_bit_fixP)
    {
#ifndef BFD_ASSEMBLER
      /* For callx, we always want to write out zero, and emit a
         symbolic relocation.  */
      if (fixP->fx_bsr)
        val = 0;

      fixP->fx_addnumber = val;
#endif

      md_number_to_imm (place, val, fixP->fx_size);
    }
  else if ((int) fixP->fx_bit_fixP == 13
           && fixP->fx_addsy != NULL
           && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
    {
      /* This is a COBR instruction.  They have only a
         13-bit displacement and are only to be used
         for local branches: flag as error, don't generate
         relocation.  */
      as_bad_where (fixP->fx_file, fixP->fx_line,
                    _("can't use COBR format with external label"));
      fixP->fx_addsy = NULL;
    }
  else
    md_number_to_field (place, val, fixP->fx_bit_fixP);

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

#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
void
tc_bout_fix_to_chars (where, fixP, segment_address_in_file)
     char *where;
     fixS *fixP;
     relax_addressT segment_address_in_file;
{
  static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
  struct relocation_info ri;
  symbolS *symbolP;

  memset ((char *) &ri, '\0', sizeof (ri));
  symbolP = fixP->fx_addsy;
  know (symbolP != 0 || fixP->fx_r_type != NO_RELOC);
  ri.r_bsr = fixP->fx_bsr;      /*SAC LD RELAX HACK */
  /* These two 'cuz of NS32K */
  ri.r_callj = fixP->fx_tcbit;
  if (fixP->fx_bit_fixP)
    ri.r_length = 2;
  else
    ri.r_length = nbytes_r_length[fixP->fx_size];
  ri.r_pcrel = fixP->fx_pcrel;
  ri.r_address = fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file;

  if (fixP->fx_r_type != NO_RELOC)
    {
      switch (fixP->fx_r_type)
        {
        case rs_align:
          ri.r_index = -2;
          ri.r_pcrel = 1;
          ri.r_length = fixP->fx_size - 1;
          break;
        case rs_org:
          ri.r_index = -2;
          ri.r_pcrel = 0;
          break;
        case rs_fill:
          ri.r_index = -1;
          break;
        default:
          abort ();
        }
      ri.r_extern = 0;
    }
  else if (linkrelax || !S_IS_DEFINED (symbolP) || fixP->fx_bsr)
    {
      ri.r_extern = 1;
      ri.r_index = symbolP->sy_number;
    }
  else
    {
      ri.r_extern = 0;
      ri.r_index = S_GET_TYPE (symbolP);
    }

  /* Output the relocation information in machine-dependent form.  */
  md_ri_to_chars (where, &ri);
}

#endif /* OBJ_AOUT or OBJ_BOUT */

#if defined (OBJ_COFF) && defined (BFD)
short
tc_coff_fix2rtype (fixP)
     fixS *fixP;
{
  if (fixP->fx_bsr)
    abort ();

  if (fixP->fx_pcrel == 0 && fixP->fx_size == 4)
    return R_RELLONG;

  if (fixP->fx_pcrel != 0 && fixP->fx_size == 4)
    return R_IPRMED;

  abort ();
  return 0;
}

int
tc_coff_sizemachdep (frag)
     fragS *frag;
{
  if (frag->fr_next)
    return frag->fr_next->fr_address - frag->fr_address;
  else
    return 0;
}
#endif

/* Align an address by rounding it up to the specified boundary.  */
valueT
md_section_align (seg, addr)
     segT seg;
     valueT addr;               /* Address to be rounded up */
{
  int align;
#ifdef BFD_ASSEMBLER
  align = bfd_get_section_alignment (stdoutput, seg);
#else
  align = section_alignment[(int) seg];
#endif
  return (addr + (1 << align) - 1) & (-1 << align);
}

extern int coff_flags;

#ifdef OBJ_COFF
void
tc_headers_hook (headers)
     object_headers *headers;
{
  switch (architecture)
    {
    case ARCH_KA:
      coff_flags |= F_I960KA;
      break;

    case ARCH_KB:
      coff_flags |= F_I960KB;
      break;

    case ARCH_MC:
      coff_flags |= F_I960MC;
      break;

    case ARCH_CA:
      coff_flags |= F_I960CA;
      break;

    case ARCH_JX:
      coff_flags |= F_I960JX;
      break;

    case ARCH_HX:
      coff_flags |= F_I960HX;
      break;

    default:
      if (iclasses_seen == I_BASE)
        coff_flags |= F_I960CORE;
      else if (iclasses_seen & I_CX)
        coff_flags |= F_I960CA;
      else if (iclasses_seen & I_HX)
        coff_flags |= F_I960HX;
      else if (iclasses_seen & I_JX)
        coff_flags |= F_I960JX;
      else if (iclasses_seen & I_CX2)
        coff_flags |= F_I960CA;
      else if (iclasses_seen & I_MIL)
        coff_flags |= F_I960MC;
      else if (iclasses_seen & (I_DEC | I_FP))
        coff_flags |= F_I960KB;
      else
        coff_flags |= F_I960KA;
      break;
    }

  if (flag_readonly_data_in_text)
    {
      headers->filehdr.f_magic = I960RWMAGIC;
      headers->aouthdr.magic = OMAGIC;
    }
  else
    {
      headers->filehdr.f_magic = I960ROMAGIC;
      headers->aouthdr.magic = NMAGIC;
    }                           /* set magic numbers */
}

#endif /* OBJ_COFF */

#ifndef BFD_ASSEMBLER

/* Things going on here:

   For bout, We need to assure a couple of simplifying
   assumptions about leafprocs for the linker: the leafproc
   entry symbols will be defined in the same assembly in
   which they're declared with the '.leafproc' directive;
   and if a leafproc has both 'call' and 'bal' entry points
   they are both global or both local.

   For coff, the call symbol has a second aux entry that
   contains the bal entry point.  The bal symbol becomes a
   label.

   For coff representation, the call symbol has a second aux entry that
   contains the bal entry point.  The bal symbol becomes a label.  */

void
tc_crawl_symbol_chain (headers)
     object_headers *headers ATTRIBUTE_UNUSED;
{
  symbolS *symbolP;

  for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
    {
#ifdef OBJ_COFF
      if (TC_S_IS_SYSPROC (symbolP))
        {
          /* second aux entry already contains the sysproc number */
          S_SET_NUMBER_AUXILIARY (symbolP, 2);
          S_SET_STORAGE_CLASS (symbolP, C_SCALL);
          S_SET_DATA_TYPE (symbolP, S_GET_DATA_TYPE (symbolP) | (DT_FCN << N_BTSHFT));
          continue;
        }                       /* rewrite sysproc */
#endif /* OBJ_COFF */

      if (!TC_S_IS_BALNAME (symbolP) && !TC_S_IS_CALLNAME (symbolP))
        {
          continue;
        }                       /* Not a leafproc symbol */

      if (!S_IS_DEFINED (symbolP))
        {
          as_bad (_("leafproc symbol '%s' undefined"), S_GET_NAME (symbolP));
        }                       /* undefined leaf */

      if (TC_S_IS_CALLNAME (symbolP))
        {
          symbolS *balP = tc_get_bal_of_call (symbolP);
          if (S_IS_EXTERNAL (symbolP) != S_IS_EXTERNAL (balP))
            {
              S_SET_EXTERNAL (symbolP);
              S_SET_EXTERNAL (balP);
              as_warn (_("Warning: making leafproc entries %s and %s both global\n"),
                       S_GET_NAME (symbolP), S_GET_NAME (balP));
            }                   /* externality mismatch */
        }                       /* if callname */
    }                           /* walk the symbol chain */
}

#endif /* ! BFD_ASSEMBLER */

/* For aout or bout, the bal immediately follows the call.

   For coff, we cheat and store a pointer to the bal symbol in the
   second aux entry of the call.  */

#undef OBJ_ABOUT
#ifdef OBJ_AOUT
#define OBJ_ABOUT
#endif
#ifdef OBJ_BOUT
#define OBJ_ABOUT
#endif

void
tc_set_bal_of_call (callP, balP)
     symbolS *callP ATTRIBUTE_UNUSED;
     symbolS *balP ATTRIBUTE_UNUSED;
{
  know (TC_S_IS_CALLNAME (callP));
  know (TC_S_IS_BALNAME (balP));

#ifdef OBJ_COFF

  callP->sy_tc = balP;
  S_SET_NUMBER_AUXILIARY (callP, 2);

#else /* ! OBJ_COFF */
#ifdef OBJ_ABOUT

  /* If the 'bal' entry doesn't immediately follow the 'call'
     * symbol, unlink it from the symbol list and re-insert it.
   */
  if (symbol_next (callP) != balP)
    {
      symbol_remove (balP, &symbol_rootP, &symbol_lastP);
      symbol_append (balP, callP, &symbol_rootP, &symbol_lastP);
    }                           /* if not in order */

#else /* ! OBJ_ABOUT */
  as_fatal ("Only supported for a.out, b.out, or COFF");
#endif /* ! OBJ_ABOUT */
#endif /* ! OBJ_COFF */
}

symbolS *
tc_get_bal_of_call (callP)
     symbolS *callP ATTRIBUTE_UNUSED;
{
  symbolS *retval;

  know (TC_S_IS_CALLNAME (callP));

#ifdef OBJ_COFF
  retval = callP->sy_tc;
#else
#ifdef OBJ_ABOUT
  retval = symbol_next (callP);
#else
  as_fatal ("Only supported for a.out, b.out, or COFF");
#endif /* ! OBJ_ABOUT */
#endif /* ! OBJ_COFF */

  know (TC_S_IS_BALNAME (retval));
  return retval;
}                               /* _tc_get_bal_of_call() */

#ifdef OBJ_COFF
void
tc_coff_symbol_emit_hook (symbolP)
     symbolS *symbolP ATTRIBUTE_UNUSED;
{
  if (TC_S_IS_CALLNAME (symbolP))
    {
      symbolS *balP = tc_get_bal_of_call (symbolP);

#if 0
      /* second aux entry contains the bal entry point */
      S_SET_NUMBER_AUXILIARY (symbolP, 2);
#endif
      symbolP->sy_symbol.ost_auxent[1].x_bal.x_balntry = S_GET_VALUE (balP);
      if (S_GET_STORAGE_CLASS (symbolP) == C_EXT)
        S_SET_STORAGE_CLASS (symbolP, C_LEAFEXT);
      else
        S_SET_STORAGE_CLASS (symbolP, C_LEAFSTAT);
      S_SET_DATA_TYPE (symbolP, S_GET_DATA_TYPE (symbolP) | (DT_FCN << N_BTSHFT));
      /* fix up the bal symbol */
      S_SET_STORAGE_CLASS (balP, C_LABEL);
    }                           /* only on calls */
}
#endif /* OBJ_COFF */

void
i960_handle_align (fragp)
     fragS *fragp ATTRIBUTE_UNUSED;
{
  if (!linkrelax)
    return;

#ifndef OBJ_BOUT

  as_bad (_("option --link-relax is only supported in b.out format"));
  linkrelax = 0;
  return;

#else

  /* The text section "ends" with another alignment reloc, to which we
     aren't adding padding.  */
  if (fragp->fr_next == text_last_frag
      || fragp->fr_next == data_last_frag)
    return;

  /* alignment directive */
  fix_new (fragp, fragp->fr_fix, fragp->fr_offset, 0, 0, 0,
           (int) fragp->fr_type);
#endif /* OBJ_BOUT */
}

int
i960_validate_fix (fixP, this_segment_type)
     fixS *fixP;
     segT this_segment_type ATTRIBUTE_UNUSED;
{
  if (fixP->fx_tcbit && TC_S_IS_CALLNAME (fixP->fx_addsy))
    {
      /* Relocation should be done via the associated 'bal'
         entry point symbol.  */

      if (!TC_S_IS_BALNAME (tc_get_bal_of_call (fixP->fx_addsy)))
        {
          as_bad_where (fixP->fx_file, fixP->fx_line,
                        _("No 'bal' entry point for leafproc %s"),
                        S_GET_NAME (fixP->fx_addsy));
          return 0;
        }
      fixP->fx_addsy = tc_get_bal_of_call (fixP->fx_addsy);
    }

  return 1;
}

#ifdef BFD_ASSEMBLER

/* From cgen.c:  */

static short tc_bfd_fix2rtype PARAMS ((fixS *));

static short
tc_bfd_fix2rtype (fixP)
     fixS *fixP;
{
#if 0
  if (fixP->fx_bsr)
    abort ();
#endif

  if (fixP->fx_pcrel == 0 && fixP->fx_size == 4)
    return BFD_RELOC_32;

  if (fixP->fx_pcrel != 0 && fixP->fx_size == 4)
    return BFD_RELOC_24_PCREL;

  abort ();
  return 0;
}

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

   FIXME: To what extent can we get all relevant targets to use this?  */

arelent *
tc_gen_reloc (section, fixP)
     asection *section ATTRIBUTE_UNUSED;
     fixS *fixP;
{
  arelent * reloc;

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

  /* HACK: Is this right? */
  fixP->fx_r_type = tc_bfd_fix2rtype (fixP);

  reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
  if (reloc->howto == (reloc_howto_type *) NULL)
    {
      as_bad_where (fixP->fx_file, fixP->fx_line,
                    "internal error: can't export reloc type %d (`%s')",
                    fixP->fx_r_type,
                    bfd_get_reloc_code_name (fixP->fx_r_type));
      return NULL;
    }

  assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);

  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;
  reloc->addend = fixP->fx_addnumber;

  return reloc;
}

/* end from cgen.c */

#endif /* BFD_ASSEMBLER */

/* end of tc-i960.c */