opcodes/i386-gen.c

   1 /* Copyright (C) 2007-2014 Free Software Foundation, Inc.
   2
   3    This file is part of the GNU opcodes library.
   4
   5    This library is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    It is distributed in the hope that it will be useful, but WITHOUT
  11    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  13    License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  18    MA 02110-1301, USA.  */
  19
  20 #include "sysdep.h"
  21 #include <stdio.h>
  22 #include <errno.h>
  23 #include "getopt.h"
  24 #include "libiberty.h"
  25 #include "hashtab.h"
  26 #include "safe-ctype.h"
  27
  28 #include "i386-opc.h"
  29
  30 #include <libintl.h>
  31 #define _(String) gettext (String)
  32
  33 static const char *program_name = NULL;
  34 static int debug = 0;
  35
  36 typedef struct initializer
  37 {
  38   const char *name;
  39   const char *init;
  40 } initializer;
  41
  42 static initializer cpu_flag_init[] =
  43 {
  44   { "CPU_UNKNOWN_FLAGS",
  45     "~(CpuL1OM|CpuK1OM)" },
  46   { "CPU_GENERIC32_FLAGS",
  47     "Cpu186|Cpu286|Cpu386" },
  48   { "CPU_GENERIC64_FLAGS",
  49     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuLM" },
  50   { "CPU_NONE_FLAGS",
  51    "0" },
  52   { "CPU_I186_FLAGS",
  53     "Cpu186" },
  54   { "CPU_I286_FLAGS",
  55     "Cpu186|Cpu286" },
  56   { "CPU_I386_FLAGS",
  57     "Cpu186|Cpu286|Cpu386" },
  58   { "CPU_I486_FLAGS",
  59     "Cpu186|Cpu286|Cpu386|Cpu486" },
  60   { "CPU_I586_FLAGS",
  61     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu387" },
  62   { "CPU_I686_FLAGS",
  63     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687" },
  64   { "CPU_PENTIUMPRO_FLAGS",
  65     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuNop" },
  66   { "CPU_P2_FLAGS",
  67     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuNop|CpuMMX" },
  68   { "CPU_P3_FLAGS",
  69     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuNop|CpuMMX|CpuSSE" },
  70   { "CPU_P4_FLAGS",
  71     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuNop|CpuMMX|CpuSSE|CpuSSE2" },
  72   { "CPU_NOCONA_FLAGS",
  73     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuLM|CpuCX16" },
  74   { "CPU_CORE_FLAGS",
  75     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuCX16" },
  76   { "CPU_CORE2_FLAGS",
  77     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuLM|CpuCX16" },
  78   { "CPU_COREI7_FLAGS",
  79     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuRdtscp|CpuLM|CpuCX16" },
  80   { "CPU_K6_FLAGS",
  81     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX" },
  82   { "CPU_K6_2_FLAGS",
  83     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX|Cpu3dnow" },
  84   { "CPU_ATHLON_FLAGS",
  85     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|Cpu387|Cpu687|CpuNop|CpuMMX|Cpu3dnow|Cpu3dnowA" },
  86   { "CPU_K8_FLAGS",
  87     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuNop|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
  88   { "CPU_AMDFAM10_FLAGS",
  89     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM" },
  90   { "CPU_BDVER1_FLAGS",
  91     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM|CpuFMA4|CpuXOP|CpuLWP|CpuCX16|CpuClflush|CpuSSSE3|CpuSVME|CpuSSE4_1|CpuSSE4_2|CpuXsave|CpuAES|CpuAVX|CpuPCLMUL|CpuLZCNT|CpuPRFCHW" },
  92   { "CPU_BDVER2_FLAGS",
  93     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM|CpuFMA|CpuFMA4|CpuXOP|CpuLWP|CpuBMI|CpuTBM|CpuF16C|CpuCX16|CpuClflush|CpuSSSE3|CpuSVME|CpuSSE4_1|CpuSSE4_2|CpuXsave|CpuAES|CpuAVX|CpuPCLMUL|CpuLZCNT|CpuPRFCHW" },
  94   { "CPU_BDVER3_FLAGS",
  95     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM|CpuFMA|CpuFMA4|CpuXOP|CpuLWP|CpuBMI|CpuTBM|CpuF16C|CpuCX16|CpuClflush|CpuSSSE3|CpuSVME|CpuSSE4_1|CpuSSE4_2|CpuAES|CpuAVX|CpuPCLMUL|CpuLZCNT|CpuPRFCHW|CpuXsave|CpuXsaveopt|CpuFSGSBase" },
  96   { "CPU_BDVER4_FLAGS",
  97     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM|CpuFMA|CpuFMA4|CpuXOP|CpuLWP|CpuBMI|CpuTBM|CpuF16C|CpuCX16|CpuClflush|CpuSSSE3|CpuSVME|CpuSSE4_1|CpuSSE4_2|CpuAES|CpuAVX|CpuPCLMUL|CpuLZCNT|CpuPRFCHW|CpuXsave|CpuXsaveopt|CpuFSGSBase|CpuAVX2|CpuMovbe|CpuBMI2|CpuRdRnd" },
  98   { "CPU_BTVER1_FLAGS",
  99     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4a|CpuABM|CpuLM|CpuPRFCHW|CpuCX16|CpuClflush|CpuFISTTP|CpuSVME|CpuLZCNT" },
 100   { "CPU_BTVER2_FLAGS",
 101     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuNop|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4a|CpuSSE4_1|CpuSSE4_2|CpuABM|CpuLM|CpuBMI|CpuF16C|CpuAES|CpuPCLMUL|CpuAVX|CpuMovbe|CpuXsave|CpuXsaveopt|CpuPRFCHW|CpuCX16|CpuClflush|CpuFISTTP|CpuSVME|CpuLZCNT" },
 102   { "CPU_8087_FLAGS",
 103     "Cpu8087" },
 104   { "CPU_287_FLAGS",
 105     "Cpu287" },
 106   { "CPU_387_FLAGS",
 107     "Cpu387" },
 108   { "CPU_ANY87_FLAGS",
 109     "Cpu8087|Cpu287|Cpu387|Cpu687|CpuFISTTP" },
 110   { "CPU_CLFLUSH_FLAGS",
 111     "CpuClflush" },
 112   { "CPU_NOP_FLAGS",
 113     "CpuNop" },
 114   { "CPU_SYSCALL_FLAGS",
 115     "CpuSYSCALL" },
 116   { "CPU_MMX_FLAGS",
 117     "CpuMMX" },
 118   { "CPU_SSE_FLAGS",
 119     "CpuMMX|CpuSSE" },
 120   { "CPU_SSE2_FLAGS",
 121     "CpuMMX|CpuSSE|CpuSSE2" },
 122   { "CPU_SSE3_FLAGS",
 123     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
 124   { "CPU_SSSE3_FLAGS",
 125     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
 126   { "CPU_SSE4_1_FLAGS",
 127     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
 128   { "CPU_SSE4_2_FLAGS",
 129     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2" },
 130   { "CPU_ANY_SSE_FLAGS",
 131     "CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuSSE4a|CpuAVX|CpuAVX2|CpuAVX512F|CpuAVX512CD|CpuAVX512ER|CpuAVX512PF" },
 132   { "CPU_VMX_FLAGS",
 133     "CpuVMX" },
 134   { "CPU_SMX_FLAGS",
 135     "CpuSMX" },
 136   { "CPU_XSAVE_FLAGS",
 137     "CpuXsave" },
 138   { "CPU_XSAVEOPT_FLAGS",
 139     "CpuXsaveopt" },
 140   { "CPU_AES_FLAGS",
 141     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAES" },
 142   { "CPU_PCLMUL_FLAGS",
 143     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuPCLMUL" },
 144   { "CPU_FMA_FLAGS",
 145     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA" },
 146   { "CPU_FMA4_FLAGS",
 147     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA4" },
 148   { "CPU_XOP_FLAGS",
 149     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuSSE4a|CpuABM|CpuAVX|CpuFMA4|CpuXOP" },
 150   { "CPU_LWP_FLAGS",
 151     "CpuLWP" },
 152   { "CPU_BMI_FLAGS",
 153     "CpuBMI" },
 154   { "CPU_TBM_FLAGS",
 155     "CpuTBM" },
 156   { "CPU_MOVBE_FLAGS",
 157     "CpuMovbe" },
 158   { "CPU_CX16_FLAGS",
 159     "CpuCX16" },
 160   { "CPU_RDTSCP_FLAGS",
 161     "CpuRdtscp" },
 162   { "CPU_EPT_FLAGS",
 163     "CpuEPT" },
 164   { "CPU_FSGSBASE_FLAGS",
 165     "CpuFSGSBase" },
 166   { "CPU_RDRND_FLAGS",
 167     "CpuRdRnd" },
 168   { "CPU_F16C_FLAGS",
 169     "CpuF16C" },
 170   { "CPU_BMI2_FLAGS",
 171     "CpuBMI2" },
 172   { "CPU_LZCNT_FLAGS",
 173     "CpuLZCNT" },
 174   { "CPU_HLE_FLAGS",
 175     "CpuHLE" },
 176   { "CPU_RTM_FLAGS",
 177     "CpuRTM" },
 178   { "CPU_INVPCID_FLAGS",
 179     "CpuINVPCID" },
 180   { "CPU_VMFUNC_FLAGS",
 181     "CpuVMFUNC" },
 182   { "CPU_3DNOW_FLAGS",
 183     "CpuMMX|Cpu3dnow" },
 184   { "CPU_3DNOWA_FLAGS",
 185     "CpuMMX|Cpu3dnow|Cpu3dnowA" },
 186   { "CPU_PADLOCK_FLAGS",
 187     "CpuPadLock" },
 188   { "CPU_SVME_FLAGS",
 189     "CpuSVME" },
 190   { "CPU_SSE4A_FLAGS",
 191     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
 192   { "CPU_ABM_FLAGS",
 193     "CpuABM" },
 194   { "CPU_AVX_FLAGS",
 195     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX" },
 196   { "CPU_AVX2_FLAGS",
 197     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuAVX2" },
 198   { "CPU_AVX512F_FLAGS",
 199     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuAVX2|CpuAVX512F" },
 200   { "CPU_AVX512CD_FLAGS",
 201     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuAVX2|CpuAVX512F|CpuAVX512CD" },
 202   { "CPU_AVX512ER_FLAGS",
 203     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuAVX2|CpuAVX512F|CpuAVX512ER" },
 204   { "CPU_AVX512PF_FLAGS",
 205     "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuAVX2|CpuAVX512F|CpuAVX512PF" },
 206   { "CPU_ANY_AVX_FLAGS",
 207     "CpuAVX|CpuAVX2|CpuAVX512F|CpuAVX512CD|CpuAVX512ER|CpuAVX512PF" },
 208   { "CPU_L1OM_FLAGS",
 209     "unknown" },
 210   { "CPU_K1OM_FLAGS",
 211     "unknown" },
 212   { "CPU_ADX_FLAGS",
 213     "CpuADX" },
 214   { "CPU_RDSEED_FLAGS",
 215     "CpuRdSeed" },
 216   { "CPU_PRFCHW_FLAGS",
 217     "CpuPRFCHW" },
 218   { "CPU_SMAP_FLAGS",
 219     "CpuSMAP" },
 220   { "CPU_MPX_FLAGS",
 221     "CpuMPX" },
 222   { "CPU_SHA_FLAGS",
 223     "CpuSHA" },
 224   { "CPU_CLFLUSHOPT_FLAGS",
 225     "CpuClflushOpt" },
 226   { "CPU_XSAVES_FLAGS",
 227     "CpuXSAVES" },
 228   { "CPU_XSAVEC_FLAGS",
 229     "CpuXSAVEC" },
 230   { "CPU_PREFETCHWT1_FLAGS",
 231     "CpuPREFETCHWT1" },
 232 };
 233
 234 static initializer operand_type_init[] =
 235 {
 236   { "OPERAND_TYPE_NONE",
 237     "0" },
 238   { "OPERAND_TYPE_REG8",
 239     "Reg8" },
 240   { "OPERAND_TYPE_REG16",
 241     "Reg16" },
 242   { "OPERAND_TYPE_REG32",
 243     "Reg32" },
 244   { "OPERAND_TYPE_REG64",
 245     "Reg64" },
 246   { "OPERAND_TYPE_IMM1",
 247     "Imm1" },
 248   { "OPERAND_TYPE_IMM8",
 249     "Imm8" },
 250   { "OPERAND_TYPE_IMM8S",
 251     "Imm8S" },
 252   { "OPERAND_TYPE_IMM16",
 253     "Imm16" },
 254   { "OPERAND_TYPE_IMM32",
 255     "Imm32" },
 256   { "OPERAND_TYPE_IMM32S",
 257     "Imm32S" },
 258   { "OPERAND_TYPE_IMM64",
 259     "Imm64" },
 260   { "OPERAND_TYPE_BASEINDEX",
 261     "BaseIndex" },
 262   { "OPERAND_TYPE_DISP8",
 263     "Disp8" },
 264   { "OPERAND_TYPE_DISP16",
 265     "Disp16" },
 266   { "OPERAND_TYPE_DISP32",
 267     "Disp32" },
 268   { "OPERAND_TYPE_DISP32S",
 269     "Disp32S" },
 270   { "OPERAND_TYPE_DISP64",
 271     "Disp64" },
 272   { "OPERAND_TYPE_INOUTPORTREG",
 273     "InOutPortReg" },
 274   { "OPERAND_TYPE_SHIFTCOUNT",
 275     "ShiftCount" },
 276   { "OPERAND_TYPE_CONTROL",
 277     "Control" },
 278   { "OPERAND_TYPE_TEST",
 279     "Test" },
 280   { "OPERAND_TYPE_DEBUG",
 281     "FloatReg" },
 282   { "OPERAND_TYPE_FLOATREG",
 283     "FloatReg" },
 284   { "OPERAND_TYPE_FLOATACC",
 285     "FloatAcc" },
 286   { "OPERAND_TYPE_SREG2",
 287     "SReg2" },
 288   { "OPERAND_TYPE_SREG3",
 289     "SReg3" },
 290   { "OPERAND_TYPE_ACC",
 291     "Acc" },
 292   { "OPERAND_TYPE_JUMPABSOLUTE",
 293     "JumpAbsolute" },
 294   { "OPERAND_TYPE_REGMMX",
 295     "RegMMX" },
 296   { "OPERAND_TYPE_REGXMM",
 297     "RegXMM" },
 298   { "OPERAND_TYPE_REGYMM",
 299     "RegYMM" },
 300   { "OPERAND_TYPE_REGZMM",
 301     "RegZMM" },
 302   { "OPERAND_TYPE_REGMASK",
 303     "RegMask" },
 304   { "OPERAND_TYPE_ESSEG",
 305     "EsSeg" },
 306   { "OPERAND_TYPE_ACC32",
 307     "Reg32|Acc|Dword" },
 308   { "OPERAND_TYPE_ACC64",
 309     "Reg64|Acc|Qword" },
 310   { "OPERAND_TYPE_INOUTPORTREG",
 311     "InOutPortReg" },
 312   { "OPERAND_TYPE_REG16_INOUTPORTREG",
 313     "Reg16|InOutPortReg" },
 314   { "OPERAND_TYPE_DISP16_32",
 315     "Disp16|Disp32" },
 316   { "OPERAND_TYPE_ANYDISP",
 317     "Disp8|Disp16|Disp32|Disp32S|Disp64" },
 318   { "OPERAND_TYPE_IMM16_32",
 319     "Imm16|Imm32" },
 320   { "OPERAND_TYPE_IMM16_32S",
 321     "Imm16|Imm32S" },
 322   { "OPERAND_TYPE_IMM16_32_32S",
 323     "Imm16|Imm32|Imm32S" },
 324   { "OPERAND_TYPE_IMM32_64",
 325     "Imm32|Imm64" },
 326   { "OPERAND_TYPE_IMM32_32S_DISP32",
 327     "Imm32|Imm32S|Disp32" },
 328   { "OPERAND_TYPE_IMM64_DISP64",
 329     "Imm64|Disp64" },
 330   { "OPERAND_TYPE_IMM32_32S_64_DISP32",
 331     "Imm32|Imm32S|Imm64|Disp32" },
 332   { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
 333     "Imm32|Imm32S|Imm64|Disp32|Disp64" },
 334   { "OPERAND_TYPE_VEC_IMM4",
 335     "Vec_Imm4" },
 336   { "OPERAND_TYPE_REGBND",
 337     "RegBND" },
 338   { "OPERAND_TYPE_VEC_DISP8",
 339     "Vec_Disp8" },
 340 };
 341
 342 typedef struct bitfield
 343 {
 344   int position;
 345   int value;
 346   const char *name;
 347 } bitfield;
 348
 349 #define BITFIELD(n) { n, 0, #n }
 350
 351 static bitfield cpu_flags[] =
 352 {
 353   BITFIELD (Cpu186),
 354   BITFIELD (Cpu286),
 355   BITFIELD (Cpu386),
 356   BITFIELD (Cpu486),
 357   BITFIELD (Cpu586),
 358   BITFIELD (Cpu686),
 359   BITFIELD (CpuClflush),
 360   BITFIELD (CpuNop),
 361   BITFIELD (CpuSYSCALL),
 362   BITFIELD (Cpu8087),
 363   BITFIELD (Cpu287),
 364   BITFIELD (Cpu387),
 365   BITFIELD (Cpu687),
 366   BITFIELD (CpuFISTTP),
 367   BITFIELD (CpuMMX),
 368   BITFIELD (CpuSSE),
 369   BITFIELD (CpuSSE2),
 370   BITFIELD (CpuSSE3),
 371   BITFIELD (CpuSSSE3),
 372   BITFIELD (CpuSSE4_1),
 373   BITFIELD (CpuSSE4_2),
 374   BITFIELD (CpuAVX),
 375   BITFIELD (CpuAVX2),
 376   BITFIELD (CpuAVX512F),
 377   BITFIELD (CpuAVX512CD),
 378   BITFIELD (CpuAVX512ER),
 379   BITFIELD (CpuAVX512PF),
 380   BITFIELD (CpuL1OM),
 381   BITFIELD (CpuK1OM),
 382   BITFIELD (CpuSSE4a),
 383   BITFIELD (Cpu3dnow),
 384   BITFIELD (Cpu3dnowA),
 385   BITFIELD (CpuPadLock),
 386   BITFIELD (CpuSVME),
 387   BITFIELD (CpuVMX),
 388   BITFIELD (CpuSMX),
 389   BITFIELD (CpuABM),
 390   BITFIELD (CpuXsave),
 391   BITFIELD (CpuXsaveopt),
 392   BITFIELD (CpuAES),
 393   BITFIELD (CpuPCLMUL),
 394   BITFIELD (CpuFMA),
 395   BITFIELD (CpuFMA4),
 396   BITFIELD (CpuXOP),
 397   BITFIELD (CpuLWP),
 398   BITFIELD (CpuBMI),
 399   BITFIELD (CpuTBM),
 400   BITFIELD (CpuLM),
 401   BITFIELD (CpuMovbe),
 402   BITFIELD (CpuCX16),
 403   BITFIELD (CpuEPT),
 404   BITFIELD (CpuRdtscp),
 405   BITFIELD (CpuFSGSBase),
 406   BITFIELD (CpuRdRnd),
 407   BITFIELD (CpuF16C),
 408   BITFIELD (CpuBMI2),
 409   BITFIELD (CpuLZCNT),
 410   BITFIELD (CpuHLE),
 411   BITFIELD (CpuRTM),
 412   BITFIELD (CpuINVPCID),
 413   BITFIELD (CpuVMFUNC),
 414   BITFIELD (CpuRDSEED),
 415   BITFIELD (CpuADX),
 416   BITFIELD (CpuPRFCHW),
 417   BITFIELD (CpuSMAP),
 418   BITFIELD (CpuSHA),
 419   BITFIELD (CpuVREX),
 420   BITFIELD (CpuClflushOpt),
 421   BITFIELD (CpuXSAVES),
 422   BITFIELD (CpuXSAVEC),
 423   BITFIELD (CpuPREFETCHWT1),
 424   BITFIELD (Cpu64),
 425   BITFIELD (CpuNo64),
 426   BITFIELD (CpuMPX),
 427 #ifdef CpuUnused
 428   BITFIELD (CpuUnused),
 429 #endif
 430 };
 431
 432 static bitfield opcode_modifiers[] =
 433 {
 434   BITFIELD (D),
 435   BITFIELD (W),
 436   BITFIELD (S),
 437   BITFIELD (Modrm),
 438   BITFIELD (ShortForm),
 439   BITFIELD (Jump),
 440   BITFIELD (JumpDword),
 441   BITFIELD (JumpByte),
 442   BITFIELD (JumpInterSegment),
 443   BITFIELD (FloatMF),
 444   BITFIELD (FloatR),
 445   BITFIELD (FloatD),
 446   BITFIELD (Size16),
 447   BITFIELD (Size32),
 448   BITFIELD (Size64),
 449   BITFIELD (CheckRegSize),
 450   BITFIELD (IgnoreSize),
 451   BITFIELD (DefaultSize),
 452   BITFIELD (No_bSuf),
 453   BITFIELD (No_wSuf),
 454   BITFIELD (No_lSuf),
 455   BITFIELD (No_sSuf),
 456   BITFIELD (No_qSuf),
 457   BITFIELD (No_ldSuf),
 458   BITFIELD (FWait),
 459   BITFIELD (IsString),
 460   BITFIELD (BNDPrefixOk),
 461   BITFIELD (IsLockable),
 462   BITFIELD (RegKludge),
 463   BITFIELD (FirstXmm0),
 464   BITFIELD (Implicit1stXmm0),
 465   BITFIELD (RepPrefixOk),
 466   BITFIELD (HLEPrefixOk),
 467   BITFIELD (ToDword),
 468   BITFIELD (ToQword),
 469   BITFIELD (AddrPrefixOp0),
 470   BITFIELD (IsPrefix),
 471   BITFIELD (ImmExt),
 472   BITFIELD (NoRex64),
 473   BITFIELD (Rex64),
 474   BITFIELD (Ugh),
 475   BITFIELD (Vex),
 476   BITFIELD (VexVVVV),
 477   BITFIELD (VexW),
 478   BITFIELD (VexOpcode),
 479   BITFIELD (VexSources),
 480   BITFIELD (VexImmExt),
 481   BITFIELD (VecSIB),
 482   BITFIELD (SSE2AVX),
 483   BITFIELD (NoAVX),
 484   BITFIELD (EVex),
 485   BITFIELD (Masking),
 486   BITFIELD (VecESize),
 487   BITFIELD (Broadcast),
 488   BITFIELD (StaticRounding),
 489   BITFIELD (SAE),
 490   BITFIELD (Disp8MemShift),
 491   BITFIELD (NoDefMask),
 492   BITFIELD (OldGcc),
 493   BITFIELD (ATTMnemonic),
 494   BITFIELD (ATTSyntax),
 495   BITFIELD (IntelSyntax),
 496 };
 497
 498 static bitfield operand_types[] =
 499 {
 500   BITFIELD (Reg8),
 501   BITFIELD (Reg16),
 502   BITFIELD (Reg32),
 503   BITFIELD (Reg64),
 504   BITFIELD (FloatReg),
 505   BITFIELD (RegMMX),
 506   BITFIELD (RegXMM),
 507   BITFIELD (RegYMM),
 508   BITFIELD (RegZMM),
 509   BITFIELD (RegMask),
 510   BITFIELD (Imm1),
 511   BITFIELD (Imm8),
 512   BITFIELD (Imm8S),
 513   BITFIELD (Imm16),
 514   BITFIELD (Imm32),
 515   BITFIELD (Imm32S),
 516   BITFIELD (Imm64),
 517   BITFIELD (BaseIndex),
 518   BITFIELD (Disp8),
 519   BITFIELD (Disp16),
 520   BITFIELD (Disp32),
 521   BITFIELD (Disp32S),
 522   BITFIELD (Disp64),
 523   BITFIELD (InOutPortReg),
 524   BITFIELD (ShiftCount),
 525   BITFIELD (Control),
 526   BITFIELD (Debug),
 527   BITFIELD (Test),
 528   BITFIELD (SReg2),
 529   BITFIELD (SReg3),
 530   BITFIELD (Acc),
 531   BITFIELD (FloatAcc),
 532   BITFIELD (JumpAbsolute),
 533   BITFIELD (EsSeg),
 534   BITFIELD (RegMem),
 535   BITFIELD (Mem),
 536   BITFIELD (Byte),
 537   BITFIELD (Word),
 538   BITFIELD (Dword),
 539   BITFIELD (Fword),
 540   BITFIELD (Qword),
 541   BITFIELD (Tbyte),
 542   BITFIELD (Xmmword),
 543   BITFIELD (Ymmword),
 544   BITFIELD (Zmmword),
 545   BITFIELD (Unspecified),
 546   BITFIELD (Anysize),
 547   BITFIELD (Vec_Imm4),
 548   BITFIELD (RegBND),
 549   BITFIELD (Vec_Disp8),
 550 #ifdef OTUnused
 551   BITFIELD (OTUnused),
 552 #endif
 553 };
 554
 555 static const char *filename;
 556
 557 static int
 558 compare (const void *x, const void *y)
 559 {
 560   const bitfield *xp = (const bitfield *) x;
 561   const bitfield *yp = (const bitfield *) y;
 562   return xp->position - yp->position;
 563 }
 564
 565 static void
 566 fail (const char *message, ...)
 567 {
 568   va_list args;
 569
 570   va_start (args, message);
 571   fprintf (stderr, _("%s: Error: "), program_name);
 572   vfprintf (stderr, message, args);
 573   va_end (args);
 574   xexit (1);
 575 }
 576
 577 static void
 578 process_copyright (FILE *fp)
 579 {
 580   fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
 581 /* Copyright (C) 2007-2014 Free Software Foundation, Inc.\n\
 582 \n\
 583    This file is part of the GNU opcodes library.\n\
 584 \n\
 585    This library is free software; you can redistribute it and/or modify\n\
 586    it under the terms of the GNU General Public License as published by\n\
 587    the Free Software Foundation; either version 3, or (at your option)\n\
 588    any later version.\n\
 589 \n\
 590    It is distributed in the hope that it will be useful, but WITHOUT\n\
 591    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
 592    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
 593    License for more details.\n\
 594 \n\
 595    You should have received a copy of the GNU General Public License\n\
 596    along with this program; if not, write to the Free Software\n\
 597    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
 598    MA 02110-1301, USA.  */\n");
 599 }
 600
 601 /* Remove leading white spaces.  */
 602
 603 static char *
 604 remove_leading_whitespaces (char *str)
 605 {
 606   while (ISSPACE (*str))
 607     str++;
 608   return str;
 609 }
 610
 611 /* Remove trailing white spaces.  */
 612
 613 static void
 614 remove_trailing_whitespaces (char *str)
 615 {
 616   size_t last = strlen (str);
 617
 618   if (last == 0)
 619     return;
 620
 621   do
 622     {
 623       last--;
 624       if (ISSPACE (str [last]))
 625         str[last] = '\0';
 626       else
 627         break;
 628     }
 629   while (last != 0);
 630 }
 631
 632 /* Find next field separated by SEP and terminate it. Return a
 633    pointer to the one after it.  */
 634
 635 static char *
 636 next_field (char *str, char sep, char **next, char *last)
 637 {
 638   char *p;
 639
 640   p = remove_leading_whitespaces (str);
 641   for (str = p; *str != sep && *str != '\0'; str++);
 642
 643   *str = '\0';
 644   remove_trailing_whitespaces (p);
 645
 646   *next = str + 1;
 647
 648   if (p >= last)
 649     abort ();
 650
 651   return p;
 652 }
 653
 654 static void
 655 set_bitfield (const char *f, bitfield *array, int value,
 656               unsigned int size, int lineno)
 657 {
 658   unsigned int i;
 659
 660   if (strcmp (f, "CpuFP") == 0)
 661     {
 662       set_bitfield("Cpu387", array, value, size, lineno);
 663       set_bitfield("Cpu287", array, value, size, lineno);
 664       f = "Cpu8087";
 665     }
 666   else if (strcmp (f, "Mmword") == 0)
 667     f= "Qword";
 668   else if (strcmp (f, "Oword") == 0)
 669     f= "Xmmword";
 670
 671   for (i = 0; i < size; i++)
 672     if (strcasecmp (array[i].name, f) == 0)
 673       {
 674         array[i].value = value;
 675         return;
 676       }
 677
 678   if (value)
 679     {
 680       const char *v = strchr (f, '=');
 681
 682       if (v)
 683         {
 684           size_t n = v - f;
 685           char *end;
 686
 687           for (i = 0; i < size; i++)
 688             if (strncasecmp (array[i].name, f, n) == 0)
 689               {
 690                 value = strtol (v + 1, &end, 0);
 691                 if (*end == '\0')
 692                   {
 693                     array[i].value = value;
 694                     return;
 695                   }
 696                 break;
 697               }
 698         }
 699     }
 700
 701   if (lineno != -1)
 702     fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
 703   else
 704     fail (_("Unknown bitfield: %s\n"), f);
 705 }
 706
 707 static void
 708 output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
 709                   int macro, const char *comma, const char *indent)
 710 {
 711   unsigned int i;
 712
 713   fprintf (table, "%s{ { ", indent);
 714
 715   for (i = 0; i < size - 1; i++)
 716     {
 717       if (((i + 1) % 20) != 0)
 718         fprintf (table, "%d, ", flags[i].value);
 719       else
 720         fprintf (table, "%d,", flags[i].value);
 721       if (((i + 1) % 20) == 0)
 722         {
 723           /* We need \\ for macro.  */
 724           if (macro)
 725             fprintf (table, " \\\n    %s", indent);
 726           else
 727             fprintf (table, "\n    %s", indent);
 728         }
 729     }
 730
 731   fprintf (table, "%d } }%s\n", flags[i].value, comma);
 732 }
 733
 734 static void
 735 process_i386_cpu_flag (FILE *table, char *flag, int macro,
 736                        const char *comma, const char *indent,
 737                        int lineno)
 738 {
 739   char *str, *next, *last;
 740   unsigned int i;
 741   bitfield flags [ARRAY_SIZE (cpu_flags)];
 742
 743   /* Copy the default cpu flags.  */
 744   memcpy (flags, cpu_flags, sizeof (cpu_flags));
 745
 746   if (strcasecmp (flag, "unknown") == 0)
 747     {
 748       /* We turn on everything except for cpu64 in case of
 749          CPU_UNKNOWN_FLAGS.  */
 750       for (i = 0; i < ARRAY_SIZE (flags); i++)
 751         if (flags[i].position != Cpu64)
 752           flags[i].value = 1;
 753     }
 754   else if (flag[0] == '~')
 755     {
 756       last = flag + strlen (flag);
 757
 758       if (flag[1] == '(')
 759         {
 760           last -= 1;
 761           next = flag + 2;
 762           if (*last != ')')
 763             fail (_("%s: %d: Missing `)' in bitfield: %s\n"), filename,
 764                   lineno, flag);
 765           *last = '\0';
 766         }
 767       else
 768         next = flag + 1;
 769
 770       /* First we turn on everything except for cpu64.  */
 771       for (i = 0; i < ARRAY_SIZE (flags); i++)
 772         if (flags[i].position != Cpu64)
 773           flags[i].value = 1;
 774
 775       /* Turn off selective bits.  */
 776       for (; next && next < last; )
 777         {
 778           str = next_field (next, '|', &next, last);
 779           if (str)
 780             set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
 781         }
 782     }
 783   else if (strcmp (flag, "0"))
 784     {
 785       /* Turn on selective bits.  */
 786       last = flag + strlen (flag);
 787       for (next = flag; next && next < last; )
 788         {
 789           str = next_field (next, '|', &next, last);
 790           if (str)
 791             set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
 792         }
 793     }
 794
 795   output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
 796                     comma, indent);
 797 }
 798
 799 static void
 800 output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
 801 {
 802   unsigned int i;
 803
 804   fprintf (table, "    { ");
 805
 806   for (i = 0; i < size - 1; i++)
 807     {
 808       if (((i + 1) % 20) != 0)
 809         fprintf (table, "%d, ", modifier[i].value);
 810       else
 811         fprintf (table, "%d,", modifier[i].value);
 812       if (((i + 1) % 20) == 0)
 813         fprintf (table, "\n      ");
 814     }
 815
 816   fprintf (table, "%d },\n", modifier[i].value);
 817 }
 818
 819 static void
 820 process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
 821 {
 822   char *str, *next, *last;
 823   bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
 824
 825   /* Copy the default opcode modifier.  */
 826   memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
 827
 828   if (strcmp (mod, "0"))
 829     {
 830       last = mod + strlen (mod);
 831       for (next = mod; next && next < last; )
 832         {
 833           str = next_field (next, '|', &next, last);
 834           if (str)
 835             set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
 836                           lineno);
 837         }
 838     }
 839   output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
 840 }
 841
 842 static void
 843 output_operand_type (FILE *table, bitfield *types, unsigned int size,
 844                      int macro, const char *indent)
 845 {
 846   unsigned int i;
 847
 848   fprintf (table, "{ { ");
 849
 850   for (i = 0; i < size - 1; i++)
 851     {
 852       if (((i + 1) % 20) != 0)
 853         fprintf (table, "%d, ", types[i].value);
 854       else
 855         fprintf (table, "%d,", types[i].value);
 856       if (((i + 1) % 20) == 0)
 857         {
 858           /* We need \\ for macro.  */
 859           if (macro)
 860             fprintf (table, " \\\n%s", indent);
 861           else
 862             fprintf (table, "\n%s", indent);
 863         }
 864     }
 865
 866   fprintf (table, "%d } }", types[i].value);
 867 }
 868
 869 static void
 870 process_i386_operand_type (FILE *table, char *op, int macro,
 871                            const char *indent, int lineno)
 872 {
 873   char *str, *next, *last;
 874   bitfield types [ARRAY_SIZE (operand_types)];
 875
 876   /* Copy the default operand type.  */
 877   memcpy (types, operand_types, sizeof (types));
 878
 879   if (strcmp (op, "0"))
 880     {
 881       last = op + strlen (op);
 882       for (next = op; next && next < last; )
 883         {
 884           str = next_field (next, '|', &next, last);
 885           if (str)
 886             set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
 887         }
 888     }
 889   output_operand_type (table, types, ARRAY_SIZE (types), macro,
 890                        indent);
 891 }
 892
 893 static void
 894 output_i386_opcode (FILE *table, const char *name, char *str,
 895                     char *last, int lineno)
 896 {
 897   unsigned int i;
 898   char *operands, *base_opcode, *extension_opcode, *opcode_length;
 899   char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
 900
 901   /* Find number of operands.  */
 902   operands = next_field (str, ',', &str, last);
 903
 904   /* Find base_opcode.  */
 905   base_opcode = next_field (str, ',', &str, last);
 906
 907   /* Find extension_opcode.  */
 908   extension_opcode = next_field (str, ',', &str, last);
 909
 910   /* Find opcode_length.  */
 911   opcode_length = next_field (str, ',', &str, last);
 912
 913   /* Find cpu_flags.  */
 914   cpu_flags = next_field (str, ',', &str, last);
 915
 916   /* Find opcode_modifier.  */
 917   opcode_modifier = next_field (str, ',', &str, last);
 918
 919   /* Remove the first {.  */
 920   str = remove_leading_whitespaces (str);
 921   if (*str != '{')
 922     abort ();
 923   str = remove_leading_whitespaces (str + 1);
 924
 925   i = strlen (str);
 926
 927   /* There are at least "X}".  */
 928   if (i < 2)
 929     abort ();
 930
 931   /* Remove trailing white spaces and }. */
 932   do
 933     {
 934       i--;
 935       if (ISSPACE (str[i]) || str[i] == '}')
 936         str[i] = '\0';
 937       else
 938         break;
 939     }
 940   while (i != 0);
 941
 942   last = str + i;
 943
 944   /* Find operand_types.  */
 945   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
 946     {
 947       if (str >= last)
 948         {
 949           operand_types [i] = NULL;
 950           break;
 951         }
 952
 953       operand_types [i] = next_field (str, ',', &str, last);
 954       if (*operand_types[i] == '0')
 955         {
 956           if (i != 0)
 957             operand_types[i] = NULL;
 958           break;
 959         }
 960     }
 961
 962   fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
 963            name, operands, base_opcode, extension_opcode,
 964            opcode_length);
 965
 966   process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
 967
 968   process_i386_opcode_modifier (table, opcode_modifier, lineno);
 969
 970   fprintf (table, "    { ");
 971
 972   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
 973     {
 974       if (operand_types[i] == NULL || *operand_types[i] == '0')
 975         {
 976           if (i == 0)
 977             process_i386_operand_type (table, "0", 0, "\t  ", lineno);
 978           break;
 979         }
 980
 981       if (i != 0)
 982         fprintf (table, ",\n      ");
 983
 984       process_i386_operand_type (table, operand_types[i], 0,
 985                                  "\t  ", lineno);
 986     }
 987   fprintf (table, " } },\n");
 988 }
 989
 990 struct opcode_hash_entry
 991 {
 992   struct opcode_hash_entry *next;
 993   char *name;
 994   char *opcode;
 995   int lineno;
 996 };
 997
 998 /* Calculate the hash value of an opcode hash entry P.  */
 999
1000 static hashval_t
1001 opcode_hash_hash (const void *p)
1002 {
1003   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1004   return htab_hash_string (entry->name);
1005 }
1006
1007 /* Compare a string Q against an opcode hash entry P.  */
1008
1009 static int
1010 opcode_hash_eq (const void *p, const void *q)
1011 {
1012   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1013   const char *name = (const char *) q;
1014   return strcmp (name, entry->name) == 0;
1015 }
1016
1017 static void
1018 process_i386_opcodes (FILE *table)
1019 {
1020   FILE *fp;
1021   char buf[2048];
1022   unsigned int i, j;
1023   char *str, *p, *last, *name;
1024   struct opcode_hash_entry **hash_slot, **entry, *next;
1025   htab_t opcode_hash_table;
1026   struct opcode_hash_entry **opcode_array;
1027   unsigned int opcode_array_size = 1024;
1028   int lineno = 0;
1029
1030   filename = "i386-opc.tbl";
1031   fp = fopen (filename, "r");
1032
1033   if (fp == NULL)
1034     fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
1035           xstrerror (errno));
1036
1037   i = 0;
1038   opcode_array = (struct opcode_hash_entry **)
1039     xmalloc (sizeof (*opcode_array) * opcode_array_size);
1040
1041   opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1042                                          opcode_hash_eq, NULL,
1043                                          xcalloc, free);
1044
1045   fprintf (table, "\n/* i386 opcode table.  */\n\n");
1046   fprintf (table, "const insn_template i386_optab[] =\n{\n");
1047
1048   /* Put everything on opcode array.  */
1049   while (!feof (fp))
1050     {
1051       if (fgets (buf, sizeof (buf), fp) == NULL)
1052         break;
1053
1054       lineno++;
1055
1056       p = remove_leading_whitespaces (buf);
1057
1058       /* Skip comments.  */
1059       str = strstr (p, "//");
1060       if (str != NULL)
1061         str[0] = '\0';
1062
1063       /* Remove trailing white spaces.  */
1064       remove_trailing_whitespaces (p);
1065
1066       switch (p[0])
1067         {
1068         case '#':
1069           /* Ignore comments.  */
1070         case '\0':
1071           continue;
1072           break;
1073         default:
1074           break;
1075         }
1076
1077       last = p + strlen (p);
1078
1079       /* Find name.  */
1080       name = next_field (p, ',', &str, last);
1081
1082       /* Get the slot in hash table.  */
1083       hash_slot = (struct opcode_hash_entry **)
1084         htab_find_slot_with_hash (opcode_hash_table, name,
1085                                   htab_hash_string (name),
1086                                   INSERT);
1087
1088       if (*hash_slot == NULL)
1089         {
1090           /* It is the new one.  Put it on opcode array.  */
1091           if (i >= opcode_array_size)
1092             {
1093               /* Grow the opcode array when needed.  */
1094               opcode_array_size += 1024;
1095               opcode_array = (struct opcode_hash_entry **)
1096                 xrealloc (opcode_array,
1097                           sizeof (*opcode_array) * opcode_array_size);
1098             }
1099
1100           opcode_array[i] = (struct opcode_hash_entry *)
1101             xmalloc (sizeof (struct opcode_hash_entry));
1102           opcode_array[i]->next = NULL;
1103           opcode_array[i]->name = xstrdup (name);
1104           opcode_array[i]->opcode = xstrdup (str);
1105           opcode_array[i]->lineno = lineno;
1106           *hash_slot = opcode_array[i];
1107           i++;
1108         }
1109       else
1110         {
1111           /* Append it to the existing one.  */
1112           entry = hash_slot;
1113           while ((*entry) != NULL)
1114             entry = &(*entry)->next;
1115           *entry = (struct opcode_hash_entry *)
1116             xmalloc (sizeof (struct opcode_hash_entry));
1117           (*entry)->next = NULL;
1118           (*entry)->name = (*hash_slot)->name;
1119           (*entry)->opcode = xstrdup (str);
1120           (*entry)->lineno = lineno;
1121         }
1122     }
1123
1124   /* Process opcode array.  */
1125   for (j = 0; j < i; j++)
1126     {
1127       for (next = opcode_array[j]; next; next = next->next)
1128         {
1129           name = next->name;
1130           str = next->opcode;
1131           lineno = next->lineno;
1132           last = str + strlen (str);
1133           output_i386_opcode (table, name, str, last, lineno);
1134         }
1135     }
1136
1137   fclose (fp);
1138
1139   fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
1140
1141   process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
1142
1143   process_i386_opcode_modifier (table, "0", -1);
1144
1145   fprintf (table, "    { ");
1146   process_i386_operand_type (table, "0", 0, "\t  ", -1);
1147   fprintf (table, " } }\n");
1148
1149   fprintf (table, "};\n");
1150 }
1151
1152 static void
1153 process_i386_registers (FILE *table)
1154 {
1155   FILE *fp;
1156   char buf[2048];
1157   char *str, *p, *last;
1158   char *reg_name, *reg_type, *reg_flags, *reg_num;
1159   char *dw2_32_num, *dw2_64_num;
1160   int lineno = 0;
1161
1162   filename = "i386-reg.tbl";
1163   fp = fopen (filename, "r");
1164   if (fp == NULL)
1165     fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1166           xstrerror (errno));
1167
1168   fprintf (table, "\n/* i386 register table.  */\n\n");
1169   fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
1170
1171   while (!feof (fp))
1172     {
1173       if (fgets (buf, sizeof (buf), fp) == NULL)
1174         break;
1175
1176       lineno++;
1177
1178       p = remove_leading_whitespaces (buf);
1179
1180       /* Skip comments.  */
1181       str = strstr (p, "//");
1182       if (str != NULL)
1183         str[0] = '\0';
1184
1185       /* Remove trailing white spaces.  */
1186       remove_trailing_whitespaces (p);
1187
1188       switch (p[0])
1189         {
1190         case '#':
1191           fprintf (table, "%s\n", p);
1192         case '\0':
1193           continue;
1194           break;
1195         default:
1196           break;
1197         }
1198
1199       last = p + strlen (p);
1200
1201       /* Find reg_name.  */
1202       reg_name = next_field (p, ',', &str, last);
1203
1204       /* Find reg_type.  */
1205       reg_type = next_field (str, ',', &str, last);
1206
1207       /* Find reg_flags.  */
1208       reg_flags = next_field (str, ',', &str, last);
1209
1210       /* Find reg_num.  */
1211       reg_num = next_field (str, ',', &str, last);
1212
1213       fprintf (table, "  { \"%s\",\n    ", reg_name);
1214
1215       process_i386_operand_type (table, reg_type, 0, "\t", lineno);
1216
1217       /* Find 32-bit Dwarf2 register number.  */
1218       dw2_32_num = next_field (str, ',', &str, last);
1219
1220       /* Find 64-bit Dwarf2 register number.  */
1221       dw2_64_num = next_field (str, ',', &str, last);
1222
1223       fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
1224                reg_flags, reg_num, dw2_32_num, dw2_64_num);
1225     }
1226
1227   fclose (fp);
1228
1229   fprintf (table, "};\n");
1230
1231   fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1232 }
1233
1234 static void
1235 process_i386_initializers (void)
1236 {
1237   unsigned int i;
1238   FILE *fp = fopen ("i386-init.h", "w");
1239   char *init;
1240
1241   if (fp == NULL)
1242     fail (_("can't create i386-init.h, errno = %s\n"),
1243           xstrerror (errno));
1244
1245   process_copyright (fp);
1246
1247   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1248     {
1249       fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1250       init = xstrdup (cpu_flag_init[i].init);
1251       process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
1252       free (init);
1253     }
1254
1255   for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1256     {
1257       fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
1258       init = xstrdup (operand_type_init[i].init);
1259       process_i386_operand_type (fp, init, 1, "      ", -1);
1260       free (init);
1261     }
1262   fprintf (fp, "\n");
1263
1264   fclose (fp);
1265 }
1266
1267 /* Program options.  */
1268 #define OPTION_SRCDIR   200
1269
1270 struct option long_options[] =
1271 {
1272   {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
1273   {"debug",   no_argument,       NULL, 'd'},
1274   {"version", no_argument,       NULL, 'V'},
1275   {"help",    no_argument,       NULL, 'h'},
1276   {0,         no_argument,       NULL, 0}
1277 };
1278
1279 static void
1280 print_version (void)
1281 {
1282   printf ("%s: version 1.0\n", program_name);
1283   xexit (0);
1284 }
1285
1286 static void
1287 usage (FILE * stream, int status)
1288 {
1289   fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1290            program_name);
1291   xexit (status);
1292 }
1293
1294 int
1295 main (int argc, char **argv)
1296 {
1297   extern int chdir (char *);
1298   char *srcdir = NULL;
1299   int c;
1300   FILE *table;
1301
1302   program_name = *argv;
1303   xmalloc_set_program_name (program_name);
1304
1305   while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1306     switch (c)
1307       {
1308       case OPTION_SRCDIR:
1309         srcdir = optarg;
1310         break;
1311       case 'V':
1312       case 'v':
1313         print_version ();
1314         break;
1315       case 'd':
1316         debug = 1;
1317         break;
1318       case 'h':
1319       case '?':
1320         usage (stderr, 0);
1321       default:
1322       case 0:
1323         break;
1324       }
1325
1326   if (optind != argc)
1327     usage (stdout, 1);
1328
1329   if (srcdir != NULL)
1330     if (chdir (srcdir) != 0)
1331       fail (_("unable to change directory to \"%s\", errno = %s\n"),
1332             srcdir, xstrerror (errno));
1333
1334   /* Check the unused bitfield in i386_cpu_flags.  */
1335 #ifndef CpuUnused
1336   c = CpuNumOfBits - CpuMax - 1;
1337   if (c)
1338     fail (_("%d unused bits in i386_cpu_flags.\n"), c);
1339 #endif
1340
1341   /* Check the unused bitfield in i386_operand_type.  */
1342 #ifndef OTUnused
1343   c = OTNumOfBits - OTMax - 1;
1344   if (c)
1345     fail (_("%d unused bits in i386_operand_type.\n"), c);
1346 #endif
1347
1348   qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1349          compare);
1350
1351   qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1352          sizeof (opcode_modifiers [0]), compare);
1353
1354   qsort (operand_types, ARRAY_SIZE (operand_types),
1355          sizeof (operand_types [0]), compare);
1356
1357   table = fopen ("i386-tbl.h", "w");
1358   if (table == NULL)
1359     fail (_("can't create i386-tbl.h, errno = %s\n"),
1360           xstrerror (errno));
1361
1362   process_copyright (table);
1363
1364   process_i386_opcodes (table);
1365   process_i386_registers (table);
1366   process_i386_initializers ();
1367
1368   fclose (table);
1369
1370   exit (0);
1371 }