opcodes/i386-gen.c

   1 /* Copyright (C) 2007-2019 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     "InOutPortReg" },
 426   { "OPERAND_TYPE_SHIFTCOUNT",
 427     "ShiftCount" },
 428   { "OPERAND_TYPE_CONTROL",
 429     "Control" },
 430   { "OPERAND_TYPE_TEST",
 431     "Test" },
 432   { "OPERAND_TYPE_DEBUG",
 433     "Debug" },
 434   { "OPERAND_TYPE_FLOATREG",
 435     "Class=Reg|Tbyte" },
 436   { "OPERAND_TYPE_FLOATACC",
 437     "Acc|Tbyte" },
 438   { "OPERAND_TYPE_SREG",
 439     "Class=SReg" },
 440   { "OPERAND_TYPE_JUMPABSOLUTE",
 441     "JumpAbsolute" },
 442   { "OPERAND_TYPE_REGMMX",
 443     "RegMMX" },
 444   { "OPERAND_TYPE_REGXMM",
 445     "RegSIMD|Xmmword" },
 446   { "OPERAND_TYPE_REGYMM",
 447     "RegSIMD|Ymmword" },
 448   { "OPERAND_TYPE_REGZMM",
 449     "RegSIMD|Zmmword" },
 450   { "OPERAND_TYPE_REGMASK",
 451     "RegMask" },
 452   { "OPERAND_TYPE_ESSEG",
 453     "EsSeg" },
 454   { "OPERAND_TYPE_ACC8",
 455     "Acc|Byte" },
 456   { "OPERAND_TYPE_ACC16",
 457     "Acc|Word" },
 458   { "OPERAND_TYPE_ACC32",
 459     "Acc|Dword" },
 460   { "OPERAND_TYPE_ACC64",
 461     "Acc|Qword" },
 462   { "OPERAND_TYPE_DISP16_32",
 463     "Disp16|Disp32" },
 464   { "OPERAND_TYPE_ANYDISP",
 465     "Disp8|Disp16|Disp32|Disp32S|Disp64" },
 466   { "OPERAND_TYPE_IMM16_32",
 467     "Imm16|Imm32" },
 468   { "OPERAND_TYPE_IMM16_32S",
 469     "Imm16|Imm32S" },
 470   { "OPERAND_TYPE_IMM16_32_32S",
 471     "Imm16|Imm32|Imm32S" },
 472   { "OPERAND_TYPE_IMM32_64",
 473     "Imm32|Imm64" },
 474   { "OPERAND_TYPE_IMM32_32S_DISP32",
 475     "Imm32|Imm32S|Disp32" },
 476   { "OPERAND_TYPE_IMM64_DISP64",
 477     "Imm64|Disp64" },
 478   { "OPERAND_TYPE_IMM32_32S_64_DISP32",
 479     "Imm32|Imm32S|Imm64|Disp32" },
 480   { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
 481     "Imm32|Imm32S|Imm64|Disp32|Disp64" },
 482   { "OPERAND_TYPE_ANYIMM",
 483     "Imm1|Imm8|Imm8S|Imm16|Imm32|Imm32S|Imm64" },
 484   { "OPERAND_TYPE_REGBND",
 485     "RegBND" },
 486 };
 487
 488 typedef struct bitfield
 489 {
 490   int position;
 491   int value;
 492   const char *name;
 493 } bitfield;
 494
 495 #define BITFIELD(n) { n, 0, #n }
 496
 497 static bitfield cpu_flags[] =
 498 {
 499   BITFIELD (Cpu186),
 500   BITFIELD (Cpu286),
 501   BITFIELD (Cpu386),
 502   BITFIELD (Cpu486),
 503   BITFIELD (Cpu586),
 504   BITFIELD (Cpu686),
 505   BITFIELD (CpuCMOV),
 506   BITFIELD (CpuFXSR),
 507   BITFIELD (CpuClflush),
 508   BITFIELD (CpuNop),
 509   BITFIELD (CpuSYSCALL),
 510   BITFIELD (Cpu8087),
 511   BITFIELD (Cpu287),
 512   BITFIELD (Cpu387),
 513   BITFIELD (Cpu687),
 514   BITFIELD (CpuFISTTP),
 515   BITFIELD (CpuMMX),
 516   BITFIELD (CpuSSE),
 517   BITFIELD (CpuSSE2),
 518   BITFIELD (CpuSSE3),
 519   BITFIELD (CpuSSSE3),
 520   BITFIELD (CpuSSE4_1),
 521   BITFIELD (CpuSSE4_2),
 522   BITFIELD (CpuAVX),
 523   BITFIELD (CpuAVX2),
 524   BITFIELD (CpuAVX512F),
 525   BITFIELD (CpuAVX512CD),
 526   BITFIELD (CpuAVX512ER),
 527   BITFIELD (CpuAVX512PF),
 528   BITFIELD (CpuAVX512VL),
 529   BITFIELD (CpuAVX512DQ),
 530   BITFIELD (CpuAVX512BW),
 531   BITFIELD (CpuL1OM),
 532   BITFIELD (CpuK1OM),
 533   BITFIELD (CpuIAMCU),
 534   BITFIELD (CpuSSE4a),
 535   BITFIELD (Cpu3dnow),
 536   BITFIELD (Cpu3dnowA),
 537   BITFIELD (CpuPadLock),
 538   BITFIELD (CpuSVME),
 539   BITFIELD (CpuVMX),
 540   BITFIELD (CpuSMX),
 541   BITFIELD (CpuABM),
 542   BITFIELD (CpuXsave),
 543   BITFIELD (CpuXsaveopt),
 544   BITFIELD (CpuAES),
 545   BITFIELD (CpuPCLMUL),
 546   BITFIELD (CpuFMA),
 547   BITFIELD (CpuFMA4),
 548   BITFIELD (CpuXOP),
 549   BITFIELD (CpuLWP),
 550   BITFIELD (CpuBMI),
 551   BITFIELD (CpuTBM),
 552   BITFIELD (CpuLM),
 553   BITFIELD (CpuMovbe),
 554   BITFIELD (CpuCX16),
 555   BITFIELD (CpuEPT),
 556   BITFIELD (CpuRdtscp),
 557   BITFIELD (CpuFSGSBase),
 558   BITFIELD (CpuRdRnd),
 559   BITFIELD (CpuF16C),
 560   BITFIELD (CpuBMI2),
 561   BITFIELD (CpuLZCNT),
 562   BITFIELD (CpuHLE),
 563   BITFIELD (CpuRTM),
 564   BITFIELD (CpuINVPCID),
 565   BITFIELD (CpuVMFUNC),
 566   BITFIELD (CpuRDSEED),
 567   BITFIELD (CpuADX),
 568   BITFIELD (CpuPRFCHW),
 569   BITFIELD (CpuSMAP),
 570   BITFIELD (CpuSHA),
 571   BITFIELD (CpuClflushOpt),
 572   BITFIELD (CpuXSAVES),
 573   BITFIELD (CpuXSAVEC),
 574   BITFIELD (CpuPREFETCHWT1),
 575   BITFIELD (CpuSE1),
 576   BITFIELD (CpuCLWB),
 577   BITFIELD (Cpu64),
 578   BITFIELD (CpuNo64),
 579   BITFIELD (CpuMPX),
 580   BITFIELD (CpuAVX512IFMA),
 581   BITFIELD (CpuAVX512VBMI),
 582   BITFIELD (CpuAVX512_4FMAPS),
 583   BITFIELD (CpuAVX512_4VNNIW),
 584   BITFIELD (CpuAVX512_VPOPCNTDQ),
 585   BITFIELD (CpuAVX512_VBMI2),
 586   BITFIELD (CpuAVX512_VNNI),
 587   BITFIELD (CpuAVX512_BITALG),
 588   BITFIELD (CpuAVX512_BF16),
 589   BITFIELD (CpuAVX512_VP2INTERSECT),
 590   BITFIELD (CpuMWAITX),
 591   BITFIELD (CpuCLZERO),
 592   BITFIELD (CpuOSPKE),
 593   BITFIELD (CpuRDPID),
 594   BITFIELD (CpuPTWRITE),
 595   BITFIELD (CpuIBT),
 596   BITFIELD (CpuSHSTK),
 597   BITFIELD (CpuGFNI),
 598   BITFIELD (CpuVAES),
 599   BITFIELD (CpuVPCLMULQDQ),
 600   BITFIELD (CpuWBNOINVD),
 601   BITFIELD (CpuPCONFIG),
 602   BITFIELD (CpuWAITPKG),
 603   BITFIELD (CpuCLDEMOTE),
 604   BITFIELD (CpuMOVDIRI),
 605   BITFIELD (CpuMOVDIR64B),
 606   BITFIELD (CpuENQCMD),
 607   BITFIELD (CpuRDPRU),
 608   BITFIELD (CpuMCOMMIT),
 609 #ifdef CpuUnused
 610   BITFIELD (CpuUnused),
 611 #endif
 612 };
 613
 614 static bitfield opcode_modifiers[] =
 615 {
 616   BITFIELD (D),
 617   BITFIELD (W),
 618   BITFIELD (Load),
 619   BITFIELD (Modrm),
 620   BITFIELD (ShortForm),
 621   BITFIELD (Jump),
 622   BITFIELD (JumpDword),
 623   BITFIELD (JumpByte),
 624   BITFIELD (JumpInterSegment),
 625   BITFIELD (FloatMF),
 626   BITFIELD (FloatR),
 627   BITFIELD (Size),
 628   BITFIELD (CheckRegSize),
 629   BITFIELD (IgnoreSize),
 630   BITFIELD (DefaultSize),
 631   BITFIELD (No_bSuf),
 632   BITFIELD (No_wSuf),
 633   BITFIELD (No_lSuf),
 634   BITFIELD (No_sSuf),
 635   BITFIELD (No_qSuf),
 636   BITFIELD (No_ldSuf),
 637   BITFIELD (FWait),
 638   BITFIELD (IsString),
 639   BITFIELD (RegMem),
 640   BITFIELD (BNDPrefixOk),
 641   BITFIELD (NoTrackPrefixOk),
 642   BITFIELD (IsLockable),
 643   BITFIELD (RegKludge),
 644   BITFIELD (Implicit1stXmm0),
 645   BITFIELD (RepPrefixOk),
 646   BITFIELD (HLEPrefixOk),
 647   BITFIELD (ToDword),
 648   BITFIELD (ToQword),
 649   BITFIELD (AddrPrefixOpReg),
 650   BITFIELD (IsPrefix),
 651   BITFIELD (ImmExt),
 652   BITFIELD (NoRex64),
 653   BITFIELD (Rex64),
 654   BITFIELD (Ugh),
 655   BITFIELD (Vex),
 656   BITFIELD (VexVVVV),
 657   BITFIELD (VexW),
 658   BITFIELD (VexOpcode),
 659   BITFIELD (VexSources),
 660   BITFIELD (VecSIB),
 661   BITFIELD (SSE2AVX),
 662   BITFIELD (NoAVX),
 663   BITFIELD (EVex),
 664   BITFIELD (Masking),
 665   BITFIELD (Broadcast),
 666   BITFIELD (StaticRounding),
 667   BITFIELD (SAE),
 668   BITFIELD (Disp8MemShift),
 669   BITFIELD (NoDefMask),
 670   BITFIELD (ImplicitQuadGroup),
 671   BITFIELD (Optimize),
 672   BITFIELD (ATTMnemonic),
 673   BITFIELD (ATTSyntax),
 674   BITFIELD (IntelSyntax),
 675   BITFIELD (AMD64),
 676   BITFIELD (Intel64),
 677 };
 678
 679 #define CLASS(n) #n, n
 680
 681 static const struct {
 682   const char *name;
 683   enum operand_class value;
 684 } operand_classes[] = {
 685   CLASS (Reg),
 686   CLASS (SReg),
 687 };
 688
 689 #undef CLASS
 690
 691 static bitfield operand_types[] =
 692 {
 693   BITFIELD (RegMMX),
 694   BITFIELD (RegSIMD),
 695   BITFIELD (RegMask),
 696   BITFIELD (Imm1),
 697   BITFIELD (Imm8),
 698   BITFIELD (Imm8S),
 699   BITFIELD (Imm16),
 700   BITFIELD (Imm32),
 701   BITFIELD (Imm32S),
 702   BITFIELD (Imm64),
 703   BITFIELD (BaseIndex),
 704   BITFIELD (Disp8),
 705   BITFIELD (Disp16),
 706   BITFIELD (Disp32),
 707   BITFIELD (Disp32S),
 708   BITFIELD (Disp64),
 709   BITFIELD (InOutPortReg),
 710   BITFIELD (ShiftCount),
 711   BITFIELD (Control),
 712   BITFIELD (Debug),
 713   BITFIELD (Test),
 714   BITFIELD (Acc),
 715   BITFIELD (JumpAbsolute),
 716   BITFIELD (EsSeg),
 717   BITFIELD (Byte),
 718   BITFIELD (Word),
 719   BITFIELD (Dword),
 720   BITFIELD (Fword),
 721   BITFIELD (Qword),
 722   BITFIELD (Tbyte),
 723   BITFIELD (Xmmword),
 724   BITFIELD (Ymmword),
 725   BITFIELD (Zmmword),
 726   BITFIELD (Unspecified),
 727   BITFIELD (Anysize),
 728   BITFIELD (RegBND),
 729 #ifdef OTUnused
 730   BITFIELD (OTUnused),
 731 #endif
 732 };
 733
 734 static const char *filename;
 735 static i386_cpu_flags active_cpu_flags;
 736 static int active_isstring;
 737
 738 static int
 739 compare (const void *x, const void *y)
 740 {
 741   const bitfield *xp = (const bitfield *) x;
 742   const bitfield *yp = (const bitfield *) y;
 743   return xp->position - yp->position;
 744 }
 745
 746 static void
 747 fail (const char *message, ...)
 748 {
 749   va_list args;
 750
 751   va_start (args, message);
 752   fprintf (stderr, _("%s: error: "), program_name);
 753   vfprintf (stderr, message, args);
 754   va_end (args);
 755   xexit (1);
 756 }
 757
 758 static void
 759 process_copyright (FILE *fp)
 760 {
 761   fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
 762 /* Copyright (C) 2007-2019 Free Software Foundation, Inc.\n\
 763 \n\
 764    This file is part of the GNU opcodes library.\n\
 765 \n\
 766    This library is free software; you can redistribute it and/or modify\n\
 767    it under the terms of the GNU General Public License as published by\n\
 768    the Free Software Foundation; either version 3, or (at your option)\n\
 769    any later version.\n\
 770 \n\
 771    It is distributed in the hope that it will be useful, but WITHOUT\n\
 772    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
 773    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
 774    License for more details.\n\
 775 \n\
 776    You should have received a copy of the GNU General Public License\n\
 777    along with this program; if not, write to the Free Software\n\
 778    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
 779    MA 02110-1301, USA.  */\n");
 780 }
 781
 782 /* Remove leading white spaces.  */
 783
 784 static char *
 785 remove_leading_whitespaces (char *str)
 786 {
 787   while (ISSPACE (*str))
 788     str++;
 789   return str;
 790 }
 791
 792 /* Remove trailing white spaces.  */
 793
 794 static void
 795 remove_trailing_whitespaces (char *str)
 796 {
 797   size_t last = strlen (str);
 798
 799   if (last == 0)
 800     return;
 801
 802   do
 803     {
 804       last--;
 805       if (ISSPACE (str [last]))
 806         str[last] = '\0';
 807       else
 808         break;
 809     }
 810   while (last != 0);
 811 }
 812
 813 /* Find next field separated by SEP and terminate it. Return a
 814    pointer to the one after it.  */
 815
 816 static char *
 817 next_field (char *str, char sep, char **next, char *last)
 818 {
 819   char *p;
 820
 821   p = remove_leading_whitespaces (str);
 822   for (str = p; *str != sep && *str != '\0'; str++);
 823
 824   *str = '\0';
 825   remove_trailing_whitespaces (p);
 826
 827   *next = str + 1;
 828
 829   if (p >= last)
 830     abort ();
 831
 832   return p;
 833 }
 834
 835 static void set_bitfield (char *, bitfield *, int, unsigned int, int);
 836
 837 static int
 838 set_bitfield_from_cpu_flag_init (char *f, bitfield *array, unsigned int size,
 839                                  int lineno)
 840 {
 841   char *str, *next, *last;
 842   unsigned int i;
 843
 844   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
 845     if (strcmp (cpu_flag_init[i].name, f) == 0)
 846       {
 847         /* Turn on selective bits.  */
 848         char *init = xstrdup (cpu_flag_init[i].init);
 849         last = init + strlen (init);
 850         for (next = init; next && next < last; )
 851           {
 852             str = next_field (next, '|', &next, last);
 853             if (str)
 854               set_bitfield (str, array, 1, size, lineno);
 855           }
 856         free (init);
 857         return 0;
 858       }
 859
 860   return -1;
 861 }
 862
 863 static void
 864 set_bitfield (char *f, bitfield *array, int value,
 865               unsigned int size, int lineno)
 866 {
 867   unsigned int i;
 868
 869   if (strcmp (f, "CpuFP") == 0)
 870     {
 871       set_bitfield("Cpu387", array, value, size, lineno);
 872       set_bitfield("Cpu287", array, value, size, lineno);
 873       f = "Cpu8087";
 874     }
 875   else if (strcmp (f, "Mmword") == 0)
 876     f= "Qword";
 877   else if (strcmp (f, "Oword") == 0)
 878     f= "Xmmword";
 879
 880   for (i = 0; i < size; i++)
 881     if (strcasecmp (array[i].name, f) == 0)
 882       {
 883         array[i].value = value;
 884         return;
 885       }
 886
 887   if (value)
 888     {
 889       const char *v = strchr (f, '=');
 890
 891       if (v)
 892         {
 893           size_t n = v - f;
 894           char *end;
 895
 896           for (i = 0; i < size; i++)
 897             if (strncasecmp (array[i].name, f, n) == 0)
 898               {
 899                 value = strtol (v + 1, &end, 0);
 900                 if (*end == '\0')
 901                   {
 902                     array[i].value = value;
 903                     return;
 904                   }
 905                 break;
 906               }
 907         }
 908     }
 909
 910   /* Handle CPU_XXX_FLAGS.  */
 911   if (value == 1 && !set_bitfield_from_cpu_flag_init (f, array, size, lineno))
 912     return;
 913
 914   if (lineno != -1)
 915     fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
 916   else
 917     fail (_("unknown bitfield: %s\n"), f);
 918 }
 919
 920 static void
 921 output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
 922                   int macro, const char *comma, const char *indent)
 923 {
 924   unsigned int i;
 925
 926   memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
 927
 928   fprintf (table, "%s{ { ", indent);
 929
 930   for (i = 0; i < size - 1; i++)
 931     {
 932       if (((i + 1) % 20) != 0)
 933         fprintf (table, "%d, ", flags[i].value);
 934       else
 935         fprintf (table, "%d,", flags[i].value);
 936       if (((i + 1) % 20) == 0)
 937         {
 938           /* We need \\ for macro.  */
 939           if (macro)
 940             fprintf (table, " \\\n    %s", indent);
 941           else
 942             fprintf (table, "\n    %s", indent);
 943         }
 944       if (flags[i].value)
 945         active_cpu_flags.array[i / 32] |= 1U << (i % 32);
 946     }
 947
 948   fprintf (table, "%d } }%s\n", flags[i].value, comma);
 949 }
 950
 951 static void
 952 process_i386_cpu_flag (FILE *table, char *flag, int macro,
 953                        const char *comma, const char *indent,
 954                        int lineno)
 955 {
 956   char *str, *next, *last;
 957   unsigned int i;
 958   bitfield flags [ARRAY_SIZE (cpu_flags)];
 959
 960   /* Copy the default cpu flags.  */
 961   memcpy (flags, cpu_flags, sizeof (cpu_flags));
 962
 963   if (strcasecmp (flag, "unknown") == 0)
 964     {
 965       /* We turn on everything except for cpu64 in case of
 966          CPU_UNKNOWN_FLAGS.  */
 967       for (i = 0; i < ARRAY_SIZE (flags); i++)
 968         if (flags[i].position != Cpu64)
 969           flags[i].value = 1;
 970     }
 971   else if (flag[0] == '~')
 972     {
 973       last = flag + strlen (flag);
 974
 975       if (flag[1] == '(')
 976         {
 977           last -= 1;
 978           next = flag + 2;
 979           if (*last != ')')
 980             fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
 981                   lineno, flag);
 982           *last = '\0';
 983         }
 984       else
 985         next = flag + 1;
 986
 987       /* First we turn on everything except for cpu64.  */
 988       for (i = 0; i < ARRAY_SIZE (flags); i++)
 989         if (flags[i].position != Cpu64)
 990           flags[i].value = 1;
 991
 992       /* Turn off selective bits.  */
 993       for (; next && next < last; )
 994         {
 995           str = next_field (next, '|', &next, last);
 996           if (str)
 997             set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
 998         }
 999     }
1000   else if (strcmp (flag, "0"))
1001     {
1002       /* Turn on selective bits.  */
1003       last = flag + strlen (flag);
1004       for (next = flag; next && next < last; )
1005         {
1006           str = next_field (next, '|', &next, last);
1007           if (str)
1008             set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
1009         }
1010     }
1011
1012   output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
1013                     comma, indent);
1014 }
1015
1016 static void
1017 output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1018 {
1019   unsigned int i;
1020
1021   fprintf (table, "    { ");
1022
1023   for (i = 0; i < size - 1; i++)
1024     {
1025       if (((i + 1) % 20) != 0)
1026         fprintf (table, "%d, ", modifier[i].value);
1027       else
1028         fprintf (table, "%d,", modifier[i].value);
1029       if (((i + 1) % 20) == 0)
1030         fprintf (table, "\n      ");
1031     }
1032
1033   fprintf (table, "%d },\n", modifier[i].value);
1034 }
1035
1036 static int
1037 adjust_broadcast_modifier (char **opnd)
1038 {
1039   char *str, *next, *last, *op;
1040   int bcst_type = INT_MAX;
1041
1042   /* Skip the immediate operand.  */
1043   op = opnd[0];
1044   if (strcasecmp(op, "Imm8") == 0)
1045     op = opnd[1];
1046
1047   op = xstrdup (op);
1048   last = op + strlen (op);
1049   for (next = op; next && next < last; )
1050     {
1051       str = next_field (next, '|', &next, last);
1052       if (str)
1053         {
1054           if (strcasecmp(str, "Byte") == 0)
1055             {
1056               /* The smalest broadcast type, no need to check
1057                  further.  */
1058               bcst_type = BYTE_BROADCAST;
1059               break;
1060             }
1061           else if (strcasecmp(str, "Word") == 0)
1062             {
1063               if (bcst_type > WORD_BROADCAST)
1064                 bcst_type = WORD_BROADCAST;
1065             }
1066           else if (strcasecmp(str, "Dword") == 0)
1067             {
1068               if (bcst_type > DWORD_BROADCAST)
1069                 bcst_type = DWORD_BROADCAST;
1070             }
1071           else if (strcasecmp(str, "Qword") == 0)
1072             {
1073               if (bcst_type > QWORD_BROADCAST)
1074                 bcst_type = QWORD_BROADCAST;
1075             }
1076         }
1077     }
1078   free (op);
1079
1080   if (bcst_type == INT_MAX)
1081     fail (_("unknown broadcast operand: %s\n"), op);
1082
1083   return bcst_type;
1084 }
1085
1086 static void
1087 process_i386_opcode_modifier (FILE *table, char *mod, char **opnd, int lineno)
1088 {
1089   char *str, *next, *last;
1090   bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1091
1092   active_isstring = 0;
1093
1094   /* Copy the default opcode modifier.  */
1095   memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1096
1097   if (strcmp (mod, "0"))
1098     {
1099       unsigned int have_w = 0, bwlq_suf = 0xf;
1100
1101       last = mod + strlen (mod);
1102       for (next = mod; next && next < last; )
1103         {
1104           str = next_field (next, '|', &next, last);
1105           if (str)
1106             {
1107               int val = 1;
1108               if (strcasecmp(str, "Broadcast") == 0)
1109                   val = adjust_broadcast_modifier (opnd);
1110               set_bitfield (str, modifiers, val, ARRAY_SIZE (modifiers),
1111                           lineno);
1112               if (strcasecmp(str, "IsString") == 0)
1113                 active_isstring = 1;
1114
1115               if (strcasecmp(str, "W") == 0)
1116                 have_w = 1;
1117
1118               if (strcasecmp(str, "No_bSuf") == 0)
1119                 bwlq_suf &= ~1;
1120               if (strcasecmp(str, "No_wSuf") == 0)
1121                 bwlq_suf &= ~2;
1122               if (strcasecmp(str, "No_lSuf") == 0)
1123                 bwlq_suf &= ~4;
1124               if (strcasecmp(str, "No_qSuf") == 0)
1125                 bwlq_suf &= ~8;
1126             }
1127         }
1128
1129       if (have_w && !bwlq_suf)
1130         fail ("%s: %d: stray W modifier\n", filename, lineno);
1131       if (have_w && !(bwlq_suf & 1))
1132         fprintf (stderr, "%s: %d: W modifier without Byte operand(s)\n",
1133                  filename, lineno);
1134       if (have_w && !(bwlq_suf & ~1))
1135         fprintf (stderr,
1136                  "%s: %d: W modifier without Word/Dword/Qword operand(s)\n",
1137                  filename, lineno);
1138     }
1139   output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1140 }
1141
1142 enum stage {
1143   stage_macros,
1144   stage_opcodes,
1145   stage_registers,
1146 };
1147
1148 static void
1149 output_operand_type (FILE *table, enum operand_class class,
1150                      const bitfield *types, unsigned int size,
1151                      enum stage stage, const char *indent)
1152 {
1153   unsigned int i;
1154
1155   fprintf (table, "{ { %d, ", class);
1156
1157   for (i = 0; i < size - 1; i++)
1158     {
1159       if (((i + 2) % 20) != 0)
1160         fprintf (table, "%d, ", types[i].value);
1161       else
1162         fprintf (table, "%d,", types[i].value);
1163       if (((i + 2) % 20) == 0)
1164         {
1165           /* We need \\ for macro.  */
1166           if (stage == stage_macros)
1167             fprintf (table, " \\\n%s", indent);
1168           else
1169             fprintf (table, "\n%s", indent);
1170         }
1171     }
1172
1173   fprintf (table, "%d } }", types[i].value);
1174 }
1175
1176 static void
1177 process_i386_operand_type (FILE *table, char *op, enum stage stage,
1178                            const char *indent, int lineno)
1179 {
1180   char *str, *next, *last;
1181   enum operand_class class = ClassNone;
1182   bitfield types [ARRAY_SIZE (operand_types)];
1183
1184   /* Copy the default operand type.  */
1185   memcpy (types, operand_types, sizeof (types));
1186
1187   if (strcmp (op, "0"))
1188     {
1189       int baseindex = 0;
1190
1191       last = op + strlen (op);
1192       for (next = op; next && next < last; )
1193         {
1194           str = next_field (next, '|', &next, last);
1195           if (str)
1196             {
1197               unsigned int i;
1198
1199               if (!strncmp(str, "Class=", 6))
1200                 {
1201                   for (i = 0; i < ARRAY_SIZE(operand_classes); ++i)
1202                     if (!strcmp(str + 6, operand_classes[i].name))
1203                       {
1204                         class = operand_classes[i].value;
1205                         str = NULL;
1206                         break;
1207                       }
1208                 }
1209             }
1210           if (str)
1211             {
1212               set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1213               if (strcasecmp(str, "BaseIndex") == 0)
1214                 baseindex = 1;
1215             }
1216         }
1217
1218       if (stage == stage_opcodes && baseindex && !active_isstring)
1219         {
1220           set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1221           if (!active_cpu_flags.bitfield.cpu64
1222               && !active_cpu_flags.bitfield.cpumpx)
1223             set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1224           set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1225           if (!active_cpu_flags.bitfield.cpuno64)
1226             set_bitfield("Disp32S", types, 1, ARRAY_SIZE (types), lineno);
1227         }
1228     }
1229   output_operand_type (table, class, types, ARRAY_SIZE (types), stage,
1230                        indent);
1231 }
1232
1233 static void
1234 output_i386_opcode (FILE *table, const char *name, char *str,
1235                     char *last, int lineno)
1236 {
1237   unsigned int i;
1238   char *operands, *base_opcode, *extension_opcode, *opcode_length;
1239   char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1240
1241   /* Find number of operands.  */
1242   operands = next_field (str, ',', &str, last);
1243
1244   /* Find base_opcode.  */
1245   base_opcode = next_field (str, ',', &str, last);
1246
1247   /* Find extension_opcode.  */
1248   extension_opcode = next_field (str, ',', &str, last);
1249
1250   /* Find opcode_length.  */
1251   opcode_length = next_field (str, ',', &str, last);
1252
1253   /* Find cpu_flags.  */
1254   cpu_flags = next_field (str, ',', &str, last);
1255
1256   /* Find opcode_modifier.  */
1257   opcode_modifier = next_field (str, ',', &str, last);
1258
1259   /* Remove the first {.  */
1260   str = remove_leading_whitespaces (str);
1261   if (*str != '{')
1262     abort ();
1263   str = remove_leading_whitespaces (str + 1);
1264
1265   i = strlen (str);
1266
1267   /* There are at least "X}".  */
1268   if (i < 2)
1269     abort ();
1270
1271   /* Remove trailing white spaces and }. */
1272   do
1273     {
1274       i--;
1275       if (ISSPACE (str[i]) || str[i] == '}')
1276         str[i] = '\0';
1277       else
1278         break;
1279     }
1280   while (i != 0);
1281
1282   last = str + i;
1283
1284   /* Find operand_types.  */
1285   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1286     {
1287       if (str >= last)
1288         {
1289           operand_types [i] = NULL;
1290           break;
1291         }
1292
1293       operand_types [i] = next_field (str, ',', &str, last);
1294       if (*operand_types[i] == '0')
1295         {
1296           if (i != 0)
1297             operand_types[i] = NULL;
1298           break;
1299         }
1300     }
1301
1302   fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
1303            name, base_opcode, extension_opcode, opcode_length, operands);
1304
1305   process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
1306
1307   process_i386_opcode_modifier (table, opcode_modifier, operand_types, lineno);
1308
1309   fprintf (table, "    { ");
1310
1311   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1312     {
1313       if (operand_types[i] == NULL || *operand_types[i] == '0')
1314         {
1315           if (i == 0)
1316             process_i386_operand_type (table, "0", stage_opcodes, "\t  ",
1317                                        lineno);
1318           break;
1319         }
1320
1321       if (i != 0)
1322         fprintf (table, ",\n      ");
1323
1324       process_i386_operand_type (table, operand_types[i], stage_opcodes,
1325                                  "\t  ", lineno);
1326     }
1327   fprintf (table, " } },\n");
1328 }
1329
1330 struct opcode_hash_entry
1331 {
1332   struct opcode_hash_entry *next;
1333   char *name;
1334   char *opcode;
1335   int lineno;
1336 };
1337
1338 /* Calculate the hash value of an opcode hash entry P.  */
1339
1340 static hashval_t
1341 opcode_hash_hash (const void *p)
1342 {
1343   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1344   return htab_hash_string (entry->name);
1345 }
1346
1347 /* Compare a string Q against an opcode hash entry P.  */
1348
1349 static int
1350 opcode_hash_eq (const void *p, const void *q)
1351 {
1352   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1353   const char *name = (const char *) q;
1354   return strcmp (name, entry->name) == 0;
1355 }
1356
1357 static void
1358 process_i386_opcodes (FILE *table)
1359 {
1360   FILE *fp;
1361   char buf[2048];
1362   unsigned int i, j;
1363   char *str, *p, *last, *name;
1364   struct opcode_hash_entry **hash_slot, **entry, *next;
1365   htab_t opcode_hash_table;
1366   struct opcode_hash_entry **opcode_array;
1367   unsigned int opcode_array_size = 1024;
1368   int lineno = 0, marker = 0;
1369
1370   filename = "i386-opc.tbl";
1371   fp = stdin;
1372
1373   i = 0;
1374   opcode_array = (struct opcode_hash_entry **)
1375     xmalloc (sizeof (*opcode_array) * opcode_array_size);
1376
1377   opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1378                                          opcode_hash_eq, NULL,
1379                                          xcalloc, free);
1380
1381   fprintf (table, "\n/* i386 opcode table.  */\n\n");
1382   fprintf (table, "const insn_template i386_optab[] =\n{\n");
1383
1384   /* Put everything on opcode array.  */
1385   while (!feof (fp))
1386     {
1387       if (fgets (buf, sizeof (buf), fp) == NULL)
1388         break;
1389
1390       lineno++;
1391
1392       p = remove_leading_whitespaces (buf);
1393
1394       /* Skip comments.  */
1395       str = strstr (p, "//");
1396       if (str != NULL)
1397         str[0] = '\0';
1398
1399       /* Remove trailing white spaces.  */
1400       remove_trailing_whitespaces (p);
1401
1402       switch (p[0])
1403         {
1404         case '#':
1405           if (!strcmp("### MARKER ###", buf))
1406             marker = 1;
1407           else
1408             {
1409               /* Since we ignore all included files (we only care about their
1410                  #define-s here), we don't need to monitor filenames.  The final
1411                  line number directive is going to refer to the main source file
1412                  again.  */
1413               char *end;
1414               unsigned long ln;
1415
1416               p = remove_leading_whitespaces (p + 1);
1417               if (!strncmp(p, "line", 4))
1418                 p += 4;
1419               ln = strtoul (p, &end, 10);
1420               if (ln > 1 && ln < INT_MAX
1421                   && *remove_leading_whitespaces (end) == '"')
1422                 lineno = ln - 1;
1423             }
1424           /* Ignore comments.  */
1425         case '\0':
1426           continue;
1427           break;
1428         default:
1429           if (!marker)
1430             continue;
1431           break;
1432         }
1433
1434       last = p + strlen (p);
1435
1436       /* Find name.  */
1437       name = next_field (p, ',', &str, last);
1438
1439       /* Get the slot in hash table.  */
1440       hash_slot = (struct opcode_hash_entry **)
1441         htab_find_slot_with_hash (opcode_hash_table, name,
1442                                   htab_hash_string (name),
1443                                   INSERT);
1444
1445       if (*hash_slot == NULL)
1446         {
1447           /* It is the new one.  Put it on opcode array.  */
1448           if (i >= opcode_array_size)
1449             {
1450               /* Grow the opcode array when needed.  */
1451               opcode_array_size += 1024;
1452               opcode_array = (struct opcode_hash_entry **)
1453                 xrealloc (opcode_array,
1454                           sizeof (*opcode_array) * opcode_array_size);
1455             }
1456
1457           opcode_array[i] = (struct opcode_hash_entry *)
1458             xmalloc (sizeof (struct opcode_hash_entry));
1459           opcode_array[i]->next = NULL;
1460           opcode_array[i]->name = xstrdup (name);
1461           opcode_array[i]->opcode = xstrdup (str);
1462           opcode_array[i]->lineno = lineno;
1463           *hash_slot = opcode_array[i];
1464           i++;
1465         }
1466       else
1467         {
1468           /* Append it to the existing one.  */
1469           entry = hash_slot;
1470           while ((*entry) != NULL)
1471             entry = &(*entry)->next;
1472           *entry = (struct opcode_hash_entry *)
1473             xmalloc (sizeof (struct opcode_hash_entry));
1474           (*entry)->next = NULL;
1475           (*entry)->name = (*hash_slot)->name;
1476           (*entry)->opcode = xstrdup (str);
1477           (*entry)->lineno = lineno;
1478         }
1479     }
1480
1481   /* Process opcode array.  */
1482   for (j = 0; j < i; j++)
1483     {
1484       for (next = opcode_array[j]; next; next = next->next)
1485         {
1486           name = next->name;
1487           str = next->opcode;
1488           lineno = next->lineno;
1489           last = str + strlen (str);
1490           output_i386_opcode (table, name, str, last, lineno);
1491         }
1492     }
1493
1494   fclose (fp);
1495
1496   fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
1497
1498   process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
1499
1500   process_i386_opcode_modifier (table, "0", NULL, -1);
1501
1502   fprintf (table, "    { ");
1503   process_i386_operand_type (table, "0", stage_opcodes, "\t  ", -1);
1504   fprintf (table, " } }\n");
1505
1506   fprintf (table, "};\n");
1507 }
1508
1509 static void
1510 process_i386_registers (FILE *table)
1511 {
1512   FILE *fp;
1513   char buf[2048];
1514   char *str, *p, *last;
1515   char *reg_name, *reg_type, *reg_flags, *reg_num;
1516   char *dw2_32_num, *dw2_64_num;
1517   int lineno = 0;
1518
1519   filename = "i386-reg.tbl";
1520   fp = fopen (filename, "r");
1521   if (fp == NULL)
1522     fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1523           xstrerror (errno));
1524
1525   fprintf (table, "\n/* i386 register table.  */\n\n");
1526   fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
1527
1528   while (!feof (fp))
1529     {
1530       if (fgets (buf, sizeof (buf), fp) == NULL)
1531         break;
1532
1533       lineno++;
1534
1535       p = remove_leading_whitespaces (buf);
1536
1537       /* Skip comments.  */
1538       str = strstr (p, "//");
1539       if (str != NULL)
1540         str[0] = '\0';
1541
1542       /* Remove trailing white spaces.  */
1543       remove_trailing_whitespaces (p);
1544
1545       switch (p[0])
1546         {
1547         case '#':
1548           fprintf (table, "%s\n", p);
1549         case '\0':
1550           continue;
1551           break;
1552         default:
1553           break;
1554         }
1555
1556       last = p + strlen (p);
1557
1558       /* Find reg_name.  */
1559       reg_name = next_field (p, ',', &str, last);
1560
1561       /* Find reg_type.  */
1562       reg_type = next_field (str, ',', &str, last);
1563
1564       /* Find reg_flags.  */
1565       reg_flags = next_field (str, ',', &str, last);
1566
1567       /* Find reg_num.  */
1568       reg_num = next_field (str, ',', &str, last);
1569
1570       fprintf (table, "  { \"%s\",\n    ", reg_name);
1571
1572       process_i386_operand_type (table, reg_type, stage_registers, "\t",
1573                                  lineno);
1574
1575       /* Find 32-bit Dwarf2 register number.  */
1576       dw2_32_num = next_field (str, ',', &str, last);
1577
1578       /* Find 64-bit Dwarf2 register number.  */
1579       dw2_64_num = next_field (str, ',', &str, last);
1580
1581       fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
1582                reg_flags, reg_num, dw2_32_num, dw2_64_num);
1583     }
1584
1585   fclose (fp);
1586
1587   fprintf (table, "};\n");
1588
1589   fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1590 }
1591
1592 static void
1593 process_i386_initializers (void)
1594 {
1595   unsigned int i;
1596   FILE *fp = fopen ("i386-init.h", "w");
1597   char *init;
1598
1599   if (fp == NULL)
1600     fail (_("can't create i386-init.h, errno = %s\n"),
1601           xstrerror (errno));
1602
1603   process_copyright (fp);
1604
1605   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1606     {
1607       fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1608       init = xstrdup (cpu_flag_init[i].init);
1609       process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
1610       free (init);
1611     }
1612
1613   for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1614     {
1615       fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
1616       init = xstrdup (operand_type_init[i].init);
1617       process_i386_operand_type (fp, init, stage_macros, "      ", -1);
1618       free (init);
1619     }
1620   fprintf (fp, "\n");
1621
1622   fclose (fp);
1623 }
1624
1625 /* Program options.  */
1626 #define OPTION_SRCDIR   200
1627
1628 struct option long_options[] =
1629 {
1630   {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
1631   {"debug",   no_argument,       NULL, 'd'},
1632   {"version", no_argument,       NULL, 'V'},
1633   {"help",    no_argument,       NULL, 'h'},
1634   {0,         no_argument,       NULL, 0}
1635 };
1636
1637 static void
1638 print_version (void)
1639 {
1640   printf ("%s: version 1.0\n", program_name);
1641   xexit (0);
1642 }
1643
1644 static void
1645 usage (FILE * stream, int status)
1646 {
1647   fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1648            program_name);
1649   xexit (status);
1650 }
1651
1652 int
1653 main (int argc, char **argv)
1654 {
1655   extern int chdir (char *);
1656   char *srcdir = NULL;
1657   int c;
1658   unsigned int i, cpumax;
1659   FILE *table;
1660
1661   program_name = *argv;
1662   xmalloc_set_program_name (program_name);
1663
1664   while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1665     switch (c)
1666       {
1667       case OPTION_SRCDIR:
1668         srcdir = optarg;
1669         break;
1670       case 'V':
1671       case 'v':
1672         print_version ();
1673         break;
1674       case 'd':
1675         debug = 1;
1676         break;
1677       case 'h':
1678       case '?':
1679         usage (stderr, 0);
1680       default:
1681       case 0:
1682         break;
1683       }
1684
1685   if (optind != argc)
1686     usage (stdout, 1);
1687
1688   if (srcdir != NULL)
1689     if (chdir (srcdir) != 0)
1690       fail (_("unable to change directory to \"%s\", errno = %s\n"),
1691             srcdir, xstrerror (errno));
1692
1693   /* cpu_flags isn't sorted by position.  */
1694   cpumax = 0;
1695   for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
1696     if (cpu_flags[i].position > cpumax)
1697       cpumax = cpu_flags[i].position;
1698
1699   /* Check the unused bitfield in i386_cpu_flags.  */
1700 #ifdef CpuUnused
1701   static_assert (ARRAY_SIZE (cpu_flags) == CpuMax + 2);
1702
1703   if ((cpumax - 1) != CpuMax)
1704     fail (_("CpuMax != %d!\n"), cpumax);
1705 #else
1706   static_assert (ARRAY_SIZE (cpu_flags) == CpuMax + 1);
1707
1708   if (cpumax != CpuMax)
1709     fail (_("CpuMax != %d!\n"), cpumax);
1710
1711   c = CpuNumOfBits - CpuMax - 1;
1712   if (c)
1713     fail (_("%d unused bits in i386_cpu_flags.\n"), c);
1714 #endif
1715
1716   static_assert (ARRAY_SIZE (opcode_modifiers) == Opcode_Modifier_Num);
1717
1718   /* Check the unused bitfield in i386_operand_type.  */
1719 #ifdef OTUnused
1720   static_assert (ARRAY_SIZE (operand_types) + CLASS_WIDTH == OTNum + 1);
1721 #else
1722   static_assert (ARRAY_SIZE (operand_types) + CLASS_WIDTH == OTNum);
1723
1724   c = OTNumOfBits - OTMax - 1;
1725   if (c)
1726     fail (_("%d unused bits in i386_operand_type.\n"), c);
1727 #endif
1728
1729   qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1730          compare);
1731
1732   qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1733          sizeof (opcode_modifiers [0]), compare);
1734
1735   qsort (operand_types, ARRAY_SIZE (operand_types),
1736          sizeof (operand_types [0]), compare);
1737
1738   table = fopen ("i386-tbl.h", "w");
1739   if (table == NULL)
1740     fail (_("can't create i386-tbl.h, errno = %s\n"),
1741           xstrerror (errno));
1742
1743   process_copyright (table);
1744
1745   process_i386_opcodes (table);
1746   process_i386_registers (table);
1747   process_i386_initializers ();
1748
1749   fclose (table);
1750
1751   exit (0);
1752 }