opcodes/i386-gen.c

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