opcodes/i386-gen.c

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