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|Cpu387|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_XOP_FLAGS|CpuABM|CpuLWP|CpuSVME|CpuAES|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_AVX2_FLAGS|CpuSSE4A|CpuABM|CpuSVME|CpuAES|CpuPCLMUL|CpuLZCNT|CpuPRFCHW|CpuFMA|CpuBMI|CpuF16C|CpuXsaveopt|CpuFSGSBase|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_AVX_FLAGS|CpuBMI|CpuF16C|CpuAES|CpuPCLMUL|CpuMovbe|CpuXsaveopt|CpuPRFCHW" },
 104   { "CPU_8087_FLAGS",
 105     "Cpu8087" },
 106   { "CPU_287_FLAGS",
 107     "Cpu287" },
 108   { "CPU_387_FLAGS",
 109     "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     "CpuMMX" },
 120   { "CPU_SSE_FLAGS",
 121     "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     "CPU_XSAVE_FLAGS|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|CPU_XSAVE_FLAGS|CpuAVX" },
 196   { "CPU_AVX2_FLAGS",
 197     "CPU_AVX_FLAGS|CpuAVX2" },
 198   { "CPU_AVX512F_FLAGS",
 199     "CPU_AVX2_FLAGS|CpuVREX|CpuAVX512F" },
 200   { "CPU_AVX512CD_FLAGS",
 201     "CPU_AVX512F_FLAGS|CpuAVX512CD" },
 202   { "CPU_AVX512ER_FLAGS",
 203     "CPU_AVX512F_FLAGS|CpuAVX512ER" },
 204   { "CPU_AVX512PF_FLAGS",
 205     "CPU_AVX512F_FLAGS|CpuAVX512PF" },
 206   { "CPU_AVX512DQ_FLAGS",
 207     "CPU_AVX512F_FLAGS|CpuAVX512DQ" },
 208   { "CPU_AVX512BW_FLAGS",
 209     "CPU_AVX512F_FLAGS|CpuAVX512BW" },
 210   { "CPU_AVX512VL_FLAGS",
 211     "CPU_AVX512F_FLAGS|CpuAVX512VL" },
 212   { "CPU_AVX512IFMA_FLAGS",
 213     "CPU_AVX512F_FLAGS|CpuAVX512IFMA" },
 214   { "CPU_AVX512VBMI_FLAGS",
 215     "CPU_AVX512F_FLAGS|CpuAVX512VBMI" },
 216   { "CPU_AVX512_4FMAPS_FLAGS",
 217     "CPU_AVX512F_FLAGS|CpuAVX512_4FMAPS" },
 218   { "CPU_AVX512_4VNNIW_FLAGS",
 219     "CPU_AVX512F_FLAGS|CpuAVX512_4VNNIW" },
 220   { "CPU_AVX512_VPOPCNTDQ_FLAGS",
 221     "CPU_AVX512F_FLAGS|CpuAVX512_VPOPCNTDQ" },
 222   { "CPU_AVX512_VBMI2_FLAGS",
 223     "CPU_AVX512F_FLAGS|CpuAVX512_VBMI2" },
 224   { "CPU_AVX512_VNNI_FLAGS",
 225     "CPU_AVX512F_FLAGS|CpuAVX512_VNNI" },
 226   { "CPU_AVX512_BITALG_FLAGS",
 227     "CPU_AVX512F_FLAGS|CpuAVX512_BITALG" },
 228   { "CPU_L1OM_FLAGS",
 229     "unknown" },
 230   { "CPU_K1OM_FLAGS",
 231     "unknown" },
 232   { "CPU_IAMCU_FLAGS",
 233     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586" },
 234   { "CPU_ADX_FLAGS",
 235     "CpuADX" },
 236   { "CPU_RDSEED_FLAGS",
 237     "CpuRdSeed" },
 238   { "CPU_PRFCHW_FLAGS",
 239     "CpuPRFCHW" },
 240   { "CPU_SMAP_FLAGS",
 241     "CpuSMAP" },
 242   { "CPU_MPX_FLAGS",
 243     "CPU_XSAVE_FLAGS|CpuMPX" },
 244   { "CPU_SHA_FLAGS",
 245     "CPU_SSE2_FLAGS|CpuSHA" },
 246   { "CPU_CLFLUSHOPT_FLAGS",
 247     "CpuClflushOpt" },
 248   { "CPU_XSAVES_FLAGS",
 249     "CPU_XSAVE_FLAGS|CpuXSAVES" },
 250   { "CPU_XSAVEC_FLAGS",
 251     "CPU_XSAVE_FLAGS|CpuXSAVEC" },
 252   { "CPU_PREFETCHWT1_FLAGS",
 253     "CpuPREFETCHWT1" },
 254   { "CPU_SE1_FLAGS",
 255     "CpuSE1" },
 256   { "CPU_CLWB_FLAGS",
 257     "CpuCLWB" },
 258   { "CPU_CLZERO_FLAGS",
 259     "CpuCLZERO" },
 260   { "CPU_MWAITX_FLAGS",
 261     "CpuMWAITX" },
 262   { "CPU_OSPKE_FLAGS",
 263     "CPU_XSAVE_FLAGS|CpuOSPKE" },
 264   { "CPU_RDPID_FLAGS",
 265     "CpuRDPID" },
 266   { "CPU_PTWRITE_FLAGS",
 267     "CpuPTWRITE" },
 268   { "CPU_IBT_FLAGS",
 269     "CpuIBT" },
 270   { "CPU_SHSTK_FLAGS",
 271     "CpuSHSTK" },
 272   { "CPU_GFNI_FLAGS",
 273     "CpuGFNI" },
 274   { "CPU_VAES_FLAGS",
 275     "CpuVAES" },
 276   { "CPU_VPCLMULQDQ_FLAGS",
 277     "CpuVPCLMULQDQ" },
 278   { "CPU_WBNOINVD_FLAGS",
 279     "CpuWBNOINVD" },
 280   { "CPU_PCONFIG_FLAGS",
 281     "CpuPCONFIG" },
 282   { "CPU_WAITPKG_FLAGS",
 283     "CpuWAITPKG" },
 284   { "CPU_CLDEMOTE_FLAGS",
 285     "CpuCLDEMOTE" },
 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|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 (CpuWAITPKG),
 579   BITFIELD (CpuCLDEMOTE),
 580 #ifdef CpuUnused
 581   BITFIELD (CpuUnused),
 582 #endif
 583 };
 584
 585 static bitfield opcode_modifiers[] =
 586 {
 587   BITFIELD (D),
 588   BITFIELD (W),
 589   BITFIELD (Load),
 590   BITFIELD (Modrm),
 591   BITFIELD (ShortForm),
 592   BITFIELD (Jump),
 593   BITFIELD (JumpDword),
 594   BITFIELD (JumpByte),
 595   BITFIELD (JumpInterSegment),
 596   BITFIELD (FloatMF),
 597   BITFIELD (FloatR),
 598   BITFIELD (Size16),
 599   BITFIELD (Size32),
 600   BITFIELD (Size64),
 601   BITFIELD (CheckRegSize),
 602   BITFIELD (IgnoreSize),
 603   BITFIELD (DefaultSize),
 604   BITFIELD (No_bSuf),
 605   BITFIELD (No_wSuf),
 606   BITFIELD (No_lSuf),
 607   BITFIELD (No_sSuf),
 608   BITFIELD (No_qSuf),
 609   BITFIELD (No_ldSuf),
 610   BITFIELD (FWait),
 611   BITFIELD (IsString),
 612   BITFIELD (BNDPrefixOk),
 613   BITFIELD (NoTrackPrefixOk),
 614   BITFIELD (IsLockable),
 615   BITFIELD (RegKludge),
 616   BITFIELD (Implicit1stXmm0),
 617   BITFIELD (RepPrefixOk),
 618   BITFIELD (HLEPrefixOk),
 619   BITFIELD (ToDword),
 620   BITFIELD (ToQword),
 621   BITFIELD (AddrPrefixOpReg),
 622   BITFIELD (IsPrefix),
 623   BITFIELD (ImmExt),
 624   BITFIELD (NoRex64),
 625   BITFIELD (Rex64),
 626   BITFIELD (Ugh),
 627   BITFIELD (Vex),
 628   BITFIELD (VexVVVV),
 629   BITFIELD (VexW),
 630   BITFIELD (VexOpcode),
 631   BITFIELD (VexSources),
 632   BITFIELD (VecSIB),
 633   BITFIELD (SSE2AVX),
 634   BITFIELD (NoAVX),
 635   BITFIELD (EVex),
 636   BITFIELD (Masking),
 637   BITFIELD (Broadcast),
 638   BITFIELD (StaticRounding),
 639   BITFIELD (SAE),
 640   BITFIELD (Disp8MemShift),
 641   BITFIELD (NoDefMask),
 642   BITFIELD (ImplicitQuadGroup),
 643   BITFIELD (Optimize),
 644   BITFIELD (ATTMnemonic),
 645   BITFIELD (ATTSyntax),
 646   BITFIELD (IntelSyntax),
 647   BITFIELD (AMD64),
 648   BITFIELD (Intel64),
 649 };
 650
 651 static bitfield operand_types[] =
 652 {
 653   BITFIELD (Reg),
 654   BITFIELD (RegMMX),
 655   BITFIELD (RegSIMD),
 656   BITFIELD (RegMask),
 657   BITFIELD (Imm1),
 658   BITFIELD (Imm8),
 659   BITFIELD (Imm8S),
 660   BITFIELD (Imm16),
 661   BITFIELD (Imm32),
 662   BITFIELD (Imm32S),
 663   BITFIELD (Imm64),
 664   BITFIELD (BaseIndex),
 665   BITFIELD (Disp8),
 666   BITFIELD (Disp16),
 667   BITFIELD (Disp32),
 668   BITFIELD (Disp32S),
 669   BITFIELD (Disp64),
 670   BITFIELD (InOutPortReg),
 671   BITFIELD (ShiftCount),
 672   BITFIELD (Control),
 673   BITFIELD (Debug),
 674   BITFIELD (Test),
 675   BITFIELD (SReg2),
 676   BITFIELD (SReg3),
 677   BITFIELD (Acc),
 678   BITFIELD (JumpAbsolute),
 679   BITFIELD (EsSeg),
 680   BITFIELD (RegMem),
 681   BITFIELD (Mem),
 682   BITFIELD (Byte),
 683   BITFIELD (Word),
 684   BITFIELD (Dword),
 685   BITFIELD (Fword),
 686   BITFIELD (Qword),
 687   BITFIELD (Tbyte),
 688   BITFIELD (Xmmword),
 689   BITFIELD (Ymmword),
 690   BITFIELD (Zmmword),
 691   BITFIELD (Unspecified),
 692   BITFIELD (Anysize),
 693   BITFIELD (Vec_Imm4),
 694   BITFIELD (RegBND),
 695 #ifdef OTUnused
 696   BITFIELD (OTUnused),
 697 #endif
 698 };
 699
 700 static const char *filename;
 701 static i386_cpu_flags active_cpu_flags;
 702 static int active_isstring;
 703
 704 static int
 705 compare (const void *x, const void *y)
 706 {
 707   const bitfield *xp = (const bitfield *) x;
 708   const bitfield *yp = (const bitfield *) y;
 709   return xp->position - yp->position;
 710 }
 711
 712 static void
 713 fail (const char *message, ...)
 714 {
 715   va_list args;
 716
 717   va_start (args, message);
 718   fprintf (stderr, _("%s: error: "), program_name);
 719   vfprintf (stderr, message, args);
 720   va_end (args);
 721   xexit (1);
 722 }
 723
 724 static void
 725 process_copyright (FILE *fp)
 726 {
 727   fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
 728 /* Copyright (C) 2007-2018 Free Software Foundation, Inc.\n\
 729 \n\
 730    This file is part of the GNU opcodes library.\n\
 731 \n\
 732    This library is free software; you can redistribute it and/or modify\n\
 733    it under the terms of the GNU General Public License as published by\n\
 734    the Free Software Foundation; either version 3, or (at your option)\n\
 735    any later version.\n\
 736 \n\
 737    It is distributed in the hope that it will be useful, but WITHOUT\n\
 738    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
 739    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
 740    License for more details.\n\
 741 \n\
 742    You should have received a copy of the GNU General Public License\n\
 743    along with this program; if not, write to the Free Software\n\
 744    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
 745    MA 02110-1301, USA.  */\n");
 746 }
 747
 748 /* Remove leading white spaces.  */
 749
 750 static char *
 751 remove_leading_whitespaces (char *str)
 752 {
 753   while (ISSPACE (*str))
 754     str++;
 755   return str;
 756 }
 757
 758 /* Remove trailing white spaces.  */
 759
 760 static void
 761 remove_trailing_whitespaces (char *str)
 762 {
 763   size_t last = strlen (str);
 764
 765   if (last == 0)
 766     return;
 767
 768   do
 769     {
 770       last--;
 771       if (ISSPACE (str [last]))
 772         str[last] = '\0';
 773       else
 774         break;
 775     }
 776   while (last != 0);
 777 }
 778
 779 /* Find next field separated by SEP and terminate it. Return a
 780    pointer to the one after it.  */
 781
 782 static char *
 783 next_field (char *str, char sep, char **next, char *last)
 784 {
 785   char *p;
 786
 787   p = remove_leading_whitespaces (str);
 788   for (str = p; *str != sep && *str != '\0'; str++);
 789
 790   *str = '\0';
 791   remove_trailing_whitespaces (p);
 792
 793   *next = str + 1;
 794
 795   if (p >= last)
 796     abort ();
 797
 798   return p;
 799 }
 800
 801 static void set_bitfield (char *, bitfield *, int, unsigned int, int);
 802
 803 static int
 804 set_bitfield_from_shorthand (char *f, bitfield *array, unsigned int size,
 805                              int lineno)
 806 {
 807   char *str, *next, *last;
 808   unsigned int i;
 809
 810   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
 811     if (strcmp (cpu_flag_init[i].name, f) == 0)
 812       {
 813         /* Turn on selective bits.  */
 814         char *init = xstrdup (cpu_flag_init[i].init);
 815         last = init + strlen (init);
 816         for (next = init; next && next < last; )
 817           {
 818             str = next_field (next, '|', &next, last);
 819             if (str)
 820               set_bitfield (str, array, 1, size, lineno);
 821           }
 822         free (init);
 823         return 0;
 824       }
 825
 826   for (i = 0; i < ARRAY_SIZE (operand_type_shorthands); i++)
 827     if (strcmp (operand_type_shorthands[i].name, f) == 0)
 828       {
 829         /* Turn on selective bits.  */
 830         char *init = xstrdup (operand_type_shorthands[i].init);
 831         last = init + strlen (init);
 832         for (next = init; next && next < last; )
 833           {
 834             str = next_field (next, '|', &next, last);
 835             if (str)
 836               set_bitfield (str, array, 1, size, lineno);
 837           }
 838         free (init);
 839         return 0;
 840       }
 841
 842   return -1;
 843 }
 844
 845 static void
 846 set_bitfield (char *f, bitfield *array, int value,
 847               unsigned int size, int lineno)
 848 {
 849   unsigned int i;
 850
 851   if (strcmp (f, "CpuFP") == 0)
 852     {
 853       set_bitfield("Cpu387", array, value, size, lineno);
 854       set_bitfield("Cpu287", array, value, size, lineno);
 855       f = "Cpu8087";
 856     }
 857   else if (strcmp (f, "Mmword") == 0)
 858     f= "Qword";
 859   else if (strcmp (f, "Oword") == 0)
 860     f= "Xmmword";
 861
 862   for (i = 0; i < size; i++)
 863     if (strcasecmp (array[i].name, f) == 0)
 864       {
 865         array[i].value = value;
 866         return;
 867       }
 868
 869   if (value)
 870     {
 871       const char *v = strchr (f, '=');
 872
 873       if (v)
 874         {
 875           size_t n = v - f;
 876           char *end;
 877
 878           for (i = 0; i < size; i++)
 879             if (strncasecmp (array[i].name, f, n) == 0)
 880               {
 881                 value = strtol (v + 1, &end, 0);
 882                 if (*end == '\0')
 883                   {
 884                     array[i].value = value;
 885                     return;
 886                   }
 887                 break;
 888               }
 889         }
 890     }
 891
 892   /* Handle shorthands.  */
 893   if (value == 1 && !set_bitfield_from_shorthand (f, array, size, lineno))
 894     return;
 895
 896   if (lineno != -1)
 897     fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
 898   else
 899     fail (_("unknown bitfield: %s\n"), f);
 900 }
 901
 902 static void
 903 output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
 904                   int macro, const char *comma, const char *indent)
 905 {
 906   unsigned int i;
 907
 908   memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
 909
 910   fprintf (table, "%s{ { ", indent);
 911
 912   for (i = 0; i < size - 1; i++)
 913     {
 914       if (((i + 1) % 20) != 0)
 915         fprintf (table, "%d, ", flags[i].value);
 916       else
 917         fprintf (table, "%d,", flags[i].value);
 918       if (((i + 1) % 20) == 0)
 919         {
 920           /* We need \\ for macro.  */
 921           if (macro)
 922             fprintf (table, " \\\n    %s", indent);
 923           else
 924             fprintf (table, "\n    %s", indent);
 925         }
 926       if (flags[i].value)
 927         active_cpu_flags.array[i / 32] |= 1U << (i % 32);
 928     }
 929
 930   fprintf (table, "%d } }%s\n", flags[i].value, comma);
 931 }
 932
 933 static void
 934 process_i386_cpu_flag (FILE *table, char *flag, int macro,
 935                        const char *comma, const char *indent,
 936                        int lineno)
 937 {
 938   char *str, *next, *last;
 939   unsigned int i;
 940   bitfield flags [ARRAY_SIZE (cpu_flags)];
 941
 942   /* Copy the default cpu flags.  */
 943   memcpy (flags, cpu_flags, sizeof (cpu_flags));
 944
 945   if (strcasecmp (flag, "unknown") == 0)
 946     {
 947       /* We turn on everything except for cpu64 in case of
 948          CPU_UNKNOWN_FLAGS.  */
 949       for (i = 0; i < ARRAY_SIZE (flags); i++)
 950         if (flags[i].position != Cpu64)
 951           flags[i].value = 1;
 952     }
 953   else if (flag[0] == '~')
 954     {
 955       last = flag + strlen (flag);
 956
 957       if (flag[1] == '(')
 958         {
 959           last -= 1;
 960           next = flag + 2;
 961           if (*last != ')')
 962             fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
 963                   lineno, flag);
 964           *last = '\0';
 965         }
 966       else
 967         next = flag + 1;
 968
 969       /* First we turn on everything except for cpu64.  */
 970       for (i = 0; i < ARRAY_SIZE (flags); i++)
 971         if (flags[i].position != Cpu64)
 972           flags[i].value = 1;
 973
 974       /* Turn off selective bits.  */
 975       for (; next && next < last; )
 976         {
 977           str = next_field (next, '|', &next, last);
 978           if (str)
 979             set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
 980         }
 981     }
 982   else if (strcmp (flag, "0"))
 983     {
 984       /* Turn on selective bits.  */
 985       last = flag + strlen (flag);
 986       for (next = flag; next && next < last; )
 987         {
 988           str = next_field (next, '|', &next, last);
 989           if (str)
 990             set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
 991         }
 992     }
 993
 994   output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
 995                     comma, indent);
 996 }
 997
 998 static void
 999 output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1000 {
1001   unsigned int i;
1002
1003   fprintf (table, "    { ");
1004
1005   for (i = 0; i < size - 1; i++)
1006     {
1007       if (((i + 1) % 20) != 0)
1008         fprintf (table, "%d, ", modifier[i].value);
1009       else
1010         fprintf (table, "%d,", modifier[i].value);
1011       if (((i + 1) % 20) == 0)
1012         fprintf (table, "\n      ");
1013     }
1014
1015   fprintf (table, "%d },\n", modifier[i].value);
1016 }
1017
1018 static void
1019 process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
1020 {
1021   char *str, *next, *last;
1022   bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1023
1024   active_isstring = 0;
1025
1026   /* Copy the default opcode modifier.  */
1027   memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1028
1029   if (strcmp (mod, "0"))
1030     {
1031       last = mod + strlen (mod);
1032       for (next = mod; next && next < last; )
1033         {
1034           str = next_field (next, '|', &next, last);
1035           if (str)
1036             {
1037               set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
1038                           lineno);
1039               if (strcasecmp(str, "IsString") == 0)
1040                 active_isstring = 1;
1041             }
1042         }
1043     }
1044   output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1045 }
1046
1047 enum stage {
1048   stage_macros,
1049   stage_opcodes,
1050   stage_registers,
1051 };
1052
1053 static void
1054 output_operand_type (FILE *table, bitfield *types, unsigned int size,
1055                      enum stage stage, const char *indent)
1056 {
1057   unsigned int i;
1058
1059   fprintf (table, "{ { ");
1060
1061   for (i = 0; i < size - 1; i++)
1062     {
1063       if (((i + 1) % 20) != 0)
1064         fprintf (table, "%d, ", types[i].value);
1065       else
1066         fprintf (table, "%d,", types[i].value);
1067       if (((i + 1) % 20) == 0)
1068         {
1069           /* We need \\ for macro.  */
1070           if (stage == stage_macros)
1071             fprintf (table, " \\\n%s", indent);
1072           else
1073             fprintf (table, "\n%s", indent);
1074         }
1075     }
1076
1077   fprintf (table, "%d } }", types[i].value);
1078 }
1079
1080 static void
1081 process_i386_operand_type (FILE *table, char *op, enum stage stage,
1082                            const char *indent, int lineno)
1083 {
1084   char *str, *next, *last;
1085   bitfield types [ARRAY_SIZE (operand_types)];
1086
1087   /* Copy the default operand type.  */
1088   memcpy (types, operand_types, sizeof (types));
1089
1090   if (strcmp (op, "0"))
1091     {
1092       int baseindex = 0;
1093
1094       last = op + strlen (op);
1095       for (next = op; next && next < last; )
1096         {
1097           str = next_field (next, '|', &next, last);
1098           if (str)
1099             {
1100               set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1101               if (strcasecmp(str, "BaseIndex") == 0)
1102                 baseindex = 1;
1103             }
1104         }
1105
1106       if (stage == stage_opcodes && baseindex && !active_isstring)
1107         {
1108           set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1109           if (!active_cpu_flags.bitfield.cpu64
1110               && !active_cpu_flags.bitfield.cpumpx)
1111             set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1112           set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1113           if (!active_cpu_flags.bitfield.cpuno64)
1114             set_bitfield("Disp32S", types, 1, ARRAY_SIZE (types), lineno);
1115         }
1116     }
1117   output_operand_type (table, types, ARRAY_SIZE (types), stage,
1118                        indent);
1119 }
1120
1121 static void
1122 output_i386_opcode (FILE *table, const char *name, char *str,
1123                     char *last, int lineno)
1124 {
1125   unsigned int i;
1126   char *operands, *base_opcode, *extension_opcode, *opcode_length;
1127   char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1128
1129   /* Find number of operands.  */
1130   operands = next_field (str, ',', &str, last);
1131
1132   /* Find base_opcode.  */
1133   base_opcode = next_field (str, ',', &str, last);
1134
1135   /* Find extension_opcode.  */
1136   extension_opcode = next_field (str, ',', &str, last);
1137
1138   /* Find opcode_length.  */
1139   opcode_length = next_field (str, ',', &str, last);
1140
1141   /* Find cpu_flags.  */
1142   cpu_flags = next_field (str, ',', &str, last);
1143
1144   /* Find opcode_modifier.  */
1145   opcode_modifier = next_field (str, ',', &str, last);
1146
1147   /* Remove the first {.  */
1148   str = remove_leading_whitespaces (str);
1149   if (*str != '{')
1150     abort ();
1151   str = remove_leading_whitespaces (str + 1);
1152
1153   i = strlen (str);
1154
1155   /* There are at least "X}".  */
1156   if (i < 2)
1157     abort ();
1158
1159   /* Remove trailing white spaces and }. */
1160   do
1161     {
1162       i--;
1163       if (ISSPACE (str[i]) || str[i] == '}')
1164         str[i] = '\0';
1165       else
1166         break;
1167     }
1168   while (i != 0);
1169
1170   last = str + i;
1171
1172   /* Find operand_types.  */
1173   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1174     {
1175       if (str >= last)
1176         {
1177           operand_types [i] = NULL;
1178           break;
1179         }
1180
1181       operand_types [i] = next_field (str, ',', &str, last);
1182       if (*operand_types[i] == '0')
1183         {
1184           if (i != 0)
1185             operand_types[i] = NULL;
1186           break;
1187         }
1188     }
1189
1190   fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
1191            name, operands, base_opcode, extension_opcode,
1192            opcode_length);
1193
1194   process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
1195
1196   process_i386_opcode_modifier (table, opcode_modifier, lineno);
1197
1198   fprintf (table, "    { ");
1199
1200   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1201     {
1202       if (operand_types[i] == NULL || *operand_types[i] == '0')
1203         {
1204           if (i == 0)
1205             process_i386_operand_type (table, "0", stage_opcodes, "\t  ",
1206                                        lineno);
1207           break;
1208         }
1209
1210       if (i != 0)
1211         fprintf (table, ",\n      ");
1212
1213       process_i386_operand_type (table, operand_types[i], stage_opcodes,
1214                                  "\t  ", lineno);
1215     }
1216   fprintf (table, " } },\n");
1217 }
1218
1219 struct opcode_hash_entry
1220 {
1221   struct opcode_hash_entry *next;
1222   char *name;
1223   char *opcode;
1224   int lineno;
1225 };
1226
1227 /* Calculate the hash value of an opcode hash entry P.  */
1228
1229 static hashval_t
1230 opcode_hash_hash (const void *p)
1231 {
1232   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1233   return htab_hash_string (entry->name);
1234 }
1235
1236 /* Compare a string Q against an opcode hash entry P.  */
1237
1238 static int
1239 opcode_hash_eq (const void *p, const void *q)
1240 {
1241   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1242   const char *name = (const char *) q;
1243   return strcmp (name, entry->name) == 0;
1244 }
1245
1246 static void
1247 process_i386_opcodes (FILE *table)
1248 {
1249   FILE *fp;
1250   char buf[2048];
1251   unsigned int i, j;
1252   char *str, *p, *last, *name;
1253   struct opcode_hash_entry **hash_slot, **entry, *next;
1254   htab_t opcode_hash_table;
1255   struct opcode_hash_entry **opcode_array;
1256   unsigned int opcode_array_size = 1024;
1257   int lineno = 0;
1258
1259   filename = "i386-opc.tbl";
1260   fp = fopen (filename, "r");
1261
1262   if (fp == NULL)
1263     fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
1264           xstrerror (errno));
1265
1266   i = 0;
1267   opcode_array = (struct opcode_hash_entry **)
1268     xmalloc (sizeof (*opcode_array) * opcode_array_size);
1269
1270   opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1271                                          opcode_hash_eq, NULL,
1272                                          xcalloc, free);
1273
1274   fprintf (table, "\n/* i386 opcode table.  */\n\n");
1275   fprintf (table, "const insn_template i386_optab[] =\n{\n");
1276
1277   /* Put everything on opcode array.  */
1278   while (!feof (fp))
1279     {
1280       if (fgets (buf, sizeof (buf), fp) == NULL)
1281         break;
1282
1283       lineno++;
1284
1285       p = remove_leading_whitespaces (buf);
1286
1287       /* Skip comments.  */
1288       str = strstr (p, "//");
1289       if (str != NULL)
1290         str[0] = '\0';
1291
1292       /* Remove trailing white spaces.  */
1293       remove_trailing_whitespaces (p);
1294
1295       switch (p[0])
1296         {
1297         case '#':
1298           /* Ignore comments.  */
1299         case '\0':
1300           continue;
1301           break;
1302         default:
1303           break;
1304         }
1305
1306       last = p + strlen (p);
1307
1308       /* Find name.  */
1309       name = next_field (p, ',', &str, last);
1310
1311       /* Get the slot in hash table.  */
1312       hash_slot = (struct opcode_hash_entry **)
1313         htab_find_slot_with_hash (opcode_hash_table, name,
1314                                   htab_hash_string (name),
1315                                   INSERT);
1316
1317       if (*hash_slot == NULL)
1318         {
1319           /* It is the new one.  Put it on opcode array.  */
1320           if (i >= opcode_array_size)
1321             {
1322               /* Grow the opcode array when needed.  */
1323               opcode_array_size += 1024;
1324               opcode_array = (struct opcode_hash_entry **)
1325                 xrealloc (opcode_array,
1326                           sizeof (*opcode_array) * opcode_array_size);
1327             }
1328
1329           opcode_array[i] = (struct opcode_hash_entry *)
1330             xmalloc (sizeof (struct opcode_hash_entry));
1331           opcode_array[i]->next = NULL;
1332           opcode_array[i]->name = xstrdup (name);
1333           opcode_array[i]->opcode = xstrdup (str);
1334           opcode_array[i]->lineno = lineno;
1335           *hash_slot = opcode_array[i];
1336           i++;
1337         }
1338       else
1339         {
1340           /* Append it to the existing one.  */
1341           entry = hash_slot;
1342           while ((*entry) != NULL)
1343             entry = &(*entry)->next;
1344           *entry = (struct opcode_hash_entry *)
1345             xmalloc (sizeof (struct opcode_hash_entry));
1346           (*entry)->next = NULL;
1347           (*entry)->name = (*hash_slot)->name;
1348           (*entry)->opcode = xstrdup (str);
1349           (*entry)->lineno = lineno;
1350         }
1351     }
1352
1353   /* Process opcode array.  */
1354   for (j = 0; j < i; j++)
1355     {
1356       for (next = opcode_array[j]; next; next = next->next)
1357         {
1358           name = next->name;
1359           str = next->opcode;
1360           lineno = next->lineno;
1361           last = str + strlen (str);
1362           output_i386_opcode (table, name, str, last, lineno);
1363         }
1364     }
1365
1366   fclose (fp);
1367
1368   fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
1369
1370   process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
1371
1372   process_i386_opcode_modifier (table, "0", -1);
1373
1374   fprintf (table, "    { ");
1375   process_i386_operand_type (table, "0", stage_opcodes, "\t  ", -1);
1376   fprintf (table, " } }\n");
1377
1378   fprintf (table, "};\n");
1379 }
1380
1381 static void
1382 process_i386_registers (FILE *table)
1383 {
1384   FILE *fp;
1385   char buf[2048];
1386   char *str, *p, *last;
1387   char *reg_name, *reg_type, *reg_flags, *reg_num;
1388   char *dw2_32_num, *dw2_64_num;
1389   int lineno = 0;
1390
1391   filename = "i386-reg.tbl";
1392   fp = fopen (filename, "r");
1393   if (fp == NULL)
1394     fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1395           xstrerror (errno));
1396
1397   fprintf (table, "\n/* i386 register table.  */\n\n");
1398   fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
1399
1400   while (!feof (fp))
1401     {
1402       if (fgets (buf, sizeof (buf), fp) == NULL)
1403         break;
1404
1405       lineno++;
1406
1407       p = remove_leading_whitespaces (buf);
1408
1409       /* Skip comments.  */
1410       str = strstr (p, "//");
1411       if (str != NULL)
1412         str[0] = '\0';
1413
1414       /* Remove trailing white spaces.  */
1415       remove_trailing_whitespaces (p);
1416
1417       switch (p[0])
1418         {
1419         case '#':
1420           fprintf (table, "%s\n", p);
1421         case '\0':
1422           continue;
1423           break;
1424         default:
1425           break;
1426         }
1427
1428       last = p + strlen (p);
1429
1430       /* Find reg_name.  */
1431       reg_name = next_field (p, ',', &str, last);
1432
1433       /* Find reg_type.  */
1434       reg_type = next_field (str, ',', &str, last);
1435
1436       /* Find reg_flags.  */
1437       reg_flags = next_field (str, ',', &str, last);
1438
1439       /* Find reg_num.  */
1440       reg_num = next_field (str, ',', &str, last);
1441
1442       fprintf (table, "  { \"%s\",\n    ", reg_name);
1443
1444       process_i386_operand_type (table, reg_type, stage_registers, "\t",
1445                                  lineno);
1446
1447       /* Find 32-bit Dwarf2 register number.  */
1448       dw2_32_num = next_field (str, ',', &str, last);
1449
1450       /* Find 64-bit Dwarf2 register number.  */
1451       dw2_64_num = next_field (str, ',', &str, last);
1452
1453       fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
1454                reg_flags, reg_num, dw2_32_num, dw2_64_num);
1455     }
1456
1457   fclose (fp);
1458
1459   fprintf (table, "};\n");
1460
1461   fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1462 }
1463
1464 static void
1465 process_i386_initializers (void)
1466 {
1467   unsigned int i;
1468   FILE *fp = fopen ("i386-init.h", "w");
1469   char *init;
1470
1471   if (fp == NULL)
1472     fail (_("can't create i386-init.h, errno = %s\n"),
1473           xstrerror (errno));
1474
1475   process_copyright (fp);
1476
1477   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1478     {
1479       fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1480       init = xstrdup (cpu_flag_init[i].init);
1481       process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
1482       free (init);
1483     }
1484
1485   for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1486     {
1487       fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
1488       init = xstrdup (operand_type_init[i].init);
1489       process_i386_operand_type (fp, init, stage_macros, "      ", -1);
1490       free (init);
1491     }
1492   fprintf (fp, "\n");
1493
1494   fclose (fp);
1495 }
1496
1497 /* Program options.  */
1498 #define OPTION_SRCDIR   200
1499
1500 struct option long_options[] =
1501 {
1502   {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
1503   {"debug",   no_argument,       NULL, 'd'},
1504   {"version", no_argument,       NULL, 'V'},
1505   {"help",    no_argument,       NULL, 'h'},
1506   {0,         no_argument,       NULL, 0}
1507 };
1508
1509 static void
1510 print_version (void)
1511 {
1512   printf ("%s: version 1.0\n", program_name);
1513   xexit (0);
1514 }
1515
1516 static void
1517 usage (FILE * stream, int status)
1518 {
1519   fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1520            program_name);
1521   xexit (status);
1522 }
1523
1524 int
1525 main (int argc, char **argv)
1526 {
1527   extern int chdir (char *);
1528   char *srcdir = NULL;
1529   int c;
1530   unsigned int i, cpumax;
1531   FILE *table;
1532
1533   program_name = *argv;
1534   xmalloc_set_program_name (program_name);
1535
1536   while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1537     switch (c)
1538       {
1539       case OPTION_SRCDIR:
1540         srcdir = optarg;
1541         break;
1542       case 'V':
1543       case 'v':
1544         print_version ();
1545         break;
1546       case 'd':
1547         debug = 1;
1548         break;
1549       case 'h':
1550       case '?':
1551         usage (stderr, 0);
1552       default:
1553       case 0:
1554         break;
1555       }
1556
1557   if (optind != argc)
1558     usage (stdout, 1);
1559
1560   if (srcdir != NULL)
1561     if (chdir (srcdir) != 0)
1562       fail (_("unable to change directory to \"%s\", errno = %s\n"),
1563             srcdir, xstrerror (errno));
1564
1565   /* cpu_flags isn't sorted by position.  */
1566   cpumax = 0;
1567   for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
1568     if (cpu_flags[i].position > cpumax)
1569       cpumax = cpu_flags[i].position;
1570
1571   /* Check the unused bitfield in i386_cpu_flags.  */
1572 #ifdef CpuUnused
1573   if ((cpumax - 1) != CpuMax)
1574     fail (_("CpuMax != %d!\n"), cpumax);
1575 #else
1576   if (cpumax != CpuMax)
1577     fail (_("CpuMax != %d!\n"), cpumax);
1578
1579   c = CpuNumOfBits - CpuMax - 1;
1580   if (c)
1581     fail (_("%d unused bits in i386_cpu_flags.\n"), c);
1582 #endif
1583
1584   /* Check the unused bitfield in i386_operand_type.  */
1585 #ifndef OTUnused
1586   c = OTNumOfBits - OTMax - 1;
1587   if (c)
1588     fail (_("%d unused bits in i386_operand_type.\n"), c);
1589 #endif
1590
1591   qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1592          compare);
1593
1594   qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1595          sizeof (opcode_modifiers [0]), compare);
1596
1597   qsort (operand_types, ARRAY_SIZE (operand_types),
1598          sizeof (operand_types [0]), compare);
1599
1600   table = fopen ("i386-tbl.h", "w");
1601   if (table == NULL)
1602     fail (_("can't create i386-tbl.h, errno = %s\n"),
1603           xstrerror (errno));
1604
1605   process_copyright (table);
1606
1607   process_i386_opcodes (table);
1608   process_i386_registers (table);
1609   process_i386_initializers ();
1610
1611   fclose (table);
1612
1613   exit (0);
1614 }