opcodes/i386-gen.c

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