URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [i386-gen.c] - Blame information for rev 252

Go to most recent revision | Details | Compare with Previous | View Log


/* Copyright 2007, 2008, 2009
   Free Software Foundation, Inc.
 
   This file is part of the GNU opcodes library.
 
   This library 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 3, or (at your option)
   any later version.
 
   It 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 this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
#include "sysdep.h"
#include <stdio.h>
#include <errno.h>
#include "getopt.h"
#include "libiberty.h"
#include "hashtab.h"
#include "safe-ctype.h"
 
#include "i386-opc.h"
 
#include <libintl.h>
#define _(String) gettext (String)
 
static const char *program_name = NULL;
static int debug = 0;
 
typedef struct initializer
{
  const char *name;
  const char *init;
} initializer;
 
static initializer cpu_flag_init[] =
{
  { "CPU_UNKNOWN_FLAGS",
    "~CpuL1OM" },
  { "CPU_GENERIC32_FLAGS",
    "Cpu186|Cpu286|Cpu386" },
  { "CPU_GENERIC64_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2|CpuLM" },
  { "CPU_NONE_FLAGS",
   "0" },
  { "CPU_I186_FLAGS",
    "Cpu186" },
  { "CPU_I286_FLAGS",
    "Cpu186|Cpu286" },
  { "CPU_I386_FLAGS",
    "Cpu186|Cpu286|Cpu386" },
  { "CPU_I486_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486" },
  { "CPU_I586_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu387" },
  { "CPU_I686_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687" },
  { "CPU_P2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX" },
  { "CPU_P3_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX|CpuSSE" },
  { "CPU_P4_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2" },
  { "CPU_NOCONA_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuLM" },
  { "CPU_CORE_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
  { "CPU_CORE2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuLM" },
  { "CPU_COREI7_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuRdtscp|CpuLM" },
  { "CPU_K6_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX" },
  { "CPU_K6_2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX|Cpu3dnow" },
  { "CPU_ATHLON_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA" },
  { "CPU_K8_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
  { "CPU_AMDFAM10_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM" },
  { "CPU_8087_FLAGS",
    "Cpu8087" },
  { "CPU_287_FLAGS",
    "Cpu287" },
  { "CPU_387_FLAGS",
    "Cpu387" },
  { "CPU_ANY87_FLAGS",
    "Cpu8087|Cpu287|Cpu387|Cpu687|CpuFISTTP" },
  { "CPU_CLFLUSH_FLAGS",
    "CpuClflush" },
  { "CPU_SYSCALL_FLAGS",
    "CpuSYSCALL" },
  { "CPU_MMX_FLAGS",
    "CpuMMX" },
  { "CPU_SSE_FLAGS",
    "CpuMMX|CpuSSE" },
  { "CPU_SSE2_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2" },
  { "CPU_SSE3_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
  { "CPU_SSSE3_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
  { "CPU_SSE4_1_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
  { "CPU_SSE4_2_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2" },
  { "CPU_ANY_SSE_FLAGS",
    "CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuSSE4a|CpuAVX" },
  { "CPU_VMX_FLAGS",
    "CpuVMX" },
  { "CPU_SMX_FLAGS",
    "CpuSMX" },
  { "CPU_XSAVE_FLAGS",
    "CpuXsave" },
  { "CPU_AES_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAES" },
  { "CPU_PCLMUL_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuPCLMUL" },
  { "CPU_FMA_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA" },
  { "CPU_FMA4_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA4" },
  { "CPU_MOVBE_FLAGS",
    "CpuMovbe" },
  { "CPU_RDTSCP_FLAGS",
    "CpuRdtscp" },
  { "CPU_EPT_FLAGS",
    "CpuEPT" },
  { "CPU_3DNOW_FLAGS",
    "CpuMMX|Cpu3dnow" },
  { "CPU_3DNOWA_FLAGS",
    "CpuMMX|Cpu3dnow|Cpu3dnowA" },
  { "CPU_PADLOCK_FLAGS",
    "CpuPadLock" },
  { "CPU_SVME_FLAGS",
    "CpuSVME" },
  { "CPU_SSE4A_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
  { "CPU_ABM_FLAGS",
    "CpuABM" },
  { "CPU_AVX_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX" },
  { "CPU_ANY_AVX_FLAGS",
    "CpuAVX" },
  { "CPU_L1OM_FLAGS",
    "unknown" },
};
 
static initializer operand_type_init[] =
{
  { "OPERAND_TYPE_NONE",
    "0" },
  { "OPERAND_TYPE_REG8",
    "Reg8" },
  { "OPERAND_TYPE_REG16",
    "Reg16" },
  { "OPERAND_TYPE_REG32",
    "Reg32" },
  { "OPERAND_TYPE_REG64",
    "Reg64" },
  { "OPERAND_TYPE_IMM1",
    "Imm1" },
  { "OPERAND_TYPE_IMM8",
    "Imm8" },
  { "OPERAND_TYPE_IMM8S",
    "Imm8S" },
  { "OPERAND_TYPE_IMM16",
    "Imm16" },
  { "OPERAND_TYPE_IMM32",
    "Imm32" },
  { "OPERAND_TYPE_IMM32S",
    "Imm32S" },
  { "OPERAND_TYPE_IMM64",
    "Imm64" },
  { "OPERAND_TYPE_BASEINDEX",
    "BaseIndex" },
  { "OPERAND_TYPE_DISP8",
    "Disp8" },
  { "OPERAND_TYPE_DISP16",
    "Disp16" },
  { "OPERAND_TYPE_DISP32",
    "Disp32" },
  { "OPERAND_TYPE_DISP32S",
    "Disp32S" },
  { "OPERAND_TYPE_DISP64",
    "Disp64" },
  { "OPERAND_TYPE_INOUTPORTREG",
    "InOutPortReg" },
  { "OPERAND_TYPE_SHIFTCOUNT",
    "ShiftCount" },
  { "OPERAND_TYPE_CONTROL",
    "Control" },
  { "OPERAND_TYPE_TEST",
    "Test" },
  { "OPERAND_TYPE_DEBUG",
    "FloatReg" },
  { "OPERAND_TYPE_FLOATREG",
    "FloatReg" },
  { "OPERAND_TYPE_FLOATACC",
    "FloatAcc" },
  { "OPERAND_TYPE_SREG2",
    "SReg2" },
  { "OPERAND_TYPE_SREG3",
    "SReg3" },
  { "OPERAND_TYPE_ACC",
    "Acc" },
  { "OPERAND_TYPE_JUMPABSOLUTE",
    "JumpAbsolute" },
  { "OPERAND_TYPE_REGMMX",
    "RegMMX" },
  { "OPERAND_TYPE_REGXMM",
    "RegXMM" },
  { "OPERAND_TYPE_REGYMM",
    "RegYMM" },
  { "OPERAND_TYPE_ESSEG",
    "EsSeg" },
  { "OPERAND_TYPE_ACC32",
    "Reg32|Acc|Dword" },
  { "OPERAND_TYPE_ACC64",
    "Reg64|Acc|Qword" },
  { "OPERAND_TYPE_INOUTPORTREG",
    "InOutPortReg" },
  { "OPERAND_TYPE_REG16_INOUTPORTREG",
    "Reg16|InOutPortReg" },
  { "OPERAND_TYPE_DISP16_32",
    "Disp16|Disp32" },
  { "OPERAND_TYPE_ANYDISP",
    "Disp8|Disp16|Disp32|Disp32S|Disp64" },
  { "OPERAND_TYPE_IMM16_32",
    "Imm16|Imm32" },
  { "OPERAND_TYPE_IMM16_32S",
    "Imm16|Imm32S" },
  { "OPERAND_TYPE_IMM16_32_32S",
    "Imm16|Imm32|Imm32S" },
  { "OPERAND_TYPE_IMM32_32S_DISP32",
    "Imm32|Imm32S|Disp32" },
  { "OPERAND_TYPE_IMM64_DISP64",
    "Imm64|Disp64" },
  { "OPERAND_TYPE_IMM32_32S_64_DISP32",
    "Imm32|Imm32S|Imm64|Disp32" },
  { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
    "Imm32|Imm32S|Imm64|Disp32|Disp64" },
};
 
typedef struct bitfield
{
  int position;
  int value;
  const char *name;
} bitfield;
 
#define BITFIELD(n) { n, 0, #n }
 
static bitfield cpu_flags[] =
{
  BITFIELD (Cpu186),
  BITFIELD (Cpu286),
  BITFIELD (Cpu386),
  BITFIELD (Cpu486),
  BITFIELD (Cpu586),
  BITFIELD (Cpu686),
  BITFIELD (CpuClflush),
  BITFIELD (CpuSYSCALL),
  BITFIELD (Cpu8087),
  BITFIELD (Cpu287),
  BITFIELD (Cpu387),
  BITFIELD (Cpu687),
  BITFIELD (CpuFISTTP),
  BITFIELD (CpuMMX),
  BITFIELD (CpuSSE),
  BITFIELD (CpuSSE2),
  BITFIELD (CpuSSE3),
  BITFIELD (CpuSSSE3),
  BITFIELD (CpuSSE4_1),
  BITFIELD (CpuSSE4_2),
  BITFIELD (CpuAVX),
  BITFIELD (CpuL1OM),
  BITFIELD (CpuSSE4a),
  BITFIELD (Cpu3dnow),
  BITFIELD (Cpu3dnowA),
  BITFIELD (CpuPadLock),
  BITFIELD (CpuSVME),
  BITFIELD (CpuVMX),
  BITFIELD (CpuSMX),
  BITFIELD (CpuABM),
  BITFIELD (CpuXsave),
  BITFIELD (CpuAES),
  BITFIELD (CpuPCLMUL),
  BITFIELD (CpuFMA),
  BITFIELD (CpuFMA4),
  BITFIELD (CpuLM),
  BITFIELD (CpuMovbe),
  BITFIELD (CpuEPT),
  BITFIELD (CpuRdtscp),
  BITFIELD (Cpu64),
  BITFIELD (CpuNo64),
#ifdef CpuUnused
  BITFIELD (CpuUnused),
#endif
};
 
static bitfield opcode_modifiers[] =
{
  BITFIELD (D),
  BITFIELD (W),
  BITFIELD (S),
  BITFIELD (Modrm),
  BITFIELD (ShortForm),
  BITFIELD (Jump),
  BITFIELD (JumpDword),
  BITFIELD (JumpByte),
  BITFIELD (JumpInterSegment),
  BITFIELD (FloatMF),
  BITFIELD (FloatR),
  BITFIELD (FloatD),
  BITFIELD (Size16),
  BITFIELD (Size32),
  BITFIELD (Size64),
  BITFIELD (IgnoreSize),
  BITFIELD (DefaultSize),
  BITFIELD (No_bSuf),
  BITFIELD (No_wSuf),
  BITFIELD (No_lSuf),
  BITFIELD (No_sSuf),
  BITFIELD (No_qSuf),
  BITFIELD (No_ldSuf),
  BITFIELD (FWait),
  BITFIELD (IsString),
  BITFIELD (RegKludge),
  BITFIELD (FirstXmm0),
  BITFIELD (Implicit1stXmm0),
  BITFIELD (ByteOkIntel),
  BITFIELD (ToDword),
  BITFIELD (ToQword),
  BITFIELD (AddrPrefixOp0),
  BITFIELD (IsPrefix),
  BITFIELD (ImmExt),
  BITFIELD (NoRex64),
  BITFIELD (Rex64),
  BITFIELD (Ugh),
  BITFIELD (Vex),
  BITFIELD (Vex256),
  BITFIELD (VexNDS),
  BITFIELD (VexNDD),
  BITFIELD (VexW0),
  BITFIELD (VexW1),
  BITFIELD (Vex0F),
  BITFIELD (Vex0F38),
  BITFIELD (Vex0F3A),
  BITFIELD (Vex3Sources),
  BITFIELD (VexImmExt),
  BITFIELD (SSE2AVX),
  BITFIELD (NoAVX),
  BITFIELD (OldGcc),
  BITFIELD (ATTMnemonic),
  BITFIELD (ATTSyntax),
  BITFIELD (IntelSyntax),
};
 
static bitfield operand_types[] =
{
  BITFIELD (Reg8),
  BITFIELD (Reg16),
  BITFIELD (Reg32),
  BITFIELD (Reg64),
  BITFIELD (FloatReg),
  BITFIELD (RegMMX),
  BITFIELD (RegXMM),
  BITFIELD (RegYMM),
  BITFIELD (Imm8),
  BITFIELD (Imm8S),
  BITFIELD (Imm16),
  BITFIELD (Imm32),
  BITFIELD (Imm32S),
  BITFIELD (Imm64),
  BITFIELD (Imm1),
  BITFIELD (BaseIndex),
  BITFIELD (Disp8),
  BITFIELD (Disp16),
  BITFIELD (Disp32),
  BITFIELD (Disp32S),
  BITFIELD (Disp64),
  BITFIELD (InOutPortReg),
  BITFIELD (ShiftCount),
  BITFIELD (Control),
  BITFIELD (Debug),
  BITFIELD (Test),
  BITFIELD (SReg2),
  BITFIELD (SReg3),
  BITFIELD (Acc),
  BITFIELD (FloatAcc),
  BITFIELD (JumpAbsolute),
  BITFIELD (EsSeg),
  BITFIELD (RegMem),
  BITFIELD (Mem),
  BITFIELD (Byte),
  BITFIELD (Word),
  BITFIELD (Dword),
  BITFIELD (Fword),
  BITFIELD (Qword),
  BITFIELD (Tbyte),
  BITFIELD (Xmmword),
  BITFIELD (Ymmword),
  BITFIELD (Unspecified),
  BITFIELD (Anysize),
#ifdef OTUnused
  BITFIELD (OTUnused),
#endif
};
 
static const char *filename;
 
static int
compare (const void *x, const void *y)
{
  const bitfield *xp = (const bitfield *) x;
  const bitfield *yp = (const bitfield *) y;
  return xp->position - yp->position;
}
 
static void
fail (const char *message, ...)
{
  va_list args;
 
  va_start (args, message);
  fprintf (stderr, _("%s: Error: "), program_name);
  vfprintf (stderr, message, args);
  va_end (args);
  xexit (1);
}
 
static void
process_copyright (FILE *fp)
{
  fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
/* Copyright 2007, 2008, 2009\n\
   Free Software Foundation, Inc.\n\
\n\
   This file is part of the GNU opcodes library.\n\
\n\
   This library is free software; you can redistribute it and/or modify\n\
   it under the terms of the GNU General Public License as published by\n\
   the Free Software Foundation; either version 3, or (at your option)\n\
   any later version.\n\
\n\
   It is distributed in the hope that it will be useful, but WITHOUT\n\
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
   License for more details.\n\
\n\
   You should have received a copy of the GNU General Public License\n\
   along with this program; if not, write to the Free Software\n\
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
   MA 02110-1301, USA.  */\n");
}
 
/* Remove leading white spaces.  */
 
static char *
remove_leading_whitespaces (char *str)
{
  while (ISSPACE (*str))
    str++;
  return str;
}
 
/* Remove trailing white spaces.  */
 
static void
remove_trailing_whitespaces (char *str)
{
  size_t last = strlen (str);
 
  if (last == 0)
    return;
 
  do
    {
      last--;
      if (ISSPACE (str [last]))
        str[last] = '\0';
      else
        break;
    }
  while (last != 0);
}
 
/* Find next field separated by SEP and terminate it. Return a
   pointer to the one after it.  */
 
static char *
next_field (char *str, char sep, char **next, char *last)
{
  char *p;
 
  p = remove_leading_whitespaces (str);
  for (str = p; *str != sep && *str != '\0'; str++);
 
  *str = '\0';
  remove_trailing_whitespaces (p);
 
  *next = str + 1;
 
  if (p >= last)
    abort ();
 
  return p;
}
 
static void
set_bitfield (const char *f, bitfield *array, int value,
              unsigned int size, int lineno)
{
  unsigned int i;
 
  if (strcmp (f, "CpuFP") == 0)
    {
      set_bitfield("Cpu387", array, value, size, lineno);
      set_bitfield("Cpu287", array, value, size, lineno);
      f = "Cpu8087";
    }
  else if (strcmp (f, "Mmword") == 0)
    f= "Qword";
  else if (strcmp (f, "Oword") == 0)
    f= "Xmmword";
 
  for (i = 0; i < size; i++)
    if (strcasecmp (array[i].name, f) == 0)
      {
        array[i].value = value;
        return;
      }
 
  if (lineno != -1)
    fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
  else
    fail (_("Unknown bitfield: %s\n"), f);
}
 
static void
output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
                  int macro, const char *comma, const char *indent)
{
  unsigned int i;
 
  fprintf (table, "%s{ { ", indent);
 
  for (i = 0; i < size - 1; i++)
    {
      fprintf (table, "%d, ", flags[i].value);
      if (((i + 1) % 20) == 0)
        {
          /* We need \\ for macro.  */
          if (macro)
            fprintf (table, " \\\n    %s", indent);
          else
            fprintf (table, "\n    %s", indent);
        }
    }
 
  fprintf (table, "%d } }%s\n", flags[i].value, comma);
}
 
static void
process_i386_cpu_flag (FILE *table, char *flag, int macro,
                       const char *comma, const char *indent,
                       int lineno)
{
  char *str, *next, *last;
  unsigned int i;
  bitfield flags [ARRAY_SIZE (cpu_flags)];
 
  /* Copy the default cpu flags.  */
  memcpy (flags, cpu_flags, sizeof (cpu_flags));
 
  if (strcasecmp (flag, "unknown") == 0)
    {
      /* We turn on everything except for cpu64 in case of
         CPU_UNKNOWN_FLAGS.  */
      for (i = 0; i < ARRAY_SIZE (flags); i++)
        if (flags[i].position != Cpu64)
          flags[i].value = 1;
    }
  else if (flag[0] == '~')
    {
      last = flag + strlen (flag);
 
      if (flag[1] == '(')
        {
          last -= 1;
          next = flag + 2;
          if (*last != ')')
            fail (_("%s: %d: Missing `)' in bitfield: %s\n"), filename,
                  lineno, flag);
          *last = '\0';
        }
      else
        next = flag + 1;
 
      /* First we turn on everything except for cpu64.  */
      for (i = 0; i < ARRAY_SIZE (flags); i++)
        if (flags[i].position != Cpu64)
          flags[i].value = 1;
 
      /* Turn off selective bits.  */
      for (; next && next < last; )
        {
          str = next_field (next, '|', &next, last);
          if (str)
            set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
        }
    }
  else if (strcmp (flag, "0"))
    {
      /* Turn on selective bits.  */
      last = flag + strlen (flag);
      for (next = flag; next && next < last; )
        {
          str = next_field (next, '|', &next, last);
          if (str)
            set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
        }
    }
 
  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
                    comma, indent);
}
 
static void
output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
{
  unsigned int i;
 
  fprintf (table, "    { ");
 
  for (i = 0; i < size - 1; i++)
    {
      fprintf (table, "%d, ", modifier[i].value);
      if (((i + 1) % 20) == 0)
        fprintf (table, "\n      ");
    }
 
  fprintf (table, "%d },\n", modifier[i].value);
}
 
static void
process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
{
  char *str, *next, *last;
  bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
 
  /* Copy the default opcode modifier.  */
  memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
 
  if (strcmp (mod, "0"))
    {
      last = mod + strlen (mod);
      for (next = mod; next && next < last; )
        {
          str = next_field (next, '|', &next, last);
          if (str)
            set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
                          lineno);
        }
    }
  output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
}
 
static void
output_operand_type (FILE *table, bitfield *types, unsigned int size,
                     int macro, const char *indent)
{
  unsigned int i;
 
  fprintf (table, "{ { ");
 
  for (i = 0; i < size - 1; i++)
    {
      fprintf (table, "%d, ", types[i].value);
      if (((i + 1) % 20) == 0)
        {
          /* We need \\ for macro.  */
          if (macro)
            fprintf (table, "\\\n%s", indent);
          else
            fprintf (table, "\n%s", indent);
        }
    }
 
  fprintf (table, "%d } }", types[i].value);
}
 
static void
process_i386_operand_type (FILE *table, char *op, int macro,
                           const char *indent, int lineno)
{
  char *str, *next, *last;
  bitfield types [ARRAY_SIZE (operand_types)];
 
  /* Copy the default operand type.  */
  memcpy (types, operand_types, sizeof (types));
 
  if (strcmp (op, "0"))
    {
      last = op + strlen (op);
      for (next = op; next && next < last; )
        {
          str = next_field (next, '|', &next, last);
          if (str)
            set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
        }
    }
  output_operand_type (table, types, ARRAY_SIZE (types), macro,
                       indent);
}
 
static void
output_i386_opcode (FILE *table, const char *name, char *str,
                    char *last, int lineno)
{
  unsigned int i;
  char *operands, *base_opcode, *extension_opcode, *opcode_length;
  char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
 
  /* Find number of operands.  */
  operands = next_field (str, ',', &str, last);
 
  /* Find base_opcode.  */
  base_opcode = next_field (str, ',', &str, last);
 
  /* Find extension_opcode.  */
  extension_opcode = next_field (str, ',', &str, last);
 
  /* Find opcode_length.  */
  opcode_length = next_field (str, ',', &str, last);
 
  /* Find cpu_flags.  */
  cpu_flags = next_field (str, ',', &str, last);
 
  /* Find opcode_modifier.  */
  opcode_modifier = next_field (str, ',', &str, last);
 
  /* Remove the first {.  */
  str = remove_leading_whitespaces (str);
  if (*str != '{')
    abort ();
  str = remove_leading_whitespaces (str + 1);
 
  i = strlen (str);
 
  /* There are at least "X}".  */
  if (i < 2)
    abort ();
 
  /* Remove trailing white spaces and }. */
  do
    {
      i--;
      if (ISSPACE (str[i]) || str[i] == '}')
        str[i] = '\0';
      else
        break;
    }
  while (i != 0);
 
  last = str + i;
 
  /* Find operand_types.  */
  for (i = 0; i < ARRAY_SIZE (operand_types); i++)
    {
      if (str >= last)
        {
          operand_types [i] = NULL;
          break;
        }
 
      operand_types [i] = next_field (str, ',', &str, last);
      if (*operand_types[i] == '0')
        {
          if (i != 0)
            operand_types[i] = NULL;
          break;
        }
    }
 
  fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
           name, operands, base_opcode, extension_opcode,
           opcode_length);
 
  process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
 
  process_i386_opcode_modifier (table, opcode_modifier, lineno);
 
  fprintf (table, "    { ");
 
  for (i = 0; i < ARRAY_SIZE (operand_types); i++)
    {
      if (operand_types[i] == NULL || *operand_types[i] == '0')
        {
          if (i == 0)
            process_i386_operand_type (table, "0", 0, "\t  ", lineno);
          break;
        }
 
      if (i != 0)
        fprintf (table, ",\n      ");
 
      process_i386_operand_type (table, operand_types[i], 0,
                                 "\t  ", lineno);
    }
  fprintf (table, " } },\n");
}
 
struct opcode_hash_entry
{
  struct opcode_hash_entry *next;
  char *name;
  char *opcode;
  int lineno;
};
 
/* Calculate the hash value of an opcode hash entry P.  */
 
static hashval_t
opcode_hash_hash (const void *p)
{
  struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
  return htab_hash_string (entry->name);
}
 
/* Compare a string Q against an opcode hash entry P.  */
 
static int
opcode_hash_eq (const void *p, const void *q)
{
  struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
  const char *name = (const char *) q;
  return strcmp (name, entry->name) == 0;
}
 
static void
process_i386_opcodes (FILE *table)
{
  FILE *fp;
  char buf[2048];
  unsigned int i, j;
  char *str, *p, *last, *name;
  struct opcode_hash_entry **hash_slot, **entry, *next;
  htab_t opcode_hash_table;
  struct opcode_hash_entry **opcode_array;
  unsigned int opcode_array_size = 1024;
  int lineno = 0;
 
  filename = "i386-opc.tbl";
  fp = fopen (filename, "r");
 
  if (fp == NULL)
    fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
          xstrerror (errno));
 
  i = 0;
  opcode_array = (struct opcode_hash_entry **)
    xmalloc (sizeof (*opcode_array) * opcode_array_size);
 
  opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
                                         opcode_hash_eq, NULL,
                                         xcalloc, free);
 
  fprintf (table, "\n/* i386 opcode table.  */\n\n");
  fprintf (table, "const insn_template i386_optab[] =\n{\n");
 
  /* Put everything on opcode array.  */
  while (!feof (fp))
    {
      if (fgets (buf, sizeof (buf), fp) == NULL)
        break;
 
      lineno++;
 
      p = remove_leading_whitespaces (buf);
 
      /* Skip comments.  */
      str = strstr (p, "//");
      if (str != NULL)
        str[0] = '\0';
 
      /* Remove trailing white spaces.  */
      remove_trailing_whitespaces (p);
 
      switch (p[0])
        {
        case '#':
          /* Ignore comments.  */
        case '\0':
          continue;
          break;
        default:
          break;
        }
 
      last = p + strlen (p);
 
      /* Find name.  */
      name = next_field (p, ',', &str, last);
 
      /* Get the slot in hash table.  */
      hash_slot = (struct opcode_hash_entry **)
        htab_find_slot_with_hash (opcode_hash_table, name,
                                  htab_hash_string (name),
                                  INSERT);
 
      if (*hash_slot == NULL)
        {
          /* It is the new one.  Put it on opcode array.  */
          if (i >= opcode_array_size)
            {
              /* Grow the opcode array when needed.  */
              opcode_array_size += 1024;
              opcode_array = (struct opcode_hash_entry **)
                xrealloc (opcode_array,
                          sizeof (*opcode_array) * opcode_array_size);
            }
 
          opcode_array[i] = (struct opcode_hash_entry *)
            xmalloc (sizeof (struct opcode_hash_entry));
          opcode_array[i]->next = NULL;
          opcode_array[i]->name = xstrdup (name);
          opcode_array[i]->opcode = xstrdup (str);
          opcode_array[i]->lineno = lineno;
          *hash_slot = opcode_array[i];
          i++;
        }
      else
        {
          /* Append it to the existing one.  */
          entry = hash_slot;
          while ((*entry) != NULL)
            entry = &(*entry)->next;
          *entry = (struct opcode_hash_entry *)
            xmalloc (sizeof (struct opcode_hash_entry));
          (*entry)->next = NULL;
          (*entry)->name = (*hash_slot)->name;
          (*entry)->opcode = xstrdup (str);
          (*entry)->lineno = lineno;
        }
    }
 
  /* Process opcode array.  */
  for (j = 0; j < i; j++)
    {
      for (next = opcode_array[j]; next; next = next->next)
        {
          name = next->name;
          str = next->opcode;
          lineno = next->lineno;
          last = str + strlen (str);
          output_i386_opcode (table, name, str, last, lineno);
        }
    }
 
  fclose (fp);
 
  fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
 
  process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
 
  process_i386_opcode_modifier (table, "0", -1);
 
  fprintf (table, "    { ");
  process_i386_operand_type (table, "0", 0, "\t  ", -1);
  fprintf (table, " } }\n");
 
  fprintf (table, "};\n");
}
 
static void
process_i386_registers (FILE *table)
{
  FILE *fp;
  char buf[2048];
  char *str, *p, *last;
  char *reg_name, *reg_type, *reg_flags, *reg_num;
  char *dw2_32_num, *dw2_64_num;
  int lineno = 0;
 
  filename = "i386-reg.tbl";
  fp = fopen (filename, "r");
  if (fp == NULL)
    fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
          xstrerror (errno));
 
  fprintf (table, "\n/* i386 register table.  */\n\n");
  fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
 
  while (!feof (fp))
    {
      if (fgets (buf, sizeof (buf), fp) == NULL)
        break;
 
      lineno++;
 
      p = remove_leading_whitespaces (buf);
 
      /* Skip comments.  */
      str = strstr (p, "//");
      if (str != NULL)
        str[0] = '\0';
 
      /* Remove trailing white spaces.  */
      remove_trailing_whitespaces (p);
 
      switch (p[0])
        {
        case '#':
          fprintf (table, "%s\n", p);
        case '\0':
          continue;
          break;
        default:
          break;
        }
 
      last = p + strlen (p);
 
      /* Find reg_name.  */
      reg_name = next_field (p, ',', &str, last);
 
      /* Find reg_type.  */
      reg_type = next_field (str, ',', &str, last);
 
      /* Find reg_flags.  */
      reg_flags = next_field (str, ',', &str, last);
 
      /* Find reg_num.  */
      reg_num = next_field (str, ',', &str, last);
 
      fprintf (table, "  { \"%s\",\n    ", reg_name);
 
      process_i386_operand_type (table, reg_type, 0, "\t", lineno);
 
      /* Find 32-bit Dwarf2 register number.  */
      dw2_32_num = next_field (str, ',', &str, last);
 
      /* Find 64-bit Dwarf2 register number.  */
      dw2_64_num = next_field (str, ',', &str, last);
 
      fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
               reg_flags, reg_num, dw2_32_num, dw2_64_num);
    }
 
  fclose (fp);
 
  fprintf (table, "};\n");
 
  fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
}
 
static void
process_i386_initializers (void)
{
  unsigned int i;
  FILE *fp = fopen ("i386-init.h", "w");
  char *init;
 
  if (fp == NULL)
    fail (_("can't create i386-init.h, errno = %s\n"),
          xstrerror (errno));
 
  process_copyright (fp);
 
  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
    {
      fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
      init = xstrdup (cpu_flag_init[i].init);
      process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
      free (init);
    }
 
  for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
    {
      fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
      init = xstrdup (operand_type_init[i].init);
      process_i386_operand_type (fp, init, 1, "      ", -1);
      free (init);
    }
  fprintf (fp, "\n");
 
  fclose (fp);
}
 
/* Program options.  */
#define OPTION_SRCDIR   200
 
struct option long_options[] =
{
  {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
  {"debug",   no_argument,       NULL, 'd'},
  {"version", no_argument,       NULL, 'V'},
  {"help",    no_argument,       NULL, 'h'},
  {0,         no_argument,       NULL, 0}
};
 
static void
print_version (void)
{
  printf ("%s: version 1.0\n", program_name);
  xexit (0);
}
 
static void
usage (FILE * stream, int status)
{
  fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
           program_name);
  xexit (status);
}
 
int
main (int argc, char **argv)
{
  extern int chdir (char *);
  char *srcdir = NULL;
  int c;
  FILE *table;
 
  program_name = *argv;
  xmalloc_set_program_name (program_name);
 
  while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
    switch (c)
      {
      case OPTION_SRCDIR:
        srcdir = optarg;
        break;
      case 'V':
      case 'v':
        print_version ();
        break;
      case 'd':
        debug = 1;
        break;
      case 'h':
      case '?':
        usage (stderr, 0);
      default:
      case 0:
        break;
      }
 
  if (optind != argc)
    usage (stdout, 1);
 
  if (srcdir != NULL)
    if (chdir (srcdir) != 0)
      fail (_("unable to change directory to \"%s\", errno = %s\n"),
            srcdir, xstrerror (errno));
 
  /* Check the unused bitfield in i386_cpu_flags.  */
#ifndef CpuUnused
  c = CpuNumOfBits - CpuMax - 1;
  if (c)
    fail (_("%d unused bits in i386_cpu_flags.\n"), c);
#endif
 
  /* Check the unused bitfield in i386_operand_type.  */
#ifndef OTUnused
  c = OTNumOfBits - OTMax - 1;
  if (c)
    fail (_("%d unused bits in i386_operand_type.\n"), c);
#endif
 
  qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
         compare);
 
  qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
         sizeof (opcode_modifiers [0]), compare);
 
  qsort (operand_types, ARRAY_SIZE (operand_types),
         sizeof (operand_types [0]), compare);
 
  table = fopen ("i386-tbl.h", "w");
  if (table == NULL)
    fail (_("can't create i386-tbl.h, errno = %s\n"),
          xstrerror (errno));
 
  process_copyright (table);
 
  process_i386_opcodes (table);
  process_i386_registers (table);
  process_i386_initializers ();
 
  fclose (table);
 
  exit (0);
}

Line No.	Rev	Author	Line
1	225	jeremybenn	`/* Copyright 2007, 2008, 2009`
2			`Free Software Foundation, Inc.`
3	24	jeremybenn
4			`This file is part of the GNU opcodes library.`
5
6			`This library is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 3, or (at your option)`
9			`any later version.`
10
11			`It is distributed in the hope that it will be useful, but WITHOUT`
12			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY`
13			`or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public`
14			`License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
19			`MA 02110-1301, USA. */`
20
21			`#include "sysdep.h"`
22			`#include <stdio.h>`
23			`#include <errno.h>`
24			`#include "getopt.h"`
25			`#include "libiberty.h"`
26	225	jeremybenn	`#include "hashtab.h"`
27	24	jeremybenn	`#include "safe-ctype.h"`
28
29			`#include "i386-opc.h"`
30
31			`#include <libintl.h>`
32			`#define _(String) gettext (String)`
33
34			`static const char *program_name = NULL;`
35			`static int debug = 0;`
36
37			`typedef struct initializer`
38			`{`
39			`const char *name;`
40			`const char *init;`
41			`} initializer;`
42
43	225	jeremybenn	`static initializer cpu_flag_init[] =`
44	24	jeremybenn	`{`
45			`{ "CPU_UNKNOWN_FLAGS",`
46	225	jeremybenn	`"~CpuL1OM" },`
47	24	jeremybenn	`{ "CPU_GENERIC32_FLAGS",`
48			`"Cpu186\|Cpu286\|Cpu386" },`
49			`{ "CPU_GENERIC64_FLAGS",`
50	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuMMX\|CpuSSE\|CpuSSE2\|CpuLM" },`
51	24	jeremybenn	`{ "CPU_NONE_FLAGS",`
52			`"0" },`
53			`{ "CPU_I186_FLAGS",`
54			`"Cpu186" },`
55			`{ "CPU_I286_FLAGS",`
56			`"Cpu186\|Cpu286" },`
57			`{ "CPU_I386_FLAGS",`
58			`"Cpu186\|Cpu286\|Cpu386" },`
59			`{ "CPU_I486_FLAGS",`
60			`"Cpu186\|Cpu286\|Cpu386\|Cpu486" },`
61			`{ "CPU_I586_FLAGS",`
62	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu387" },`
63	24	jeremybenn	`{ "CPU_I686_FLAGS",`
64	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|Cpu387\|Cpu687" },`
65	24	jeremybenn	`{ "CPU_P2_FLAGS",`
66	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|Cpu387\|Cpu687\|CpuMMX" },`
67	24	jeremybenn	`{ "CPU_P3_FLAGS",`
68	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|Cpu387\|Cpu687\|CpuMMX\|CpuSSE" },`
69	24	jeremybenn	`{ "CPU_P4_FLAGS",`
70	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuMMX\|CpuSSE\|CpuSSE2" },`
71	24	jeremybenn	`{ "CPU_NOCONA_FLAGS",`
72	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuFISTTP\|CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuLM" },`
73	24	jeremybenn	`{ "CPU_CORE_FLAGS",`
74	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuFISTTP\|CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3" },`
75	24	jeremybenn	`{ "CPU_CORE2_FLAGS",`
76	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuFISTTP\|CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuLM" },`
77			`{ "CPU_COREI7_FLAGS",`
78			`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuClflush\|Cpu387\|Cpu687\|CpuFISTTP\|CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuRdtscp\|CpuLM" },`
79	24	jeremybenn	`{ "CPU_K6_FLAGS",`
80	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|CpuSYSCALL\|Cpu387\|CpuMMX" },`
81	24	jeremybenn	`{ "CPU_K6_2_FLAGS",`
82	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|CpuSYSCALL\|Cpu387\|CpuMMX\|Cpu3dnow" },`
83	24	jeremybenn	`{ "CPU_ATHLON_FLAGS",`
84	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuSYSCALL\|Cpu387\|Cpu687\|CpuMMX\|Cpu3dnow\|Cpu3dnowA" },`
85	24	jeremybenn	`{ "CPU_K8_FLAGS",`
86	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuSYSCALL\|CpuRdtscp\|Cpu387\|Cpu687\|CpuMMX\|Cpu3dnow\|Cpu3dnowA\|CpuSSE\|CpuSSE2\|CpuLM" },`
87	24	jeremybenn	`{ "CPU_AMDFAM10_FLAGS",`
88	225	jeremybenn	`"Cpu186\|Cpu286\|Cpu386\|Cpu486\|Cpu586\|Cpu686\|CpuSYSCALL\|CpuRdtscp\|Cpu387\|Cpu687\|CpuFISTTP\|CpuMMX\|Cpu3dnow\|Cpu3dnowA\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSE4a\|CpuABM\|CpuLM" },`
89			`{ "CPU_8087_FLAGS",`
90			`"Cpu8087" },`
91			`{ "CPU_287_FLAGS",`
92			`"Cpu287" },`
93			`{ "CPU_387_FLAGS",`
94			`"Cpu387" },`
95			`{ "CPU_ANY87_FLAGS",`
96			`"Cpu8087\|Cpu287\|Cpu387\|Cpu687\|CpuFISTTP" },`
97			`{ "CPU_CLFLUSH_FLAGS",`
98			`"CpuClflush" },`
99			`{ "CPU_SYSCALL_FLAGS",`
100			`"CpuSYSCALL" },`
101	24	jeremybenn	`{ "CPU_MMX_FLAGS",`
102			`"CpuMMX" },`
103			`{ "CPU_SSE_FLAGS",`
104			`"CpuMMX\|CpuSSE" },`
105			`{ "CPU_SSE2_FLAGS",`
106			`"CpuMMX\|CpuSSE\|CpuSSE2" },`
107			`{ "CPU_SSE3_FLAGS",`
108			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3" },`
109			`{ "CPU_SSSE3_FLAGS",`
110			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3" },`
111			`{ "CPU_SSE4_1_FLAGS",`
112			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1" },`
113			`{ "CPU_SSE4_2_FLAGS",`
114			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2" },`
115	225	jeremybenn	`{ "CPU_ANY_SSE_FLAGS",`
116			`"CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuSSE4a\|CpuAVX" },`
117	24	jeremybenn	`{ "CPU_VMX_FLAGS",`
118			`"CpuVMX" },`
119			`{ "CPU_SMX_FLAGS",`
120			`"CpuSMX" },`
121			`{ "CPU_XSAVE_FLAGS",`
122			`"CpuXsave" },`
123	225	jeremybenn	`{ "CPU_AES_FLAGS",`
124			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuAES" },`
125			`{ "CPU_PCLMUL_FLAGS",`
126			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuPCLMUL" },`
127			`{ "CPU_FMA_FLAGS",`
128			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuAVX\|CpuFMA" },`
129			`{ "CPU_FMA4_FLAGS",`
130			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuAVX\|CpuFMA4" },`
131			`{ "CPU_MOVBE_FLAGS",`
132			`"CpuMovbe" },`
133			`{ "CPU_RDTSCP_FLAGS",`
134			`"CpuRdtscp" },`
135			`{ "CPU_EPT_FLAGS",`
136			`"CpuEPT" },`
137	24	jeremybenn	`{ "CPU_3DNOW_FLAGS",`
138			`"CpuMMX\|Cpu3dnow" },`
139			`{ "CPU_3DNOWA_FLAGS",`
140			`"CpuMMX\|Cpu3dnow\|Cpu3dnowA" },`
141			`{ "CPU_PADLOCK_FLAGS",`
142			`"CpuPadLock" },`
143			`{ "CPU_SVME_FLAGS",`
144			`"CpuSVME" },`
145			`{ "CPU_SSE4A_FLAGS",`
146			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSE4a" },`
147			`{ "CPU_ABM_FLAGS",`
148			`"CpuABM" },`
149	225	jeremybenn	`{ "CPU_AVX_FLAGS",`
150			`"CpuMMX\|CpuSSE\|CpuSSE2\|CpuSSE3\|CpuSSSE3\|CpuSSE4_1\|CpuSSE4_2\|CpuAVX" },`
151			`{ "CPU_ANY_AVX_FLAGS",`
152			`"CpuAVX" },`
153			`{ "CPU_L1OM_FLAGS",`
154			`"unknown" },`
155	24	jeremybenn	`};`
156
157	225	jeremybenn	`static initializer operand_type_init[] =`
158	24	jeremybenn	`{`
159			`{ "OPERAND_TYPE_NONE",`
160			`"0" },`
161			`{ "OPERAND_TYPE_REG8",`
162			`"Reg8" },`
163			`{ "OPERAND_TYPE_REG16",`
164			`"Reg16" },`
165			`{ "OPERAND_TYPE_REG32",`
166			`"Reg32" },`
167			`{ "OPERAND_TYPE_REG64",`
168			`"Reg64" },`
169			`{ "OPERAND_TYPE_IMM1",`
170			`"Imm1" },`
171			`{ "OPERAND_TYPE_IMM8",`
172			`"Imm8" },`
173			`{ "OPERAND_TYPE_IMM8S",`
174			`"Imm8S" },`
175			`{ "OPERAND_TYPE_IMM16",`
176			`"Imm16" },`
177			`{ "OPERAND_TYPE_IMM32",`
178			`"Imm32" },`
179			`{ "OPERAND_TYPE_IMM32S",`
180			`"Imm32S" },`
181			`{ "OPERAND_TYPE_IMM64",`
182			`"Imm64" },`
183			`{ "OPERAND_TYPE_BASEINDEX",`
184			`"BaseIndex" },`
185			`{ "OPERAND_TYPE_DISP8",`
186			`"Disp8" },`
187			`{ "OPERAND_TYPE_DISP16",`
188			`"Disp16" },`
189			`{ "OPERAND_TYPE_DISP32",`
190			`"Disp32" },`
191			`{ "OPERAND_TYPE_DISP32S",`
192			`"Disp32S" },`
193			`{ "OPERAND_TYPE_DISP64",`
194			`"Disp64" },`
195			`{ "OPERAND_TYPE_INOUTPORTREG",`
196			`"InOutPortReg" },`
197			`{ "OPERAND_TYPE_SHIFTCOUNT",`
198			`"ShiftCount" },`
199			`{ "OPERAND_TYPE_CONTROL",`
200			`"Control" },`
201			`{ "OPERAND_TYPE_TEST",`
202			`"Test" },`
203			`{ "OPERAND_TYPE_DEBUG",`
204			`"FloatReg" },`
205			`{ "OPERAND_TYPE_FLOATREG",`
206			`"FloatReg" },`
207			`{ "OPERAND_TYPE_FLOATACC",`
208			`"FloatAcc" },`
209			`{ "OPERAND_TYPE_SREG2",`
210			`"SReg2" },`
211			`{ "OPERAND_TYPE_SREG3",`
212			`"SReg3" },`
213			`{ "OPERAND_TYPE_ACC",`
214			`"Acc" },`
215			`{ "OPERAND_TYPE_JUMPABSOLUTE",`
216			`"JumpAbsolute" },`
217			`{ "OPERAND_TYPE_REGMMX",`
218			`"RegMMX" },`
219			`{ "OPERAND_TYPE_REGXMM",`
220			`"RegXMM" },`
221	225	jeremybenn	`{ "OPERAND_TYPE_REGYMM",`
222			`"RegYMM" },`
223	24	jeremybenn	`{ "OPERAND_TYPE_ESSEG",`
224			`"EsSeg" },`
225			`{ "OPERAND_TYPE_ACC32",`
226			`"Reg32\|Acc\|Dword" },`
227			`{ "OPERAND_TYPE_ACC64",`
228			`"Reg64\|Acc\|Qword" },`
229			`{ "OPERAND_TYPE_INOUTPORTREG",`
230			`"InOutPortReg" },`
231			`{ "OPERAND_TYPE_REG16_INOUTPORTREG",`
232			`"Reg16\|InOutPortReg" },`
233			`{ "OPERAND_TYPE_DISP16_32",`
234			`"Disp16\|Disp32" },`
235			`{ "OPERAND_TYPE_ANYDISP",`
236			`"Disp8\|Disp16\|Disp32\|Disp32S\|Disp64" },`
237			`{ "OPERAND_TYPE_IMM16_32",`
238			`"Imm16\|Imm32" },`
239			`{ "OPERAND_TYPE_IMM16_32S",`
240			`"Imm16\|Imm32S" },`
241			`{ "OPERAND_TYPE_IMM16_32_32S",`
242			`"Imm16\|Imm32\|Imm32S" },`
243			`{ "OPERAND_TYPE_IMM32_32S_DISP32",`
244			`"Imm32\|Imm32S\|Disp32" },`
245			`{ "OPERAND_TYPE_IMM64_DISP64",`
246			`"Imm64\|Disp64" },`
247			`{ "OPERAND_TYPE_IMM32_32S_64_DISP32",`
248			`"Imm32\|Imm32S\|Imm64\|Disp32" },`
249			`{ "OPERAND_TYPE_IMM32_32S_64_DISP32_64",`
250			`"Imm32\|Imm32S\|Imm64\|Disp32\|Disp64" },`
251			`};`
252
253			`typedef struct bitfield`
254			`{`
255			`int position;`
256			`int value;`
257			`const char *name;`
258			`} bitfield;`
259
260			`#define BITFIELD(n) { n, 0, #n }`
261
262			`static bitfield cpu_flags[] =`
263			`{`
264			`BITFIELD (Cpu186),`
265			`BITFIELD (Cpu286),`
266			`BITFIELD (Cpu386),`
267			`BITFIELD (Cpu486),`
268			`BITFIELD (Cpu586),`
269			`BITFIELD (Cpu686),`
270	225	jeremybenn	`BITFIELD (CpuClflush),`
271			`BITFIELD (CpuSYSCALL),`
272			`BITFIELD (Cpu8087),`
273			`BITFIELD (Cpu287),`
274			`BITFIELD (Cpu387),`
275			`BITFIELD (Cpu687),`
276			`BITFIELD (CpuFISTTP),`
277	24	jeremybenn	`BITFIELD (CpuMMX),`
278			`BITFIELD (CpuSSE),`
279			`BITFIELD (CpuSSE2),`
280			`BITFIELD (CpuSSE3),`
281			`BITFIELD (CpuSSSE3),`
282			`BITFIELD (CpuSSE4_1),`
283			`BITFIELD (CpuSSE4_2),`
284	225	jeremybenn	`BITFIELD (CpuAVX),`
285			`BITFIELD (CpuL1OM),`
286	24	jeremybenn	`BITFIELD (CpuSSE4a),`
287			`BITFIELD (Cpu3dnow),`
288			`BITFIELD (Cpu3dnowA),`
289			`BITFIELD (CpuPadLock),`
290			`BITFIELD (CpuSVME),`
291			`BITFIELD (CpuVMX),`
292			`BITFIELD (CpuSMX),`
293			`BITFIELD (CpuABM),`
294	225	jeremybenn	`BITFIELD (CpuXsave),`
295			`BITFIELD (CpuAES),`
296			`BITFIELD (CpuPCLMUL),`
297			`BITFIELD (CpuFMA),`
298			`BITFIELD (CpuFMA4),`
299	24	jeremybenn	`BITFIELD (CpuLM),`
300	225	jeremybenn	`BITFIELD (CpuMovbe),`
301			`BITFIELD (CpuEPT),`
302			`BITFIELD (CpuRdtscp),`
303	24	jeremybenn	`BITFIELD (Cpu64),`
304			`BITFIELD (CpuNo64),`
305			`#ifdef CpuUnused`
306			`BITFIELD (CpuUnused),`
307			`#endif`
308			`};`
309
310			`static bitfield opcode_modifiers[] =`
311			`{`
312			`BITFIELD (D),`
313			`BITFIELD (W),`
314	225	jeremybenn	`BITFIELD (S),`
315	24	jeremybenn	`BITFIELD (Modrm),`
316			`BITFIELD (ShortForm),`
317			`BITFIELD (Jump),`
318			`BITFIELD (JumpDword),`
319			`BITFIELD (JumpByte),`
320			`BITFIELD (JumpInterSegment),`
321			`BITFIELD (FloatMF),`
322			`BITFIELD (FloatR),`
323			`BITFIELD (FloatD),`
324			`BITFIELD (Size16),`
325			`BITFIELD (Size32),`
326			`BITFIELD (Size64),`
327			`BITFIELD (IgnoreSize),`
328			`BITFIELD (DefaultSize),`
329			`BITFIELD (No_bSuf),`
330			`BITFIELD (No_wSuf),`
331			`BITFIELD (No_lSuf),`
332			`BITFIELD (No_sSuf),`
333			`BITFIELD (No_qSuf),`
334			`BITFIELD (No_ldSuf),`
335			`BITFIELD (FWait),`
336			`BITFIELD (IsString),`
337			`BITFIELD (RegKludge),`
338			`BITFIELD (FirstXmm0),`
339	225	jeremybenn	`BITFIELD (Implicit1stXmm0),`
340	24	jeremybenn	`BITFIELD (ByteOkIntel),`
341			`BITFIELD (ToDword),`
342			`BITFIELD (ToQword),`
343			`BITFIELD (AddrPrefixOp0),`
344			`BITFIELD (IsPrefix),`
345			`BITFIELD (ImmExt),`
346			`BITFIELD (NoRex64),`
347			`BITFIELD (Rex64),`
348			`BITFIELD (Ugh),`
349	225	jeremybenn	`BITFIELD (Vex),`
350			`BITFIELD (Vex256),`
351			`BITFIELD (VexNDS),`
352			`BITFIELD (VexNDD),`
353			`BITFIELD (VexW0),`
354			`BITFIELD (VexW1),`
355			`BITFIELD (Vex0F),`
356			`BITFIELD (Vex0F38),`
357			`BITFIELD (Vex0F3A),`
358			`BITFIELD (Vex3Sources),`
359			`BITFIELD (VexImmExt),`
360			`BITFIELD (SSE2AVX),`
361			`BITFIELD (NoAVX),`
362	24	jeremybenn	`BITFIELD (OldGcc),`
363			`BITFIELD (ATTMnemonic),`
364			`BITFIELD (ATTSyntax),`
365			`BITFIELD (IntelSyntax),`
366			`};`
367
368			`static bitfield operand_types[] =`
369			`{`
370			`BITFIELD (Reg8),`
371			`BITFIELD (Reg16),`
372			`BITFIELD (Reg32),`
373			`BITFIELD (Reg64),`
374			`BITFIELD (FloatReg),`
375			`BITFIELD (RegMMX),`
376			`BITFIELD (RegXMM),`
377	225	jeremybenn	`BITFIELD (RegYMM),`
378	24	jeremybenn	`BITFIELD (Imm8),`
379			`BITFIELD (Imm8S),`
380			`BITFIELD (Imm16),`
381			`BITFIELD (Imm32),`
382			`BITFIELD (Imm32S),`
383			`BITFIELD (Imm64),`
384			`BITFIELD (Imm1),`
385			`BITFIELD (BaseIndex),`
386			`BITFIELD (Disp8),`
387			`BITFIELD (Disp16),`
388			`BITFIELD (Disp32),`
389			`BITFIELD (Disp32S),`
390			`BITFIELD (Disp64),`
391			`BITFIELD (InOutPortReg),`
392			`BITFIELD (ShiftCount),`
393			`BITFIELD (Control),`
394			`BITFIELD (Debug),`
395			`BITFIELD (Test),`
396			`BITFIELD (SReg2),`
397			`BITFIELD (SReg3),`
398			`BITFIELD (Acc),`
399			`BITFIELD (FloatAcc),`
400			`BITFIELD (JumpAbsolute),`
401			`BITFIELD (EsSeg),`
402			`BITFIELD (RegMem),`
403			`BITFIELD (Mem),`
404			`BITFIELD (Byte),`
405			`BITFIELD (Word),`
406			`BITFIELD (Dword),`
407			`BITFIELD (Fword),`
408			`BITFIELD (Qword),`
409			`BITFIELD (Tbyte),`
410			`BITFIELD (Xmmword),`
411	225	jeremybenn	`BITFIELD (Ymmword),`
412	24	jeremybenn	`BITFIELD (Unspecified),`
413			`BITFIELD (Anysize),`
414			`#ifdef OTUnused`
415			`BITFIELD (OTUnused),`
416			`#endif`
417			`};`
418
419			`static const char *filename;`
420
421			`static int`
422			`compare (const void x, const void y)`
423			`{`
424			`const bitfield xp = (const bitfield ) x;`
425			`const bitfield yp = (const bitfield ) y;`
426			`return xp->position - yp->position;`
427			`}`
428
429			`static void`
430			`fail (const char *message, ...)`
431			`{`
432			`va_list args;`
433
434			`va_start (args, message);`
435			`fprintf (stderr, _("%s: Error: "), program_name);`
436			`vfprintf (stderr, message, args);`
437			`va_end (args);`
438			`xexit (1);`
439			`}`
440
441			`static void`
442			`process_copyright (FILE *fp)`
443			`{`
444			`fprintf (fp, "/* This file is automatically generated by i386-gen. Do not edit! */\n\`
445	225	jeremybenn	`/* Copyright 2007, 2008, 2009\n\`
446			`Free Software Foundation, Inc.\n\`
447	24	jeremybenn	`\n\`
448			`This file is part of the GNU opcodes library.\n\`
449			`\n\`
450			`This library is free software; you can redistribute it and/or modify\n\`
451			`it under the terms of the GNU General Public License as published by\n\`
452			`the Free Software Foundation; either version 3, or (at your option)\n\`
453			`any later version.\n\`
454			`\n\`
455			`It is distributed in the hope that it will be useful, but WITHOUT\n\`
456			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\`
457			`or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\`
458			`License for more details.\n\`
459			`\n\`
460			`You should have received a copy of the GNU General Public License\n\`
461			`along with this program; if not, write to the Free Software\n\`
462			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\`
463			`MA 02110-1301, USA. */\n");`
464			`}`
465
466			`/* Remove leading white spaces. */`
467
468			`static char *`
469			`remove_leading_whitespaces (char *str)`
470			`{`
471			`while (ISSPACE (*str))`
472			`str++;`
473			`return str;`
474			`}`
475
476			`/* Remove trailing white spaces. */`
477
478			`static void`
479			`remove_trailing_whitespaces (char *str)`
480			`{`
481			`size_t last = strlen (str);`
482
483			`if (last == 0)`
484			`return;`
485
486			`do`
487			`{`
488			`last--;`
489			`if (ISSPACE (str [last]))`
490			`str[last] = '\0';`
491			`else`
492			`break;`
493			`}`
494			`while (last != 0);`
495			`}`
496
497			`/* Find next field separated by SEP and terminate it. Return a`
498			`pointer to the one after it. */`
499
500			`static char *`

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [i386-gen.c] - Blame information for rev 252