OpenCores
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] - Diff between revs 157 and 225

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 157 Rev 225
Line 1... Line 1...
/* Copyright 2007, 2008  Free Software Foundation, Inc.
/* Copyright 2007, 2008, 2009
 
   Free Software Foundation, Inc.
 
 
   This file is part of the GNU opcodes library.
   This file is part of the GNU opcodes library.
 
 
   This library is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
Line 20... Line 21...
#include "sysdep.h"
#include "sysdep.h"
#include <stdio.h>
#include <stdio.h>
#include <errno.h>
#include <errno.h>
#include "getopt.h"
#include "getopt.h"
#include "libiberty.h"
#include "libiberty.h"
 
#include "hashtab.h"
#include "safe-ctype.h"
#include "safe-ctype.h"
 
 
#include "i386-opc.h"
#include "i386-opc.h"
 
 
#include <libintl.h>
#include <libintl.h>
Line 39... Line 41...
} initializer;
} initializer;
 
 
static initializer cpu_flag_init [] =
static initializer cpu_flag_init [] =
{
{
  { "CPU_UNKNOWN_FLAGS",
  { "CPU_UNKNOWN_FLAGS",
    "unknown" },
    "~CpuL1OM" },
  { "CPU_GENERIC32_FLAGS",
  { "CPU_GENERIC32_FLAGS",
    "Cpu186|Cpu286|Cpu386" },
    "Cpu186|Cpu286|Cpu386" },
  { "CPU_GENERIC64_FLAGS",
  { "CPU_GENERIC64_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2|CpuLM" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2|CpuLM" },
  { "CPU_NONE_FLAGS",
  { "CPU_NONE_FLAGS",
   "0" },
   "0" },
  { "CPU_I186_FLAGS",
  { "CPU_I186_FLAGS",
    "Cpu186" },
    "Cpu186" },
  { "CPU_I286_FLAGS",
  { "CPU_I286_FLAGS",
Line 55... Line 57...
  { "CPU_I386_FLAGS",
  { "CPU_I386_FLAGS",
    "Cpu186|Cpu286|Cpu386" },
    "Cpu186|Cpu286|Cpu386" },
  { "CPU_I486_FLAGS",
  { "CPU_I486_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486" },
    "Cpu186|Cpu286|Cpu386|Cpu486" },
  { "CPU_I586_FLAGS",
  { "CPU_I586_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu387" },
  { "CPU_I686_FLAGS",
  { "CPU_I686_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687" },
  { "CPU_P2_FLAGS",
  { "CPU_P2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX" },
  { "CPU_P3_FLAGS",
  { "CPU_P3_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuSSE" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX|CpuSSE" },
  { "CPU_P4_FLAGS",
  { "CPU_P4_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2" },
  { "CPU_NOCONA_FLAGS",
  { "CPU_NOCONA_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuLM" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuLM" },
  { "CPU_CORE_FLAGS",
  { "CPU_CORE_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
  { "CPU_CORE2_FLAGS",
  { "CPU_CORE2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuLM" },
    "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",
  { "CPU_K6_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX" },
  { "CPU_K6_2_FLAGS",
  { "CPU_K6_2_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX|Cpu3dnow" },
  { "CPU_ATHLON_FLAGS",
  { "CPU_ATHLON_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuMMX|Cpu3dnow|Cpu3dnowA" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA" },
  { "CPU_K8_FLAGS",
  { "CPU_K8_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuK8|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
  { "CPU_AMDFAM10_FLAGS",
  { "CPU_AMDFAM10_FLAGS",
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuK8|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM" },
    "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",
  { "CPU_MMX_FLAGS",
    "CpuMMX" },
    "CpuMMX" },
  { "CPU_SSE_FLAGS",
  { "CPU_SSE_FLAGS",
    "CpuMMX|CpuSSE" },
    "CpuMMX|CpuSSE" },
  { "CPU_SSE2_FLAGS",
  { "CPU_SSE2_FLAGS",
Line 94... Line 110...
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
  { "CPU_SSE4_1_FLAGS",
  { "CPU_SSE4_1_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
  { "CPU_SSE4_2_FLAGS",
  { "CPU_SSE4_2_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2" },
    "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",
  { "CPU_VMX_FLAGS",
    "CpuVMX" },
    "CpuVMX" },
  { "CPU_SMX_FLAGS",
  { "CPU_SMX_FLAGS",
    "CpuSMX" },
    "CpuSMX" },
  { "CPU_XSAVE_FLAGS",
  { "CPU_XSAVE_FLAGS",
    "CpuXsave" },
    "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",
  { "CPU_3DNOW_FLAGS",
    "CpuMMX|Cpu3dnow" },
    "CpuMMX|Cpu3dnow" },
  { "CPU_3DNOWA_FLAGS",
  { "CPU_3DNOWA_FLAGS",
    "CpuMMX|Cpu3dnow|Cpu3dnowA" },
    "CpuMMX|Cpu3dnow|Cpu3dnowA" },
  { "CPU_PADLOCK_FLAGS",
  { "CPU_PADLOCK_FLAGS",
Line 112... Line 144...
    "CpuSVME" },
    "CpuSVME" },
  { "CPU_SSE4A_FLAGS",
  { "CPU_SSE4A_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
  { "CPU_ABM_FLAGS",
  { "CPU_ABM_FLAGS",
    "CpuABM" },
    "CpuABM" },
  { "CPU_SSE5_FLAGS",
  { "CPU_AVX_FLAGS",
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuSSE5"},
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX" },
 
  { "CPU_ANY_AVX_FLAGS",
 
    "CpuAVX" },
 
  { "CPU_L1OM_FLAGS",
 
    "unknown" },
};
};
 
 
static initializer operand_type_init [] =
static initializer operand_type_init [] =
{
{
  { "OPERAND_TYPE_NONE",
  { "OPERAND_TYPE_NONE",
Line 180... Line 216...
    "JumpAbsolute" },
    "JumpAbsolute" },
  { "OPERAND_TYPE_REGMMX",
  { "OPERAND_TYPE_REGMMX",
    "RegMMX" },
    "RegMMX" },
  { "OPERAND_TYPE_REGXMM",
  { "OPERAND_TYPE_REGXMM",
    "RegXMM" },
    "RegXMM" },
 
  { "OPERAND_TYPE_REGYMM",
 
    "RegYMM" },
  { "OPERAND_TYPE_ESSEG",
  { "OPERAND_TYPE_ESSEG",
    "EsSeg" },
    "EsSeg" },
  { "OPERAND_TYPE_ACC32",
  { "OPERAND_TYPE_ACC32",
    "Reg32|Acc|Dword" },
    "Reg32|Acc|Dword" },
  { "OPERAND_TYPE_ACC64",
  { "OPERAND_TYPE_ACC64",
Line 227... Line 265...
  BITFIELD (Cpu286),
  BITFIELD (Cpu286),
  BITFIELD (Cpu386),
  BITFIELD (Cpu386),
  BITFIELD (Cpu486),
  BITFIELD (Cpu486),
  BITFIELD (Cpu586),
  BITFIELD (Cpu586),
  BITFIELD (Cpu686),
  BITFIELD (Cpu686),
  BITFIELD (CpuP4),
  BITFIELD (CpuClflush),
  BITFIELD (CpuK6),
  BITFIELD (CpuSYSCALL),
  BITFIELD (CpuK8),
  BITFIELD (Cpu8087),
 
  BITFIELD (Cpu287),
 
  BITFIELD (Cpu387),
 
  BITFIELD (Cpu687),
 
  BITFIELD (CpuFISTTP),
  BITFIELD (CpuMMX),
  BITFIELD (CpuMMX),
  BITFIELD (CpuSSE),
  BITFIELD (CpuSSE),
  BITFIELD (CpuSSE2),
  BITFIELD (CpuSSE2),
  BITFIELD (CpuSSE3),
  BITFIELD (CpuSSE3),
  BITFIELD (CpuSSSE3),
  BITFIELD (CpuSSSE3),
  BITFIELD (CpuSSE4_1),
  BITFIELD (CpuSSE4_1),
  BITFIELD (CpuSSE4_2),
  BITFIELD (CpuSSE4_2),
 
  BITFIELD (CpuAVX),
 
  BITFIELD (CpuL1OM),
  BITFIELD (CpuSSE4a),
  BITFIELD (CpuSSE4a),
  BITFIELD (CpuSSE5),
 
  BITFIELD (Cpu3dnow),
  BITFIELD (Cpu3dnow),
  BITFIELD (Cpu3dnowA),
  BITFIELD (Cpu3dnowA),
  BITFIELD (CpuPadLock),
  BITFIELD (CpuPadLock),
  BITFIELD (CpuSVME),
  BITFIELD (CpuSVME),
  BITFIELD (CpuVMX),
  BITFIELD (CpuVMX),
  BITFIELD (CpuSMX),
  BITFIELD (CpuSMX),
  BITFIELD (CpuABM),
  BITFIELD (CpuABM),
  BITFIELD (CpuLM),
 
  BITFIELD (CpuXsave),
  BITFIELD (CpuXsave),
 
  BITFIELD (CpuAES),
 
  BITFIELD (CpuPCLMUL),
 
  BITFIELD (CpuFMA),
 
  BITFIELD (CpuFMA4),
 
  BITFIELD (CpuLM),
 
  BITFIELD (CpuMovbe),
 
  BITFIELD (CpuEPT),
 
  BITFIELD (CpuRdtscp),
  BITFIELD (Cpu64),
  BITFIELD (Cpu64),
  BITFIELD (CpuNo64),
  BITFIELD (CpuNo64),
#ifdef CpuUnused
#ifdef CpuUnused
  BITFIELD (CpuUnused),
  BITFIELD (CpuUnused),
#endif
#endif
Line 259... Line 309...
 
 
static bitfield opcode_modifiers[] =
static bitfield opcode_modifiers[] =
{
{
  BITFIELD (D),
  BITFIELD (D),
  BITFIELD (W),
  BITFIELD (W),
 
  BITFIELD (S),
  BITFIELD (Modrm),
  BITFIELD (Modrm),
  BITFIELD (ShortForm),
  BITFIELD (ShortForm),
  BITFIELD (Jump),
  BITFIELD (Jump),
  BITFIELD (JumpDword),
  BITFIELD (JumpDword),
  BITFIELD (JumpByte),
  BITFIELD (JumpByte),
Line 283... Line 334...
  BITFIELD (No_ldSuf),
  BITFIELD (No_ldSuf),
  BITFIELD (FWait),
  BITFIELD (FWait),
  BITFIELD (IsString),
  BITFIELD (IsString),
  BITFIELD (RegKludge),
  BITFIELD (RegKludge),
  BITFIELD (FirstXmm0),
  BITFIELD (FirstXmm0),
 
  BITFIELD (Implicit1stXmm0),
  BITFIELD (ByteOkIntel),
  BITFIELD (ByteOkIntel),
  BITFIELD (ToDword),
  BITFIELD (ToDword),
  BITFIELD (ToQword),
  BITFIELD (ToQword),
  BITFIELD (AddrPrefixOp0),
  BITFIELD (AddrPrefixOp0),
  BITFIELD (IsPrefix),
  BITFIELD (IsPrefix),
  BITFIELD (ImmExt),
  BITFIELD (ImmExt),
  BITFIELD (NoRex64),
  BITFIELD (NoRex64),
  BITFIELD (Rex64),
  BITFIELD (Rex64),
  BITFIELD (Ugh),
  BITFIELD (Ugh),
  BITFIELD (Drex),
  BITFIELD (Vex),
  BITFIELD (Drexv),
  BITFIELD (Vex256),
  BITFIELD (Drexc),
  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 (OldGcc),
  BITFIELD (ATTMnemonic),
  BITFIELD (ATTMnemonic),
  BITFIELD (ATTSyntax),
  BITFIELD (ATTSyntax),
  BITFIELD (IntelSyntax),
  BITFIELD (IntelSyntax),
};
};
Line 310... Line 372...
  BITFIELD (Reg32),
  BITFIELD (Reg32),
  BITFIELD (Reg64),
  BITFIELD (Reg64),
  BITFIELD (FloatReg),
  BITFIELD (FloatReg),
  BITFIELD (RegMMX),
  BITFIELD (RegMMX),
  BITFIELD (RegXMM),
  BITFIELD (RegXMM),
 
  BITFIELD (RegYMM),
  BITFIELD (Imm8),
  BITFIELD (Imm8),
  BITFIELD (Imm8S),
  BITFIELD (Imm8S),
  BITFIELD (Imm16),
  BITFIELD (Imm16),
  BITFIELD (Imm32),
  BITFIELD (Imm32),
  BITFIELD (Imm32S),
  BITFIELD (Imm32S),
Line 343... Line 406...
  BITFIELD (Dword),
  BITFIELD (Dword),
  BITFIELD (Fword),
  BITFIELD (Fword),
  BITFIELD (Qword),
  BITFIELD (Qword),
  BITFIELD (Tbyte),
  BITFIELD (Tbyte),
  BITFIELD (Xmmword),
  BITFIELD (Xmmword),
 
  BITFIELD (Ymmword),
  BITFIELD (Unspecified),
  BITFIELD (Unspecified),
  BITFIELD (Anysize),
  BITFIELD (Anysize),
#ifdef OTUnused
#ifdef OTUnused
  BITFIELD (OTUnused),
  BITFIELD (OTUnused),
#endif
#endif
};
};
 
 
static int lineno;
 
static const char *filename;
static const char *filename;
 
 
static int
static int
compare (const void *x, const void *y)
compare (const void *x, const void *y)
{
{
Line 377... Line 440...
 
 
static void
static void
process_copyright (FILE *fp)
process_copyright (FILE *fp)
{
{
  fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
  fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
/* Copyright 2007, 2008  Free Software Foundation, Inc.\n\
/* Copyright 2007, 2008, 2009\n\
 
   Free Software Foundation, Inc.\n\
\n\
\n\
   This file is part of the GNU opcodes library.\n\
   This file is part of the GNU opcodes library.\n\
\n\
\n\
   This library is free software; you can redistribute it and/or modify\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\
   it under the terms of the GNU General Public License as published by\n\
Line 432... Line 496...
 
 
/* Find next field separated by SEP and terminate it. Return a
/* Find next field separated by SEP and terminate it. Return a
   pointer to the one after it.  */
   pointer to the one after it.  */
 
 
static char *
static char *
next_field (char *str, char sep, char **next)
next_field (char *str, char sep, char **next, char *last)
{
{
  char *p;
  char *p;
 
 
  p = remove_leading_whitespaces (str);
  p = remove_leading_whitespaces (str);
  for (str = p; *str != sep && *str != '\0'; str++);
  for (str = p; *str != sep && *str != '\0'; str++);
Line 444... Line 508...
  *str = '\0';
  *str = '\0';
  remove_trailing_whitespaces (p);
  remove_trailing_whitespaces (p);
 
 
  *next = str + 1;
  *next = str + 1;
 
 
 
  if (p >= last)
 
    abort ();
 
 
  return p;
  return p;
}
}
 
 
static void
static void
set_bitfield (const char *f, bitfield *array, unsigned int size)
set_bitfield (const char *f, bitfield *array, int value,
 
              unsigned int size, int lineno)
{
{
  unsigned int i;
  unsigned int i;
 
 
  if (strcmp (f, "CpuSledgehammer") == 0)
  if (strcmp (f, "CpuFP") == 0)
    f= "CpuK8";
    {
 
      set_bitfield("Cpu387", array, value, size, lineno);
 
      set_bitfield("Cpu287", array, value, size, lineno);
 
      f = "Cpu8087";
 
    }
  else if (strcmp (f, "Mmword") == 0)
  else if (strcmp (f, "Mmword") == 0)
    f= "Qword";
    f= "Qword";
  else if (strcmp (f, "Oword") == 0)
  else if (strcmp (f, "Oword") == 0)
    f= "Xmmword";
    f= "Xmmword";
 
 
  for (i = 0; i < size; i++)
  for (i = 0; i < size; i++)
    if (strcasecmp (array[i].name, f) == 0)
    if (strcasecmp (array[i].name, f) == 0)
      {
      {
        array[i].value = 1;
        array[i].value = value;
        return;
        return;
      }
      }
 
 
 
  if (lineno != -1)
  fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
  fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
 
  else
 
    fail (_("Unknown bitfield: %s\n"), f);
}
}
 
 
static void
static void
output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
                  int macro, const char *comma, const char *indent)
                  int macro, const char *comma, const char *indent)
Line 495... Line 570...
  fprintf (table, "%d } }%s\n", flags[i].value, comma);
  fprintf (table, "%d } }%s\n", flags[i].value, comma);
}
}
 
 
static void
static void
process_i386_cpu_flag (FILE *table, char *flag, int macro,
process_i386_cpu_flag (FILE *table, char *flag, int macro,
                       const char *comma, const char *indent)
                       const char *comma, const char *indent,
 
                       int lineno)
{
{
  char *str, *next, *last;
  char *str, *next, *last;
 
  unsigned int i;
  bitfield flags [ARRAY_SIZE (cpu_flags)];
  bitfield flags [ARRAY_SIZE (cpu_flags)];
 
 
  /* Copy the default cpu flags.  */
  /* Copy the default cpu flags.  */
  memcpy (flags, cpu_flags, sizeof (cpu_flags));
  memcpy (flags, cpu_flags, sizeof (cpu_flags));
 
 
  if (strcasecmp (flag, "unknown") == 0)
  if (strcasecmp (flag, "unknown") == 0)
    {
    {
      unsigned int i;
 
 
 
      /* We turn on everything except for cpu64 in case of
      /* We turn on everything except for cpu64 in case of
         CPU_UNKNOWN_FLAGS. */
         CPU_UNKNOWN_FLAGS. */
      for (i = 0; i < ARRAY_SIZE (flags); i++)
      for (i = 0; i < ARRAY_SIZE (flags); i++)
        if (flags[i].position != Cpu64)
        if (flags[i].position != Cpu64)
          flags[i].value = 1;
          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"))
  else if (strcmp (flag, "0"))
    {
    {
 
      /* Turn on selective bits.  */
      last = flag + strlen (flag);
      last = flag + strlen (flag);
      for (next = flag; next && next < last; )
      for (next = flag; next && next < last; )
        {
        {
          str = next_field (next, '|', &next);
          str = next_field (next, '|', &next, last);
          if (str)
          if (str)
            set_bitfield (str, flags, ARRAY_SIZE (flags));
            set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
        }
        }
    }
    }
 
 
  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
                    comma, indent);
                    comma, indent);
Line 546... Line 651...
 
 
  fprintf (table, "%d },\n", modifier[i].value);
  fprintf (table, "%d },\n", modifier[i].value);
}
}
 
 
static void
static void
process_i386_opcode_modifier (FILE *table, char *mod)
process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
{
{
  char *str, *next, *last;
  char *str, *next, *last;
  bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
  bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
 
 
  /* Copy the default opcode modifier.  */
  /* Copy the default opcode modifier.  */
Line 559... Line 664...
  if (strcmp (mod, "0"))
  if (strcmp (mod, "0"))
    {
    {
      last = mod + strlen (mod);
      last = mod + strlen (mod);
      for (next = mod; next && next < last; )
      for (next = mod; next && next < last; )
        {
        {
          str = next_field (next, '|', &next);
          str = next_field (next, '|', &next, last);
          if (str)
          if (str)
            set_bitfield (str, modifiers, ARRAY_SIZE (modifiers));
            set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
 
                          lineno);
        }
        }
    }
    }
  output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
  output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
}
}
 
 
Line 593... Line 699...
  fprintf (table, "%d } }", types[i].value);
  fprintf (table, "%d } }", types[i].value);
}
}
 
 
static void
static void
process_i386_operand_type (FILE *table, char *op, int macro,
process_i386_operand_type (FILE *table, char *op, int macro,
                           const char *indent)
                           const char *indent, int lineno)
{
{
  char *str, *next, *last;
  char *str, *next, *last;
  bitfield types [ARRAY_SIZE (operand_types)];
  bitfield types [ARRAY_SIZE (operand_types)];
 
 
  /* Copy the default operand type.  */
  /* Copy the default operand type.  */
Line 606... Line 712...
  if (strcmp (op, "0"))
  if (strcmp (op, "0"))
    {
    {
      last = op + strlen (op);
      last = op + strlen (op);
      for (next = op; next && next < last; )
      for (next = op; next && next < last; )
        {
        {
          str = next_field (next, '|', &next);
          str = next_field (next, '|', &next, last);
          if (str)
          if (str)
            set_bitfield (str, types, ARRAY_SIZE (types));
            set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
        }
        }
    }
    }
  output_operand_type (table, types, ARRAY_SIZE (types), macro,
  output_operand_type (table, types, ARRAY_SIZE (types), macro,
                       indent);
                       indent);
}
}
 
 
static void
static void
process_i386_opcodes (FILE *table)
output_i386_opcode (FILE *table, const char *name, char *str,
 
                    char *last, int lineno)
{
{
  FILE *fp;
 
  char buf[2048];
 
  unsigned int i;
  unsigned int i;
  char *str, *p, *last;
  char *operands, *base_opcode, *extension_opcode, *opcode_length;
  char *name, *operands, *base_opcode, *extension_opcode;
 
  char *opcode_length;
 
  char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
  char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
 
 
  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));
 
 
 
  fprintf (table, "\n/* i386 opcode table.  */\n\n");
 
  fprintf (table, "const template i386_optab[] =\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 name.  */
 
      name = next_field (p, ',', &str);
 
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find number of operands.  */
      /* Find number of operands.  */
      operands = next_field (str, ',', &str);
  operands = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find base_opcode.  */
      /* Find base_opcode.  */
      base_opcode = next_field (str, ',', &str);
  base_opcode = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find extension_opcode.  */
      /* Find extension_opcode.  */
      extension_opcode = next_field (str, ',', &str);
  extension_opcode = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find opcode_length.  */
      /* Find opcode_length.  */
      opcode_length = next_field (str, ',', &str);
  opcode_length = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find cpu_flags.  */
      /* Find cpu_flags.  */
      cpu_flags = next_field (str, ',', &str);
  cpu_flags = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find opcode_modifier.  */
      /* Find opcode_modifier.  */
      opcode_modifier = next_field (str, ',', &str);
  opcode_modifier = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Remove the first {.  */
      /* Remove the first {.  */
      str = remove_leading_whitespaces (str);
      str = remove_leading_whitespaces (str);
      if (*str != '{')
      if (*str != '{')
        abort ();
        abort ();
Line 742... Line 781...
            {
            {
              operand_types [i] = NULL;
              operand_types [i] = NULL;
              break;
              break;
            }
            }
 
 
          operand_types [i] = next_field (str, ',', &str);
      operand_types [i] = next_field (str, ',', &str, last);
          if (*operand_types[i] == '0')
          if (*operand_types[i] == '0')
            {
            {
              if (i != 0)
              if (i != 0)
                operand_types[i] = NULL;
                operand_types[i] = NULL;
              break;
              break;
Line 755... Line 794...
 
 
      fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
      fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
               name, operands, base_opcode, extension_opcode,
               name, operands, base_opcode, extension_opcode,
               opcode_length);
               opcode_length);
 
 
      process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ");
  process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
 
 
      process_i386_opcode_modifier (table, opcode_modifier);
  process_i386_opcode_modifier (table, opcode_modifier, lineno);
 
 
      fprintf (table, "    { ");
      fprintf (table, "    { ");
 
 
      for (i = 0; i < ARRAY_SIZE (operand_types); i++)
      for (i = 0; i < ARRAY_SIZE (operand_types); i++)
        {
        {
          if (operand_types[i] == NULL
      if (operand_types[i] == NULL || *operand_types[i] == '0')
              || *operand_types[i] == '0')
 
            {
            {
              if (i == 0)
              if (i == 0)
                process_i386_operand_type (table, "0", 0, "\t  ");
            process_i386_operand_type (table, "0", 0, "\t  ", lineno);
              break;
              break;
            }
            }
 
 
          if (i != 0)
          if (i != 0)
            fprintf (table, ",\n      ");
            fprintf (table, ",\n      ");
 
 
          process_i386_operand_type (table, operand_types[i], 0,
          process_i386_operand_type (table, operand_types[i], 0,
                                     "\t  ");
                                 "\t  ", lineno);
        }
        }
      fprintf (table, " } },\n");
      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);
  fclose (fp);
 
 
  fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
  fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
 
 
  process_i386_cpu_flag (table, "0", 0, ",", "    ");
  process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
 
 
  process_i386_opcode_modifier (table, "0");
  process_i386_opcode_modifier (table, "0", -1);
 
 
  fprintf (table, "    { ");
  fprintf (table, "    { ");
  process_i386_operand_type (table, "0", 0, "\t  ");
  process_i386_operand_type (table, "0", 0, "\t  ", -1);
  fprintf (table, " } }\n");
  fprintf (table, " } }\n");
 
 
  fprintf (table, "};\n");
  fprintf (table, "};\n");
}
}
 
 
Line 803... Line 988...
  FILE *fp;
  FILE *fp;
  char buf[2048];
  char buf[2048];
  char *str, *p, *last;
  char *str, *p, *last;
  char *reg_name, *reg_type, *reg_flags, *reg_num;
  char *reg_name, *reg_type, *reg_flags, *reg_num;
  char *dw2_32_num, *dw2_64_num;
  char *dw2_32_num, *dw2_64_num;
 
  int lineno = 0;
 
 
  filename = "i386-reg.tbl";
  filename = "i386-reg.tbl";
  fp = fopen (filename, "r");
  fp = fopen (filename, "r");
  if (fp == NULL)
  if (fp == NULL)
    fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
    fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
Line 844... Line 1030...
        }
        }
 
 
      last = p + strlen (p);
      last = p + strlen (p);
 
 
      /* Find reg_name.  */
      /* Find reg_name.  */
      reg_name = next_field (p, ',', &str);
      reg_name = next_field (p, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find reg_type.  */
      /* Find reg_type.  */
      reg_type = next_field (str, ',', &str);
      reg_type = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find reg_flags.  */
      /* Find reg_flags.  */
      reg_flags = next_field (str, ',', &str);
      reg_flags = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find reg_num.  */
      /* Find reg_num.  */
      reg_num = next_field (str, ',', &str);
      reg_num = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      fprintf (table, "  { \"%s\",\n    ", reg_name);
      fprintf (table, "  { \"%s\",\n    ", reg_name);
 
 
      process_i386_operand_type (table, reg_type, 0, "\t");
      process_i386_operand_type (table, reg_type, 0, "\t", lineno);
 
 
      /* Find 32-bit Dwarf2 register number.  */
      /* Find 32-bit Dwarf2 register number.  */
      dw2_32_num = next_field (str, ',', &str);
      dw2_32_num = next_field (str, ',', &str, last);
 
 
      if (str >= last)
 
        abort ();
 
 
 
      /* Find 64-bit Dwarf2 register number.  */
      /* Find 64-bit Dwarf2 register number.  */
      dw2_64_num = next_field (str, ',', &str);
      dw2_64_num = next_field (str, ',', &str, last);
 
 
      fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
      fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
               reg_flags, reg_num, dw2_32_num, dw2_64_num);
               reg_flags, reg_num, dw2_32_num, dw2_64_num);
    }
    }
 
 
Line 908... Line 1079...
 
 
  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
    {
    {
      fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
      fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
      init = xstrdup (cpu_flag_init[i].init);
      init = xstrdup (cpu_flag_init[i].init);
      process_i386_cpu_flag (fp, init, 1, "", "  ");
      process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
      free (init);
      free (init);
    }
    }
 
 
  for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
  for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
    {
    {
      fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
      fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
      init = xstrdup (operand_type_init[i].init);
      init = xstrdup (operand_type_init[i].init);
      process_i386_operand_type (fp, init, 1, "      ");
      process_i386_operand_type (fp, init, 1, "      ", -1);
      free (init);
      free (init);
    }
    }
  fprintf (fp, "\n");
  fprintf (fp, "\n");
 
 
  fclose (fp);
  fclose (fp);

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.