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