opcodes/i386-gen.c

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