[binutils.git] / opcodes / ia64-opc.c

/* ia64-opc.c -- Functions to access the compacted opcode table
   Copyright (C) 1999 Free Software Foundation, Inc.
   Written by Bob Manson of Cygnus Solutions, <[email protected]>

   This file is part of GDB, GAS, and the GNU binutils.

   GDB, GAS, and the GNU binutils are free software; you can redistribute
   them and/or modify them 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.

   GDB, GAS, and the GNU binutils are distributed in the hope that they
   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 this file; see the file COPYING.  If not, write to the
   Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "ansidecl.h"
#include "libiberty.h"
#include "sysdep.h"
#include "ia64-asmtab.h"
#include "ia64-asmtab.c"

const struct ia64_templ_desc ia64_templ_desc[16] =
  {
    { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },	/* 0 */
    { 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },
    { 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" },
    { 0, { 0, },				    "-3-" },
    { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },	/* 4 */
    { 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },
    { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" },
    { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" },
    { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" },	/* 8 */
    { 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" },
    { 0, { 0, },				    "-a-" },
    { 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" },
    { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" },	/* c */
    { 0, { 0, },				    "-d-" },
    { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" },
    { 0, { 0, },				    "-f-" },
  };


/* Copy the prefix contained in *PTR (up to a '.' or a NUL) to DEST.
   PTR will be adjusted to point to the start of the next portion
   of the opcode, or at the NUL character. */

static void
get_opc_prefix (ptr, dest)
     const char **ptr;
     char *dest;
{
  char *c = strchr (*ptr, '.');
  if (c != NULL)
    {
      memcpy (dest, *ptr, c - *ptr);
      dest[c - *ptr] = '\0';
      *ptr = c + 1;
    }
  else
    {
      int l = strlen (*ptr);
      memcpy (dest, *ptr, l);
      dest[l] = '\0';
      *ptr += l;
    }
}
\f
/* Find the index of the entry in the string table corresponding to
   STR; return -1 if one does not exist. */

static short
find_string_ent (str)
     const char *str;
{
  short start = 0;
  short end = sizeof (ia64_strings) / sizeof (const char *);
  short i = (start + end) / 2;

  if (strcmp (str, ia64_strings[end - 1]) > 0)
    {
      return -1;
    }
  while (start <= end)
    {
      int c = strcmp (str, ia64_strings[i]);
      if (c < 0)
	{
	  end = i - 1;
	}
      else if (c == 0)
	{
	  return i;
	}
      else
	{
	  start = i + 1;
	}
      i = (start + end) / 2;
    }
  return -1;
}
\f
/* Find the opcode in the main opcode table whose name is STRINGINDEX, or
   return -1 if one does not exist. */

static short
find_main_ent (nameindex)
     short nameindex;
{
  short start = 0;
  short end = sizeof (main_table) / sizeof (struct ia64_main_table);
  short i = (start + end) / 2;

  if (nameindex < main_table[0].name_index
      || nameindex > main_table[end - 1].name_index)
    {
      return -1;
    }
  while (start <= end)
    {
      if (nameindex < main_table[i].name_index)
	{
	  end = i - 1;
	}
      else if (nameindex == main_table[i].name_index)
	{
	  while (i > 0 && main_table[i - 1].name_index == nameindex)
	    {
	      i--;
	    }
	  return i;
	}
      else
	{
	  start = i + 1;
	}
      i = (start + end) / 2;
    }
  return -1;
}
\f
/* Find the index of the entry in the completer table that is part of
   MAIN_ENT (starting from PREV_COMPLETER) that matches NAME, or
   return -1 if one does not exist. */

static short 
find_completer (main_ent, prev_completer, name)
     short main_ent;
     short prev_completer;
     const char *name;
{
  short name_index = find_string_ent (name);

  if (name_index < 0)
    {
      return -1;
    }

  if (prev_completer == -1)
    {
      prev_completer = main_table[main_ent].completers;
    }
  else
    {
      prev_completer = completer_table[prev_completer].subentries;
    }

  while (prev_completer != -1)
    {
      if (completer_table[prev_completer].name_index == name_index)
	{
	  return prev_completer;
	}
      prev_completer = completer_table[prev_completer].alternative;
    }
  return -1;
}
\f
/* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and
   return the result. */

static ia64_insn
apply_completer (opcode, completer_index)
     ia64_insn opcode;
     int completer_index;
{
  ia64_insn mask = completer_table[completer_index].mask;
  ia64_insn bits = completer_table[completer_index].bits;
  int shiftamt = (completer_table[completer_index].offset & 63);

  mask = mask << shiftamt;
  bits = bits << shiftamt;
  opcode = (opcode & ~mask) | bits;
  return opcode;
}
\f
/* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in
   the dis_table array, and return its value.  (BITOFFSET is numbered
   starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the
   first byte in OP_POINTER.) */

static int
extract_op_bits (op_pointer, bitoffset, bits)
     int op_pointer;
     int bitoffset;
     int bits;
{
  int res = 0;

  op_pointer += (bitoffset / 8);

  if (bitoffset % 8)
    {
      unsigned int op = dis_table[op_pointer++];
      int numb = 8 - (bitoffset % 8);
      int mask = (1 << numb) - 1;
      int bata = (bits < numb) ? bits : numb;
      int delta = numb - bata;

      res = (res << bata) | ((op & mask) >> delta);
      bitoffset += bata;
      bits -= bata;
    }
  while (bits >= 8)
    {
      res = (res << 8) | (dis_table[op_pointer++] & 255);
      bits -= 8;
    }
  if (bits > 0)
    {
      unsigned int op = (dis_table[op_pointer++] & 255);
      res = (res << bits) | (op >> (8 - bits));
    }
  return res;
}
\f
/* Examine the state machine entry at OP_POINTER in the dis_table
   array, and extract its values into OPVAL and OP.  The length of the
   state entry in bits is returned. */

static int
extract_op (op_pointer, opval, op)
     int op_pointer;
     int *opval;
     unsigned int *op;
{
  int oplen = 5;

  *op = dis_table[op_pointer];

  if ((*op) & 0x40)
    {
      opval[0] = extract_op_bits (op_pointer, oplen, 5);
      oplen += 5;
    }
  switch ((*op) & 0x30)
    {
    case 0x10:
      {
	opval[1] = extract_op_bits (op_pointer, oplen, 8);
	oplen += 8;
	opval[1] += op_pointer;
	break;
      }
    case 0x20:
      {
	opval[1] = extract_op_bits (op_pointer, oplen, 16);
	if (! (opval[1] & 32768))
	  {
	    opval[1] += op_pointer;
	  }
	oplen += 16;
	break;
      }
    case 0x30:
      {
	oplen--;
	opval[2] = extract_op_bits (op_pointer, oplen, 12);
	oplen += 12;
	opval[2] |= 32768;
	break;
      }
    }
  if (((*op) & 0x08) && (((*op) & 0x30) != 0x30))
    {
      opval[2] = extract_op_bits (op_pointer, oplen, 16);
      oplen += 16;
      if (! (opval[2] & 32768))
	{
	  opval[2] += op_pointer;
	}
    }
  return oplen;
}
\f
/* Returns a non-zero value if the opcode in the main_table list at
   PLACE matches OPCODE and is of type TYPE. */

static int
opcode_verify (opcode, place, type)
     ia64_insn opcode;
     int place;
     enum ia64_insn_type type;
{
  if (main_table[place].opcode_type != type)
    {
      return 0;
    }
  if (main_table[place].flags 
      & (IA64_OPCODE_F2_EQ_F3 | IA64_OPCODE_LEN_EQ_64MCNT))
    {
      const struct ia64_operand *o1, *o2;
      ia64_insn f2, f3;

      if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3)
	{
	  o1 = elf64_ia64_operands + IA64_OPND_F2;
	  o2 = elf64_ia64_operands + IA64_OPND_F3;
	  (*o1->extract) (o1, opcode, &f2);
	  (*o2->extract) (o2, opcode, &f3);
	  if (f2 != f3)
	    return 0;
	}
      else
	{
	  ia64_insn len, count;

	  /* length must equal 64-count: */
	  o1 = elf64_ia64_operands + IA64_OPND_LEN6;
	  o2 = elf64_ia64_operands + main_table[place].operands[2];
	  (*o1->extract) (o1, opcode, &len);
	  (*o2->extract) (o2, opcode, &count);
	  if (len != 64 - count)
	    return 0;
	}
    }
  return 1;
}
\f
/* Find an instruction entry in the ia64_dis_names array that matches
   opcode OPCODE and is of type TYPE.  Returns either a positive index
   into the array, or a negative value if an entry for OPCODE could
   not be found.  Checks all matches and returns the one with the highest
   priority. */

static int
locate_opcode_ent (opcode, type)
     ia64_insn opcode;
     enum ia64_insn_type type;
{
  int currtest[41];
  int bitpos[41];
  int op_ptr[41];
  int currstatenum = 0;
  short found_disent = -1;
  short found_priority = -1;

  currtest[currstatenum] = 0;
  op_ptr[currstatenum] = 0;
  bitpos[currstatenum] = 40;

  while (1)
    {
      int op_pointer = op_ptr[currstatenum];
      unsigned int op;
      int currbitnum = bitpos[currstatenum];
      int oplen;
      int opval[3];
      int next_op;
      int currbit;

      oplen = extract_op (op_pointer, opval, &op);

      bitpos[currstatenum] = currbitnum;

      /* Skip opval[0] bits in the instruction. */
      if (op & 0x40)
	{
	  currbitnum -= opval[0];
	}

      /* The value of the current bit being tested. */
      currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0;
      next_op = -1;

      /* We always perform the tests specified in the current state in
	 a particular order, falling through to the next test if the
	 previous one failed. */
      switch (currtest[currstatenum])
	{
	case 0:
	  currtest[currstatenum]++;
	  if (currbit == 0 && (op & 0x80))
	    {
	      /* Check for a zero bit.  If this test solely checks for
		 a zero bit, we can check for up to 8 consecutive zero
		 bits (the number to check is specified by the lower 3
		 bits in the state code.)

		 If the state instruction matches, we go to the very
		 next state instruction; otherwise, try the next test. */

	      if ((op & 0xf8) == 0x80)
		{
		  int count = op & 0x7;
		  int x;

		  for (x = 0; x <= count; x++)
		    {
		      int i =
			opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0;
		      if (i)
			{
			  break;
			}
		    }
		  if (x > count)
		    {
		      next_op = op_pointer + ((oplen + 7) / 8);
		      currbitnum -= count;
		      break;
		    }
		}
	      else if (! currbit)
		{
		  next_op = op_pointer + ((oplen + 7) / 8);
		  break;
		}
	    }
	  /* FALLTHROUGH */
	case 1:
	  /* If the bit in the instruction is one, go to the state
	     instruction specified by opval[1]. */
	  currtest[currstatenum]++;
	  if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30))
	    {
	      next_op = opval[1];
	      break;
	    }
	  /* FALLTHROUGH */
	case 2:
	  /* Don't care.  Skip the current bit and go to the state
	     instruction specified by opval[2].

	     An encoding of 0x30 is special; this means that a 12-bit
	     offset into the ia64_dis_names[] array is specified.  */
	  currtest[currstatenum]++;
	  if ((op & 0x08) || ((op & 0x30) == 0x30))
	    {
	      next_op = opval[2];
	      break;
	    }
	}

      /* If bit 15 is set in the address of the next state, an offset
	 in the ia64_dis_names array was specified instead.  We then
	 check to see if an entry in the list of opcodes matches the
	 opcode we were given; if so, we have succeeded.  */

      if ((next_op >= 0) && (next_op & 32768))
	{
	  short disent = next_op & 32767;
          short priority = -1;

	  if (next_op > 65535)
	    {
	      abort ();
	    }

	  /* Run through the list of opcodes to check, trying to find
	     one that matches.  */
	  while (disent >= 0)
	    {
	      int place = ia64_dis_names[disent].insn_index;

              priority = ia64_dis_names[disent].priority;

	      if (opcode_verify (opcode, place, type) 
                  && priority > found_priority)
		{
		  break;
		}
	      if (ia64_dis_names[disent].next_flag)
		{
		  disent++;
		}
	      else
		{
		  disent = -1;
		}
	    }

	  if (disent >= 0)
	    {
              found_disent = disent;
              found_priority = priority;
	    }
          /* Try the next test in this state, regardless of whether a match
             was found. */
          next_op = -2;
	}

      /* next_op == -1 is "back up to the previous state".
	 next_op == -2 is "stay in this state and try the next test".
	 Otherwise, transition to the state indicated by next_op. */

      if (next_op == -1)
	{
	  currstatenum--;
	  if (currstatenum < 0)
	    {
              return found_disent;
	    }
	}
      else if (next_op >= 0)
	{
	  currstatenum++;
	  bitpos[currstatenum] = currbitnum - 1;
	  op_ptr[currstatenum] = next_op;
	  currtest[currstatenum] = 0;
	}
    }
}
\f
/* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */

static struct ia64_opcode *
make_ia64_opcode (opcode, name, place, depind)
     ia64_insn opcode;
     const char *name;
     int place;
     int depind;
{
  struct ia64_opcode *res =
    (struct ia64_opcode *) xmalloc (sizeof (struct ia64_opcode));
  res->name = xstrdup (name);
  res->type = main_table[place].opcode_type;
  res->num_outputs = main_table[place].num_outputs;
  res->opcode = opcode;
  res->mask = main_table[place].mask;
  res->operands[0] = main_table[place].operands[0];
  res->operands[1] = main_table[place].operands[1];
  res->operands[2] = main_table[place].operands[2];
  res->operands[3] = main_table[place].operands[3];
  res->operands[4] = main_table[place].operands[4];
  res->flags = main_table[place].flags;
  res->ent_index = place;
  res->dependencies = &op_dependencies[depind];
  return res;
}
\f
/* Determine the ia64_opcode entry for the opcode specified by INSN
   and TYPE.  If a valid entry is not found, return NULL. */
struct ia64_opcode *
ia64_dis_opcode (insn, type)
     ia64_insn insn;
     enum ia64_insn_type type;
{
  int disent = locate_opcode_ent (insn, type);

  if (disent < 0)
    {
      return NULL;
    }
  else
    {
      unsigned int cb = ia64_dis_names[disent].completer_index;
      static char name[128];
      int place = ia64_dis_names[disent].insn_index;
      int ci = main_table[place].completers;
      ia64_insn tinsn = main_table[place].opcode;

      strcpy (name, ia64_strings [main_table[place].name_index]);

      while (cb)
	{
	  if (cb & 1)
	    {
	      int cname = completer_table[ci].name_index;

	      tinsn = apply_completer (tinsn, ci);

	      if (ia64_strings[cname][0] != '\0')
		{
		  strcat (name, ".");
		  strcat (name, ia64_strings[cname]);
		}
	      if (cb != 1)
		{
		  ci = completer_table[ci].subentries;
		}
	    }
	  else
	    {
	      ci = completer_table[ci].alternative;
	    }
	  if (ci < 0)
	    {
	      abort ();
	    }
	  cb = cb >> 1;
	}
      if (tinsn != (insn & main_table[place].mask))
	{
	  abort ();
	}
      return make_ia64_opcode (insn, name, place, 
                               completer_table[ci].dependencies);
    }
}
\f
/* Search the main_opcode table starting from PLACE for an opcode that
   matches NAME.  Return NULL if one is not found. */

static struct ia64_opcode *
ia64_find_matching_opcode (name, place)
     const char *name;
     short place;
{
  char op[129];
  const char *suffix;
  short name_index;

  if (strlen (name) > 128)
    {
      return NULL;
    }
  suffix = name;
  get_opc_prefix (&suffix, op);
  name_index = find_string_ent (op);
  if (name_index < 0)
    {
      return NULL;
    }

  while (main_table[place].name_index == name_index)
    {
      const char *curr_suffix = suffix;
      ia64_insn curr_insn = main_table[place].opcode;
      short completer = -1;

      do {
      	if (suffix[0] == '\0')
	  {
	    completer = find_completer (place, completer, suffix);
	  }
	else
	  {
	    get_opc_prefix (&curr_suffix, op);
	    completer = find_completer (place, completer, op);
	  }
	if (completer != -1)
	  {
	    curr_insn = apply_completer (curr_insn, completer);
	  }
      } while (completer != -1 && curr_suffix[0] != '\0');

      if (completer != -1 && curr_suffix[0] == '\0'
	  && completer_table[completer].terminal_completer)
	{
          int depind = completer_table[completer].dependencies;
	  return make_ia64_opcode (curr_insn, name, place, depind);
	}
      else
	{
	  place++;
	}
    }
  return NULL;
}
\f
/* Find the next opcode after PREV_ENT that matches PREV_ENT, or return NULL
   if one does not exist.

   It is the caller's responsibility to invoke ia64_free_opcode () to
   release any resources used by the returned entry. */

struct ia64_opcode *
ia64_find_next_opcode (prev_ent)
     struct ia64_opcode *prev_ent;
{
  return ia64_find_matching_opcode (prev_ent->name,
				    prev_ent->ent_index + 1);
}

/* Find the first opcode that matches NAME, or return NULL if it does
   not exist.

   It is the caller's responsibility to invoke ia64_free_opcode () to
   release any resources used by the returned entry. */

struct ia64_opcode *
ia64_find_opcode (name)
     const char *name;
{
  char op[129];
  const char *suffix;
  short place;
  short name_index;

  if (strlen (name) > 128)
    {
      return NULL;
    }
  suffix = name;
  get_opc_prefix (&suffix, op);
  name_index = find_string_ent (op);
  if (name_index < 0)
    {
      return NULL;
    }

  place = find_main_ent (name_index);

  if (place < 0)
    {
      return NULL;
    }
  return ia64_find_matching_opcode (name, place);
}

/* Free any resources used by ENT. */
void
ia64_free_opcode (ent)
     struct ia64_opcode *ent;
{
  free ((void *)ent->name);
  free (ent);
}

const struct ia64_dependency *
ia64_find_dependency (index)
  int index;
{
  index = DEP(index);

  if (index < 0
      || index >= (int)(sizeof(dependencies) / sizeof(dependencies[0])))
    return NULL;

  return &dependencies[index];
}
Commit	Line	Data
800eeca4 JW	1	/* ia64-opc.c -- Functions to access the compacted opcode table
	2	Copyright (C) 1999 Free Software Foundation, Inc.
	3	Written by Bob Manson of Cygnus Solutions, <[email protected]>
	4
	5	This file is part of GDB, GAS, and the GNU binutils.
	6
	7	GDB, GAS, and the GNU binutils are free software; you can redistribute
	8	them and/or modify them under the terms of the GNU General Public
	9	License as published by the Free Software Foundation; either version
	10	2, or (at your option) any later version.
	11
	12	GDB, GAS, and the GNU binutils are distributed in the hope that they
	13	will be useful, but WITHOUT ANY WARRANTY; without even the implied
	14	warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	the GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this file; see the file COPYING. If not, write to the
	19	Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22	#include "ansidecl.h"
	23	#include "libiberty.h"
	24	#include "sysdep.h"
	25	#include "ia64-asmtab.h"
	26	#include "ia64-asmtab.c"
	27
	28	const struct ia64_templ_desc ia64_templ_desc[16] =
	29	{
	30	{ 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, /* 0 */
	31	{ 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" },
	32	{ 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" },
	33	{ 0, { 0, }, "-3-" },
	34	{ 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, /* 4 */
	35	{ 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" },
	36	{ 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" },
	37	{ 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" },
	38	{ 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" }, /* 8 */
	39	{ 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" },
	40	{ 0, { 0, }, "-a-" },
	41	{ 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" },
	42	{ 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" }, /* c */
	43	{ 0, { 0, }, "-d-" },
	44	{ 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" },
	45	{ 0, { 0, }, "-f-" },
	46	};
	47
	48
	49	/* Copy the prefix contained in *PTR (up to a '.' or a NUL) to DEST.
	50	PTR will be adjusted to point to the start of the next portion
	51	of the opcode, or at the NUL character. */
	52
	53	static void
	54	get_opc_prefix (ptr, dest)
	55	const char **ptr;
	56	char *dest;
	57	{
	58	char c = strchr (ptr, '.');
	59	if (c != NULL)
	60	{
	61	memcpy (dest, ptr, c - ptr);
	62	dest[c - *ptr] = '\0';
	63	*ptr = c + 1;
	64	}
65	else
66	{
67	int l = strlen (*ptr);
68	memcpy (dest, *ptr, l);
69	dest[l] = '\0';
70	*ptr += l;
71	}
72	}
73	\f
74	/* Find the index of the entry in the string table corresponding to
75	STR; return -1 if one does not exist. */
76
77	static short
78	find_string_ent (str)
79	const char *str;
80	{
81	short start = 0;
82	short end = sizeof (ia64_strings) / sizeof (const char *);
83	short i = (start + end) / 2;
84
85	if (strcmp (str, ia64_strings[end - 1]) > 0)
86	{
87	return -1;
88	}
89	while (start <= end)
90	{
91	int c = strcmp (str, ia64_strings[i]);
92	if (c < 0)
93	{
94	end = i - 1;
95	}
96	else if (c == 0)
97	{
98	return i;
99	}
100	else
101	{
102	start = i + 1;
103	}
104	i = (start + end) / 2;
105	}
106	return -1;
107	}
108	\f
109	/* Find the opcode in the main opcode table whose name is STRINGINDEX, or
110	return -1 if one does not exist. */
111
112	static short
113	find_main_ent (nameindex)
114	short nameindex;
115	{
116	short start = 0;
117	short end = sizeof (main_table) / sizeof (struct ia64_main_table);
118	short i = (start + end) / 2;
119
120	if (nameindex < main_table[0].name_index
121	\|\| nameindex > main_table[end - 1].name_index)
122	{
123	return -1;
124	}
125	while (start <= end)
126	{
127	if (nameindex < main_table[i].name_index)
128	{
129	end = i - 1;
130	}
131	else if (nameindex == main_table[i].name_index)
132	{
133	while (i > 0 && main_table[i - 1].name_index == nameindex)
134	{
135	i--;
136	}
137	return i;
138	}
139	else
140	{
141	start = i + 1;
142	}
143	i = (start + end) / 2;
144	}
145	return -1;
146	}
147	\f
148	/* Find the index of the entry in the completer table that is part of
149	MAIN_ENT (starting from PREV_COMPLETER) that matches NAME, or
150	return -1 if one does not exist. */
151
152	static short
153	find_completer (main_ent, prev_completer, name)
154	short main_ent;
155	short prev_completer;
156	const char *name;
157	{
158	short name_index = find_string_ent (name);
159
160	if (name_index < 0)
161	{
162	return -1;
163	}
164
165	if (prev_completer == -1)
166	{
167	prev_completer = main_table[main_ent].completers;
168	}
169	else
170	{
171	prev_completer = completer_table[prev_completer].subentries;
172	}
173
174	while (prev_completer != -1)
175	{
176	if (completer_table[prev_completer].name_index == name_index)
177	{
178	return prev_completer;
179	}
180	prev_completer = completer_table[prev_completer].alternative;
181	}
182	return -1;
183	}
184	\f
185	/* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and
186	return the result. */
187
188	static ia64_insn
189	apply_completer (opcode, completer_index)
190	ia64_insn opcode;
191	int completer_index;
192	{
193	ia64_insn mask = completer_table[completer_index].mask;
194	ia64_insn bits = completer_table[completer_index].bits;
195	int shiftamt = (completer_table[completer_index].offset & 63);
196
197	mask = mask << shiftamt;
198	bits = bits << shiftamt;
199	opcode = (opcode & ~mask) \| bits;
200	return opcode;
201	}
202	\f
203	/* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in
204	the dis_table array, and return its value. (BITOFFSET is numbered
205	starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the
206	first byte in OP_POINTER.) */
207
208	static int
209	extract_op_bits (op_pointer, bitoffset, bits)
210	int op_pointer;
211	int bitoffset;
212	int bits;
213	{
214	int res = 0;
215
216	op_pointer += (bitoffset / 8);
217
218	if (bitoffset % 8)
219	{
220	unsigned int op = dis_table[op_pointer++];
221	int numb = 8 - (bitoffset % 8);
222	int mask = (1 << numb) - 1;
223	int bata = (bits < numb) ? bits : numb;
224	int delta = numb - bata;
225
226	res = (res << bata) \| ((op & mask) >> delta);
227	bitoffset += bata;
228	bits -= bata;
229	}
230	while (bits >= 8)
231	{
232	res = (res << 8) \| (dis_table[op_pointer++] & 255);
233	bits -= 8;
234	}
235	if (bits > 0)
236	{
237	unsigned int op = (dis_table[op_pointer++] & 255);
238	res = (res << bits) \| (op >> (8 - bits));
239	}
240	return res;
241	}
242	\f
243	/* Examine the state machine entry at OP_POINTER in the dis_table
244	array, and extract its values into OPVAL and OP. The length of the
245	state entry in bits is returned. */
246
247	static int
248	extract_op (op_pointer, opval, op)
249	int op_pointer;
250	int *opval;
251	unsigned int *op;
252	{
253	int oplen = 5;
254
255	*op = dis_table[op_pointer];
256
257	if ((*op) & 0x40)
258	{
259	opval[0] = extract_op_bits (op_pointer, oplen, 5);
260	oplen += 5;
261	}
262	switch ((*op) & 0x30)
263	{
264	case 0x10:
265	{
266	opval[1] = extract_op_bits (op_pointer, oplen, 8);
267	oplen += 8;
268	opval[1] += op_pointer;
269	break;
270	}
271	case 0x20:
272	{
273	opval[1] = extract_op_bits (op_pointer, oplen, 16);
274	if (! (opval[1] & 32768))
275	{
276	opval[1] += op_pointer;
277	}
278	oplen += 16;
279	break;
280	}
281	case 0x30:
282	{
283	oplen--;
284	opval[2] = extract_op_bits (op_pointer, oplen, 12);
285	oplen += 12;
286	opval[2] \|= 32768;
287	break;
288	}
289	}
290	if (((op) & 0x08) && (((op) & 0x30) != 0x30))
291	{
292	opval[2] = extract_op_bits (op_pointer, oplen, 16);
293	oplen += 16;
294	if (! (opval[2] & 32768))
295	{
296	opval[2] += op_pointer;
297	}
298	}
299	return oplen;
300	}
301	\f
302	/* Returns a non-zero value if the opcode in the main_table list at
303	PLACE matches OPCODE and is of type TYPE. */
304
305	static int
306	opcode_verify (opcode, place, type)
307	ia64_insn opcode;
308	int place;
309	enum ia64_insn_type type;
310	{
311	if (main_table[place].opcode_type != type)
312	{
313	return 0;
314	}
315	if (main_table[place].flags
316	& (IA64_OPCODE_F2_EQ_F3 \| IA64_OPCODE_LEN_EQ_64MCNT))
317	{
318	const struct ia64_operand o1, o2;
319	ia64_insn f2, f3;
320
321	if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3)
322	{
323	o1 = elf64_ia64_operands + IA64_OPND_F2;
324	o2 = elf64_ia64_operands + IA64_OPND_F3;
325	(*o1->extract) (o1, opcode, &f2);
326	(*o2->extract) (o2, opcode, &f3);
327	if (f2 != f3)
328	return 0;
329	}
330	else
331	{
332	ia64_insn len, count;
333
334	/* length must equal 64-count: */
335	o1 = elf64_ia64_operands + IA64_OPND_LEN6;
336	o2 = elf64_ia64_operands + main_table[place].operands[2];
337	(*o1->extract) (o1, opcode, &len);
338	(*o2->extract) (o2, opcode, &count);
339	if (len != 64 - count)
340	return 0;
341	}
342	}
343	return 1;
344	}
345	\f
346	/* Find an instruction entry in the ia64_dis_names array that matches
347	opcode OPCODE and is of type TYPE. Returns either a positive index
348	into the array, or a negative value if an entry for OPCODE could
aa170a07 TW	349	not be found. Checks all matches and returns the one with the highest
aa170a07 TW	350	priority. */
800eeca4 JW	351
	352	static int
	353	locate_opcode_ent (opcode, type)
	354	ia64_insn opcode;
	355	enum ia64_insn_type type;
	356	{
	357	int currtest[41];
	358	int bitpos[41];
	359	int op_ptr[41];
	360	int currstatenum = 0;
aa170a07 TW	361	short found_disent = -1;
aa170a07 TW	362	short found_priority = -1;
800eeca4 JW	363
	364	currtest[currstatenum] = 0;
	365	op_ptr[currstatenum] = 0;
	366	bitpos[currstatenum] = 40;
	367
	368	while (1)
	369	{
	370	int op_pointer = op_ptr[currstatenum];
	371	unsigned int op;
	372	int currbitnum = bitpos[currstatenum];
	373	int oplen;
	374	int opval[3];
	375	int next_op;
	376	int currbit;
	377
	378	oplen = extract_op (op_pointer, opval, &op);
	379
	380	bitpos[currstatenum] = currbitnum;
	381
	382	/* Skip opval[0] bits in the instruction. */
	383	if (op & 0x40)
	384	{
	385	currbitnum -= opval[0];
	386	}
	387
	388	/* The value of the current bit being tested. */
	389	currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0;
	390	next_op = -1;
	391
	392	/* We always perform the tests specified in the current state in
	393	a particular order, falling through to the next test if the
	394	previous one failed. */
	395	switch (currtest[currstatenum])
	396	{
	397	case 0:
	398	currtest[currstatenum]++;
	399	if (currbit == 0 && (op & 0x80))
	400	{
	401	/* Check for a zero bit. If this test solely checks for
	402	a zero bit, we can check for up to 8 consecutive zero
	403	bits (the number to check is specified by the lower 3
	404	bits in the state code.)
	405
	406	If the state instruction matches, we go to the very
	407	next state instruction; otherwise, try the next test. */
	408
	409	if ((op & 0xf8) == 0x80)
	410	{
	411	int count = op & 0x7;
	412	int x;
	413
	414	for (x = 0; x <= count; x++)
	415	{
	416	int i =
	417	opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0;
	418	if (i)
	419	{
	420	break;
	421	}
	422	}
	423	if (x > count)
	424	{
	425	next_op = op_pointer + ((oplen + 7) / 8);
	426	currbitnum -= count;
427	break;
428	}
429	}
430	else if (! currbit)
431	{
432	next_op = op_pointer + ((oplen + 7) / 8);
433	break;
434	}
435	}
436	/* FALLTHROUGH */
437	case 1:
438	/* If the bit in the instruction is one, go to the state
439	instruction specified by opval[1]. */
440	currtest[currstatenum]++;
441	if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30))
442	{
443	next_op = opval[1];
444	break;
445	}
446	/* FALLTHROUGH */
447	case 2:
448	/* Don't care. Skip the current bit and go to the state
449	instruction specified by opval[2].
450
451	An encoding of 0x30 is special; this means that a 12-bit
452	offset into the ia64_dis_names[] array is specified. */
453	currtest[currstatenum]++;
454	if ((op & 0x08) \|\| ((op & 0x30) == 0x30))
455	{
456	next_op = opval[2];
457	break;
458	}
459	}
460
461	/* If bit 15 is set in the address of the next state, an offset
462	in the ia64_dis_names array was specified instead. We then
463	check to see if an entry in the list of opcodes matches the
464	opcode we were given; if so, we have succeeded. */
465
466	if ((next_op >= 0) && (next_op & 32768))
467	{
468	short disent = next_op & 32767;
aa170a07	469	short priority = -1;
800eeca4 JW	470
	471	if (next_op > 65535)
	472	{
	473	abort ();
	474	}
	475
	476	/* Run through the list of opcodes to check, trying to find
	477	one that matches. */
	478	while (disent >= 0)
	479	{
	480	int place = ia64_dis_names[disent].insn_index;
	481
aa170a07 TW	482	priority = ia64_dis_names[disent].priority;
	483
	484	if (opcode_verify (opcode, place, type)
	485	&& priority > found_priority)
800eeca4 JW	486	{
	487	break;
	488	}
	489	if (ia64_dis_names[disent].next_flag)
	490	{
	491	disent++;
	492	}
	493	else
	494	{
	495	disent = -1;
	496	}
	497	}
	498
	499	if (disent >= 0)
	500	{
aa170a07 TW	501	found_disent = disent;
aa170a07 TW	502	found_priority = priority;
800eeca4	503	}
aa170a07 TW	504	/* Try the next test in this state, regardless of whether a match
	505	was found. */
	506	next_op = -2;
800eeca4 JW	507	}
	508
	509	/* next_op == -1 is "back up to the previous state".
	510	next_op == -2 is "stay in this state and try the next test".
	511	Otherwise, transition to the state indicated by next_op. */
	512
	513	if (next_op == -1)
	514	{
	515	currstatenum--;
	516	if (currstatenum < 0)
	517	{
aa170a07	518	return found_disent;
800eeca4 JW	519	}
	520	}
	521	else if (next_op >= 0)
	522	{
	523	currstatenum++;
	524	bitpos[currstatenum] = currbitnum - 1;
	525	op_ptr[currstatenum] = next_op;
	526	currtest[currstatenum] = 0;
	527	}
	528	}
	529	}
	530	\f
	531	/* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */
	532
	533	static struct ia64_opcode *
	534	make_ia64_opcode (opcode, name, place, depind)
	535	ia64_insn opcode;
	536	const char *name;
	537	int place;
	538	int depind;
	539	{
	540	struct ia64_opcode *res =
	541	(struct ia64_opcode *) xmalloc (sizeof (struct ia64_opcode));
	542	res->name = xstrdup (name);
	543	res->type = main_table[place].opcode_type;
	544	res->num_outputs = main_table[place].num_outputs;
	545	res->opcode = opcode;
	546	res->mask = main_table[place].mask;
	547	res->operands[0] = main_table[place].operands[0];
	548	res->operands[1] = main_table[place].operands[1];
	549	res->operands[2] = main_table[place].operands[2];
	550	res->operands[3] = main_table[place].operands[3];
	551	res->operands[4] = main_table[place].operands[4];
	552	res->flags = main_table[place].flags;
	553	res->ent_index = place;
	554	res->dependencies = &op_dependencies[depind];
	555	return res;
	556	}
	557	\f
	558	/* Determine the ia64_opcode entry for the opcode specified by INSN
	559	and TYPE. If a valid entry is not found, return NULL. */
	560	struct ia64_opcode *
	561	ia64_dis_opcode (insn, type)
	562	ia64_insn insn;
	563	enum ia64_insn_type type;
	564	{
	565	int disent = locate_opcode_ent (insn, type);
	566
	567	if (disent < 0)
	568	{
	569	return NULL;
	570	}
	571	else
	572	{
	573	unsigned int cb = ia64_dis_names[disent].completer_index;
	574	static char name[128];
	575	int place = ia64_dis_names[disent].insn_index;
	576	int ci = main_table[place].completers;
	577	ia64_insn tinsn = main_table[place].opcode;
	578
	579	strcpy (name, ia64_strings [main_table[place].name_index]);
	580
	581	while (cb)
	582	{
583	if (cb & 1)
584	{
585	int cname = completer_table[ci].name_index;
586
587	tinsn = apply_completer (tinsn, ci);
588
589	if (ia64_strings[cname][0] != '\0')
590	{
591	strcat (name, ".");
592	strcat (name, ia64_strings[cname]);
593	}
594	if (cb != 1)
595	{
596	ci = completer_table[ci].subentries;
597	}
598	}
599	else
600	{
601	ci = completer_table[ci].alternative;
602	}
603	if (ci < 0)
604	{
605	abort ();
606	}
607	cb = cb >> 1;
608	}
609	if (tinsn != (insn & main_table[place].mask))
610	{
611	abort ();
612	}
613	return make_ia64_opcode (insn, name, place,
614	completer_table[ci].dependencies);
615	}
616	}
617	\f
618	/* Search the main_opcode table starting from PLACE for an opcode that
619	matches NAME. Return NULL if one is not found. */
620
621	static struct ia64_opcode *
622	ia64_find_matching_opcode (name, place)
623	const char *name;
624	short place;
625	{
626	char op[129];
627	const char *suffix;
628	short name_index;
629
630	if (strlen (name) > 128)
631	{
632	return NULL;
633	}
634	suffix = name;
635	get_opc_prefix (&suffix, op);
636	name_index = find_string_ent (op);
637	if (name_index < 0)
638	{
639	return NULL;
640	}
641
642	while (main_table[place].name_index == name_index)
643	{
644	const char *curr_suffix = suffix;
645	ia64_insn curr_insn = main_table[place].opcode;
646	short completer = -1;
647
648	do {
649	if (suffix[0] == '\0')
650	{
651	completer = find_completer (place, completer, suffix);
652	}
653	else
654	{
655	get_opc_prefix (&curr_suffix, op);
656	completer = find_completer (place, completer, op);
657	}
658	if (completer != -1)
659	{
660	curr_insn = apply_completer (curr_insn, completer);
661	}
662	} while (completer != -1 && curr_suffix[0] != '\0');
663
664	if (completer != -1 && curr_suffix[0] == '\0'
665	&& completer_table[completer].terminal_completer)
666	{
667	int depind = completer_table[completer].dependencies;
668	return make_ia64_opcode (curr_insn, name, place, depind);
669	}
670	else
671	{
672	place++;
673	}
674	}
675	return NULL;
676	}
677	\f
678	/* Find the next opcode after PREV_ENT that matches PREV_ENT, or return NULL
679	if one does not exist.
680
681	It is the caller's responsibility to invoke ia64_free_opcode () to
682	release any resources used by the returned entry. */
683
684	struct ia64_opcode *
685	ia64_find_next_opcode (prev_ent)
686	struct ia64_opcode *prev_ent;
687	{
688	return ia64_find_matching_opcode (prev_ent->name,
689	prev_ent->ent_index + 1);
690	}
691
692	/* Find the first opcode that matches NAME, or return NULL if it does
693	not exist.
694
695	It is the caller's responsibility to invoke ia64_free_opcode () to
696	release any resources used by the returned entry. */
697
698	struct ia64_opcode *
699	ia64_find_opcode (name)
700	const char *name;
701	{
702	char op[129];
703	const char *suffix;
704	short place;
705	short name_index;
706
707	if (strlen (name) > 128)
708	{
709	return NULL;
710	}
711	suffix = name;
712	get_opc_prefix (&suffix, op);
713	name_index = find_string_ent (op);
714	if (name_index < 0)
715	{
716	return NULL;
717	}
718
719	place = find_main_ent (name_index);
720
721	if (place < 0)
722	{
723	return NULL;
724	}
725	return ia64_find_matching_opcode (name, place);
726	}
727
728	/* Free any resources used by ENT. */
729	void
730	ia64_free_opcode (ent)
731	struct ia64_opcode *ent;
732	{
733	free ((void *)ent->name);
734	free (ent);
735	}
736
737	const struct ia64_dependency *
738	ia64_find_dependency (index)
739	int index;
740	{
741	index = DEP(index);
742
514829c3 JW	743	if (index < 0
514829c3 JW	744	\|\| index >= (int)(sizeof(dependencies) / sizeof(dependencies[0])))
800eeca4 JW	745	return NULL;
	746
	747	return &dependencies[index];
	748	}