%{

/* Parser for i386 CPU description.

   Copyright (C) 2004, 2005, 2007, 2008, 2009 Red Hat, Inc.

   Written by Ulrich Drepper <drepper@redhat.com>, 2004.

   This file is free software; you can redistribute it and/or modify

   it under the terms of either

     * the GNU Lesser General Public License as published by the Free

       Software Foundation; either version 3 of the License, or (at

       your option) any later version

   or

     * the GNU General Public License as published by the Free

       Software Foundation; either version 2 of the License, or (at

       your option) any later version

   or both in parallel, as here.

   elfutils 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 copies of the GNU General Public License and

   the GNU Lesser General Public License along with this program.  If

   not, see <http://www.gnu.org/licenses/>.  */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <inttypes.h>

#include <libintl.h>

#include <math.h>

#include <obstack.h>

#include <search.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libeu.h>

#include <system.h>

#define obstack_chunk_alloc xmalloc

#define obstack_chunk_free free

/* The error handler.  */

static void yyerror (const char *s);

extern int yylex (void);

extern int i386_lineno;

extern char *infname;

struct known_bitfield

{

  char *name;

  unsigned long int bits;

  int tmp;

};

struct bitvalue

{

  enum bittype { zeroone, field, failure } type;

  union

  {

    unsigned int value;

    struct known_bitfield *field;

  };

  struct bitvalue *next;

};

struct argname

{

  enum nametype { string, nfield } type;

  union

  {

    char *str;

    struct known_bitfield *field;

  };

  struct argname *next;

};

struct argument

{

  struct argname *name;

  struct argument *next;

};

struct instruction

{

  /* The byte encoding.  */

  struct bitvalue *bytes;

  /* Prefix possible.  */

  int repe;

  int rep;

  /* Mnemonic.  */

  char *mnemonic;

  /* Suffix.  */

  enum { suffix_none = 0, suffix_w, suffix_w0, suffix_W, suffix_tttn,

	 suffix_w1, suffix_W1, suffix_D } suffix;

  /* Flag set if modr/m is used.  */

  int modrm;

  /* Operands.  */

  struct operand

  {

    char *fct;

    char *str;

    int off1;

    int off2;

    int off3;

  } operands[3];

  struct instruction *next;

};

struct synonym

{

  char *from;

  char *to;

};

struct suffix

{

  char *name;

  int idx;

};

struct argstring

{

  char *str;

  int idx;

  int off;

};

static struct known_bitfield ax_reg =

  {

    .name = "ax", .bits = 0, .tmp = 0

  };

static struct known_bitfield dx_reg =

  {

    .name = "dx", .bits = 0, .tmp = 0

  };

static struct known_bitfield di_reg =

  {

    .name = "es_di", .bits = 0, .tmp = 0

  };

static struct known_bitfield si_reg =

  {

    .name = "ds_si", .bits = 0, .tmp = 0

  };

static struct known_bitfield bx_reg =

  {

    .name = "ds_bx", .bits = 0, .tmp = 0

  };

static int bitfield_compare (const void *p1, const void *p2);

static void new_bitfield (char *name, unsigned long int num);

static void check_bits (struct bitvalue *value);

static int check_duplicates (struct bitvalue *val);

static int check_argsdef (struct bitvalue *bitval, struct argument *args);

static int check_bitsused (struct bitvalue *bitval,

			   struct known_bitfield *suffix,

			   struct argument *args);

static struct argname *combine (struct argname *name);

static void fillin_arg (struct bitvalue *bytes, struct argname *name,

			struct instruction *instr, int n);

static void find_numbers (void);

static int compare_syn (const void *p1, const void *p2);

static int compare_suf (const void *p1, const void *p2);

static void instrtable_out (void);

#if 0

static void create_mnemonic_table (void);

#endif

static void *bitfields;

static struct instruction *instructions;

static size_t ninstructions;

static void *synonyms;

static void *suffixes;

static int nsuffixes;

static void *mnemonics;

size_t nmnemonics;

extern FILE *outfile;

/* Number of bits used mnemonics.  */

#if 0

static size_t best_mnemonic_bits;

#endif

%}

%union {

  unsigned long int num;

  char *str;

  char ch;

  struct known_bitfield *field;

  struct bitvalue *bit;

  struct argname *name;

  struct argument *arg;

}

%token kMASK

%token kPREFIX

%token kSUFFIX

%token kSYNONYM

%token <str> kID

%token <num> kNUMBER

%token kPERCPERC

%token <str> kBITFIELD

%token <ch> kCHAR

%token kSPACE

%type <bit> bit byte bytes

%type <field> bitfieldopt

%type <name> argcomp arg

%type <arg> args optargs

%defines

%%

spec:		  masks kPERCPERC '\n' instrs

		    {

		      if (error_message_count != 0)

			error (EXIT_FAILURE, 0,

			       "terminated due to previous error");

		      instrtable_out ();

		    }

		;

masks:		  masks '\n' mask

		| mask

		;

mask:		  kMASK kBITFIELD kNUMBER

		    { new_bitfield ($2, $3); }

		| kPREFIX kBITFIELD

		    { new_bitfield ($2, -1); }

		| kSUFFIX kBITFIELD

		    { new_bitfield ($2, -2); }

		| kSYNONYM kBITFIELD kBITFIELD

		    {

		      struct synonym *newp = xmalloc (sizeof (*newp));

		      newp->from = $2;

		      newp->to = $3;

		      if (tfind (newp, &synonyms, compare_syn) != NULL)

			error (0, 0,

			       "%d: duplicate definition for synonym '%s'",

			       i386_lineno, $2);

		      else if (tsearch ( newp, &synonyms, compare_syn) == NULL)

			error (EXIT_FAILURE, 0, "tsearch");

		    }

		|

		;

instrs:		  instrs '\n' instr

		| instr

		;

instr:		  bytes ':' bitfieldopt kID bitfieldopt optargs

		    {

		      if ($3 != NULL && strcmp ($3->name, "RE") != 0

			  && strcmp ($3->name, "R") != 0)

			{

			  error (0, 0, "%d: only 'R' and 'RE' prefix allowed",

				 i386_lineno - 1);

			}

		      if (check_duplicates ($1) == 0

			  && check_argsdef ($1, $6) == 0

			  && check_bitsused ($1, $5, $6) == 0)

			{

			  struct instruction *newp = xcalloc (sizeof (*newp),

							      1);

			  if ($3 != NULL)

			    {

			      if (strcmp ($3->name, "RE") == 0)

				newp->repe = 1;

			      else if (strcmp ($3->name, "R") == 0)

				newp->rep = 1;

			    }

			  newp->bytes = $1;

			  newp->mnemonic = $4;

			  if (newp->mnemonic != (void *) -1l

			      && tfind ($4, &mnemonics,

					(int (*)(const void *, const void *)) strcmp) == NULL)

			    {

			      if (tsearch ($4, &mnemonics,

					   (int (*)(const void *, const void *)) strcmp) == NULL)

				error (EXIT_FAILURE, errno, "tsearch");

			      ++nmnemonics;

			    }

			  if ($5 != NULL)

			    {

			      if (strcmp ($5->name, "w") == 0)

				newp->suffix = suffix_w;

			      else if (strcmp ($5->name, "w0") == 0)

				newp->suffix = suffix_w0;

			      else if (strcmp ($5->name, "tttn") == 0)

				newp->suffix = suffix_tttn;

			      else if (strcmp ($5->name, "w1") == 0)

				newp->suffix = suffix_w1;

			      else if (strcmp ($5->name, "W") == 0)

				newp->suffix = suffix_W;

			      else if (strcmp ($5->name, "W1") == 0)

				newp->suffix = suffix_W1;

			      else if (strcmp ($5->name, "D") == 0)

				newp->suffix = suffix_D;

			      else

				error (EXIT_FAILURE, 0,

				       "%s: %d: unknown suffix '%s'",

				       infname, i386_lineno - 1, $5->name);

			      struct suffix search = { .name = $5->name };

			      if (tfind (&search, &suffixes, compare_suf)

				  == NULL)

				{

				  struct suffix *ns = xmalloc (sizeof (*ns));

				  ns->name = $5->name;

				  ns->idx = ++nsuffixes;

				  if (tsearch (ns, &suffixes, compare_suf)

				      == NULL)

				    error (EXIT_FAILURE, errno, "tsearch");

				}

			    }

			  struct argument *args = $6;

			  int n = 0;

			  while (args != NULL)

			    {

			      fillin_arg ($1, args->name, newp, n);

			      args = args->next;

			      ++n;

			    }

			  newp->next = instructions;

			  instructions = newp;

			  ++ninstructions;

			}

		    }

		|

		;

bitfieldopt:	  kBITFIELD

		    {

		      struct known_bitfield search;

		      search.name = $1;

		      struct known_bitfield **res;

		      res = tfind (&search, &bitfields, bitfield_compare);

		      if (res == NULL)

			{

			  error (0, 0, "%d: unknown bitfield '%s'",

				 i386_lineno, search.name);

			  $$ = NULL;

			}

		      else

			$$ = *res;

		    }

		|

		    { $$ = NULL; }

		;

bytes:		  bytes ',' byte

		    {

		      check_bits ($3);

		      struct bitvalue *runp = $1;

		      while (runp->next != NULL)

			runp = runp->next;

		      runp->next = $3;

		      $$ = $1;

		    }

		| byte

		    {

		      check_bits ($1);

		      $$ = $1;

		    }

		;

byte:		  byte bit

		    {

		      struct bitvalue *runp = $1;

		      while (runp->next != NULL)

			runp = runp->next;

		      runp->next = $2;

		      $$ = $1;

		    }

		| bit

		    { $$ = $1; }

		;

bit:		  '0'

		    {

		      $$ = xmalloc (sizeof (struct bitvalue));

		      $$->type = zeroone;

		      $$->value = 0;

		      $$->next = NULL;

		    }

		| '1'

		    {

		      $$ = xmalloc (sizeof (struct bitvalue));

		      $$->type = zeroone;

		      $$->value = 1;

		      $$->next = NULL;

		    }

		| kBITFIELD

		    {

		      $$ = xmalloc (sizeof (struct bitvalue));

		      struct known_bitfield search;

		      search.name = $1;

		      struct known_bitfield **res;

		      res = tfind (&search, &bitfields, bitfield_compare);

		      if (res == NULL)

			{

			  error (0, 0, "%d: unknown bitfield '%s'",

				 i386_lineno, search.name);

			  $$->type = failure;

			}

		      else

			{

			  $$->type = field;

			  $$->field = *res;

			}

		      $$->next = NULL;

		    }

		;

optargs:	  kSPACE args

		    { $$ = $2; }

		|

		    { $$ = NULL; }

		;

args:		  args ',' arg

		    {

		      struct argument *runp = $1;

		      while (runp->next != NULL)

			runp = runp->next;

		      runp->next = xmalloc (sizeof (struct argument));

		      runp->next->name = combine ($3);

		      runp->next->next = NULL;

		      $$ = $1;

		    }

		| arg

		    {

		      $$ = xmalloc (sizeof (struct argument));

		      $$->name = combine ($1);

		      $$->next = NULL;

		    }

		;

arg:		  arg argcomp

		    {

		      struct argname *runp = $1;

		      while (runp->next != NULL)

			runp = runp->next;

		      runp->next = $2;

		      $$ = $1;

		    }

		| argcomp

		    { $$ = $1; }

		;

argcomp:	  kBITFIELD

		    {

		      $$ = xmalloc (sizeof (struct argname));

		      $$->type = nfield;

		      $$->next = NULL;

		      struct known_bitfield search;

		      search.name = $1;

		      struct known_bitfield **res;

		      res = tfind (&search, &bitfields, bitfield_compare);

		      if (res == NULL)

			{

			  if (strcmp ($1, "ax") == 0)

			    $$->field = &ax_reg;

			  else if (strcmp ($1, "dx") == 0)

			    $$->field = &dx_reg;

			  else if (strcmp ($1, "es_di") == 0)

			    $$->field = &di_reg;

			  else if (strcmp ($1, "ds_si") == 0)

			    $$->field = &si_reg;

			  else if (strcmp ($1, "ds_bx") == 0)

			    $$->field = &bx_reg;

			  else

			    {

			      error (0, 0, "%d: unknown bitfield '%s'",

				     i386_lineno, search.name);

			      $$->field = NULL;

			    }

			}

		      else

			$$->field = *res;

		    }

		| kCHAR

		    {

		      $$ = xmalloc (sizeof (struct argname));

		      $$->type = string;

		      $$->next = NULL;

		      $$->str = xmalloc (2);

		      $$->str[0] = $1;

		      $$->str[1] = '\0';

		    }

		| kID

		    {

		      $$ = xmalloc (sizeof (struct argname));

		      $$->type = string;

		      $$->next = NULL;

		      $$->str = $1;

		    }

		| ':'

		    {

		      $$ = xmalloc (sizeof (struct argname));

		      $$->type = string;

		      $$->next = NULL;

		      $$->str = xmalloc (2);

		      $$->str[0] = ':';

		      $$->str[1] = '\0';

		    }

		;

%%

static void

yyerror (const char *s)

{

  error (0, 0, gettext ("while reading i386 CPU description: %s at line %d"),

         gettext (s), i386_lineno);

}

static int

bitfield_compare (const void *p1, const void *p2)

{

  struct known_bitfield *f1 = (struct known_bitfield *) p1;

  struct known_bitfield *f2 = (struct known_bitfield *) p2;

  return strcmp (f1->name, f2->name);

}

static void

new_bitfield (char *name, unsigned long int num)

{

  struct known_bitfield *newp = xmalloc (sizeof (struct known_bitfield));

  newp->name = name;

  newp->bits = num;

  newp->tmp = 0;

  if (tfind (newp, &bitfields, bitfield_compare) != NULL)

    {

      error (0, 0, "%d: duplicated definition of bitfield '%s'",

	     i386_lineno, name);

      free (name);

      free (newp);

      return;

    }

  if (tsearch (newp, &bitfields, bitfield_compare) == NULL)

    error (EXIT_FAILURE, errno, "%d: cannot insert new bitfield '%s'",

	   i386_lineno, name);

}

/* Check that the number of bits is a multiple of 8.  */

static void

check_bits (struct bitvalue *val)

{

  struct bitvalue *runp = val;

  unsigned int total = 0;

  while (runp != NULL)

    {

      if (runp->type == zeroone)

	++total;

      else if (runp->field == NULL)

	/* No sense doing anything, the field is not known.  */

	return;

      else

	total += runp->field->bits;

      runp = runp->next;

    }

  if (total % 8 != 0)

    {

      struct obstack os;

      obstack_init (&os);

      while (val != NULL)

	{

	  if (val->type == zeroone)

	    obstack_printf (&os, "%u", val->value);

	  else

	    obstack_printf (&os, "{%s}", val->field->name);

	  val = val->next;

	}

      obstack_1grow (&os, '\0');

      error (0, 0, "%d: field '%s' not a multiple of 8 bits in size",

	     i386_lineno, (char *) obstack_finish (&os);;

      obstack_free (&os, NULL);

    }

}

static int

check_duplicates (struct bitvalue *val)

{

  static int testcnt;

  ++testcnt;

  int result = 0;

  while (val != NULL)

    {

      if (val->type == field && val->field != NULL)

	{

	  if (val->field->tmp == testcnt)

	    {

	      error (0, 0, "%d: bitfield '%s' used more than once",

		     i386_lineno - 1, val->field->name);

	      result = 1;

	    }

	  val->field->tmp = testcnt;

	}

      val = val->next;

    }

  return result;

}

static int

check_argsdef (struct bitvalue *bitval, struct argument *args)

{

  int result = 0;

  while (args != NULL)

    {

      for (struct argname *name = args->name; name != NULL; name = name->next)

	if (name->type == nfield && name->field != NULL

	    && name->field != &ax_reg && name->field != &dx_reg

	    && name->field != &di_reg && name->field != &si_reg

	    && name->field != &bx_reg)

	  {

	    struct bitvalue *runp = bitval;

	    while (runp != NULL)

	      if (runp->type == field && runp->field == name->field)

		break;

	      else

		runp = runp->next;

	    if (runp == NULL)

	      {

		error (0, 0, "%d: unknown bitfield '%s' used in output format",

		       i386_lineno - 1, name->field->name);

		result = 1;

	      }

	  }

      args = args->next;

    }

  return result;

}

static int

check_bitsused (struct bitvalue *bitval, struct known_bitfield *suffix,

		struct argument *args)

{

  int result = 0;

  while (bitval != NULL)

    {

      if (bitval->type == field && bitval->field != NULL

	  && bitval->field != suffix

	  /* {w} is handled special.  */

	  && strcmp (bitval->field->name, "w") != 0)

	{

	  struct argument *runp;

	  for (runp = args; runp != NULL; runp = runp->next)

	    {

	      struct argname *name = runp->name;

	      while (name != NULL)

		if (name->type == nfield && name->field == bitval->field)

		  break;

		else

		  name = name->next;

	      if (name != NULL)

		break;

	    }

#if 0

	  if (runp == NULL)

	    {

	      error (0, 0, "%d: bitfield '%s' not used",

		     i386_lineno - 1, bitval->field->name);

	      result = 1;

	    }

#endif

	}

      bitval = bitval->next;

    }

  return result;

}

static struct argname *

combine (struct argname *name)

{

  struct argname *last_str = NULL;

  for (struct argname *runp = name; runp != NULL; runp = runp->next)

    {

      if (runp->type == string)

	{

	  if (last_str == NULL)

	    last_str = runp;

	  else

	    {

	      last_str->str = xrealloc (last_str->str,

					strlen (last_str->str)

					+ strlen (runp->str) + 1);

	      strcat (last_str->str, runp->str);

	      last_str->next = runp->next;

	    }

	}

      else

	last_str = NULL;

    }

  return name;

}

#define obstack_grow_str(ob, str) obstack_grow (ob, str, strlen (str))

static void

fillin_arg (struct bitvalue *bytes, struct argname *name,

	    struct instruction *instr, int n)

{

  static struct obstack ob;

  static int initialized;

  if (! initialized)

    {

      initialized = 1;

      obstack_init (&ob;;

    }

  struct argname *runp = name;

  int cnt = 0;

  while (runp != NULL)

    {

      /* We ignore strings in the function name.  */

      if (runp->type == string)

	{

	  if (instr->operands[n].str != NULL)

	    error (EXIT_FAILURE, 0,

		   "%d: cannot have more than one string parameter",

		   i386_lineno - 1);

	  instr->operands[n].str = runp->str;

	}

      else

	{

	  assert (runp->type == nfield);

	  /* Construct the function name.  */

	  if (cnt++ > 0)

	    obstack_1grow (&ob, '$');

	  if (runp->field == NULL)

	    /* Add some string which contains invalid characters.  */

	    obstack_grow_str (&ob, "!!!INVALID!!!");

	  else

	    {

	      char *fieldname = runp->field->name;

	      struct synonym search = { .from = fieldname };

	      struct synonym **res = tfind (&search, &synonyms, compare_syn);

	      if (res != NULL)

		fieldname = (*res)->to;

	      obstack_grow_str (&ob, fieldname);

	    }

	  /* Now compute the bit offset of the field.  */

	  struct bitvalue *b = bytes;

	  int bitoff = 0;

	  if (runp->field != NULL)

	    while (b != NULL)

	      {

		if (b->type == field && b->field != NULL)

		  {

		    if (strcmp (b->field->name, runp->field->name) == 0)

		      break;

		    bitoff += b->field->bits;

		  }

		else

		  ++bitoff;

		b = b->next;

	      }

	  if (instr->operands[n].off1 == 0)

	    instr->operands[n].off1 = bitoff;

	  else if (instr->operands[n].off2 == 0)

	    instr->operands[n].off2 = bitoff;

	  else if (instr->operands[n].off3 == 0)

	    instr->operands[n].off3 = bitoff;

	  else

	    error (EXIT_FAILURE, 0,

		   "%d: cannot have more than three fields in parameter",

		   i386_lineno - 1);

	  if  (runp->field != NULL

	       && strncasecmp (runp->field->name, "mod", 3) == 0)

	    instr->modrm = 1;

	}

      runp = runp->next;

    }

  if (obstack_object_size (&ob) == 0)

    obstack_grow_str (&ob, "string");

  obstack_1grow (&ob, '\0');

  char *fct = obstack_finish (&ob;;

  instr->operands[n].fct = fct;

}

#if 0

static void

nameout (const void *nodep, VISIT value, int level)

{

  if (value == leaf || value == postorder)

    printf ("  %s\n", *(const char **) nodep);

}

#endif

static int

compare_argstring (const void *p1, const void *p2)

{

  const struct argstring *a1 = (const struct argstring *) p1;

  const struct argstring *a2 = (const struct argstring *) p2;