opcodes/i386-gen.c

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