opcodes/i386-gen.c

   1 /* Copyright (C) 2007-2022 Free Software Foundation, Inc.
   2
   3    This file is part of the GNU opcodes library.
   4
   5    This library is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    It is distributed in the hope that it will be useful, but WITHOUT
  11    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  13    License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  18    MA 02110-1301, USA.  */
  19
  20 #include "sysdep.h"
  21 #include <stdio.h>
  22 #include <errno.h>
  23 #include "getopt.h"
  24 #include "libiberty.h"
  25 #include "hashtab.h"
  26 #include "safe-ctype.h"
  27
  28 #include "i386-opc.h"
  29
  30 #include <libintl.h>
  31 #define _(String) gettext (String)
  32
  33 /* Build-time checks are preferrable over runtime ones.  Use this construct
  34    in preference where possible.  */
  35 #define static_assert(e) ((void)sizeof (struct { int _:1 - 2 * !(e); }))
  36
  37 static const char *program_name = NULL;
  38 static int debug = 0;
  39
  40 typedef struct initializer
  41 {
  42   const char *name;
  43   const char *init;
  44 } initializer;
  45
  46 static initializer cpu_flag_init[] =
  47 {
  48   { "CPU_UNKNOWN_FLAGS",
  49     "~CpuIAMCU" },
  50   { "CPU_GENERIC32_FLAGS",
  51     "Cpu186|Cpu286|Cpu386" },
  52   { "CPU_GENERIC64_FLAGS",
  53     "CPU_PENTIUMPRO_FLAGS|CpuClflush|CpuSYSCALL|CPU_MMX_FLAGS|CPU_SSE2_FLAGS|CpuLM" },
  54   { "CPU_NONE_FLAGS",
  55    "0" },
  56   { "CPU_I186_FLAGS",
  57     "Cpu186" },
  58   { "CPU_I286_FLAGS",
  59     "CPU_I186_FLAGS|Cpu286" },
  60   { "CPU_I386_FLAGS",
  61     "CPU_I286_FLAGS|Cpu386" },
  62   { "CPU_I486_FLAGS",
  63     "CPU_I386_FLAGS|Cpu486" },
  64   { "CPU_I586_FLAGS",
  65     "CPU_I486_FLAGS|Cpu387|Cpu586" },
  66   { "CPU_I686_FLAGS",
  67     "CPU_I586_FLAGS|Cpu686|Cpu687|CpuCMOV|CpuFXSR" },
  68   { "CPU_PENTIUMPRO_FLAGS",
  69     "CPU_I686_FLAGS|CpuNop" },
  70   { "CPU_P2_FLAGS",
  71     "CPU_PENTIUMPRO_FLAGS|CPU_MMX_FLAGS" },
  72   { "CPU_P3_FLAGS",
  73     "CPU_P2_FLAGS|CPU_SSE_FLAGS" },
  74   { "CPU_P4_FLAGS",
  75     "CPU_P3_FLAGS|CpuClflush|CPU_SSE2_FLAGS" },
  76   { "CPU_NOCONA_FLAGS",
  77     "CPU_GENERIC64_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
  78   { "CPU_CORE_FLAGS",
  79     "CPU_P4_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
  80   { "CPU_CORE2_FLAGS",
  81     "CPU_NOCONA_FLAGS|CPU_SSSE3_FLAGS" },
  82   { "CPU_COREI7_FLAGS",
  83     "CPU_CORE2_FLAGS|CPU_SSE4_2_FLAGS|CpuRdtscp" },
  84   { "CPU_K6_FLAGS",
  85     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CPU_MMX_FLAGS" },
  86   { "CPU_K6_2_FLAGS",
  87     "CPU_K6_FLAGS|Cpu3dnow" },
  88   { "CPU_ATHLON_FLAGS",
  89     "CPU_K6_2_FLAGS|Cpu686|Cpu687|CpuNop|Cpu3dnowA" },
  90   { "CPU_K8_FLAGS",
  91     "CPU_ATHLON_FLAGS|CpuRdtscp|CPU_SSE2_FLAGS|CpuLM" },
  92   { "CPU_AMDFAM10_FLAGS",
  93     "CPU_K8_FLAGS|CpuFISTTP|CPU_SSE4A_FLAGS|CpuLZCNT|CpuPOPCNT" },
  94   { "CPU_BDVER1_FLAGS",
  95     "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuRdtscp|CpuCX16|CPU_XOP_FLAGS|CpuLZCNT|CpuPOPCNT|CpuLWP|CpuSVME|CpuAES|CpuPCLMUL|CpuPRFCHW" },
  96   { "CPU_BDVER2_FLAGS",
  97     "CPU_BDVER1_FLAGS|CpuFMA|CpuBMI|CpuTBM|CpuF16C" },
  98   { "CPU_BDVER3_FLAGS",
  99     "CPU_BDVER2_FLAGS|CpuXsaveopt|CpuFSGSBase" },
 100   { "CPU_BDVER4_FLAGS",
 101     "CPU_BDVER3_FLAGS|CpuAVX2|CpuMovbe|CpuBMI2|CpuRdRnd|CpuMWAITX" },
 102   { "CPU_ZNVER1_FLAGS",
 103     "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuRdtscp|CpuCX16|CPU_AVX2_FLAGS|CpuSSE4A|CpuLZCNT|CpuPOPCNT|CpuSVME|CpuAES|CpuPCLMUL|CpuPRFCHW|CpuFMA|CpuBMI|CpuF16C|CpuXsaveopt|CpuFSGSBase|CpuMovbe|CpuBMI2|CpuRdRnd|CpuADX|CpuRdSeed|CpuSMAP|CpuSHA|CpuXSAVEC|CpuXSAVES|CpuClflushOpt|CpuCLZERO|CpuMWAITX" },
 104   { "CPU_ZNVER2_FLAGS",
 105     "CPU_ZNVER1_FLAGS|CpuCLWB|CpuRDPID|CpuRDPRU|CpuMCOMMIT|CpuWBNOINVD" },
 106   { "CPU_ZNVER3_FLAGS",
 107     "CPU_ZNVER2_FLAGS|CpuINVLPGB|CpuTLBSYNC|CpuVAES|CpuVPCLMULQDQ|CpuINVPCID|CpuSNP|CpuOSPKE" },
 108   { "CPU_ZNVER4_FLAGS",
 109     "CPU_ZNVER3_FLAGS|CpuAVX512F|CpuAVX512DQ|CpuAVX512IFMA|CpuAVX512CD|CpuAVX512BW|CpuAVX512VL|CpuAVX512_BF16|CpuAVX512VBMI|CpuAVX512_VBMI2|CpuAVX512_VNNI|CpuAVX512_BITALG|CpuAVX512_VPOPCNTDQ|CpuGFNI|CpuRMPQUERY" },
 110   { "CPU_BTVER1_FLAGS",
 111     "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuCX16|CpuRdtscp|CPU_SSSE3_FLAGS|CpuSSE4A|CpuLZCNT|CpuPOPCNT|CpuPRFCHW|CpuCX16|CpuClflush|CpuFISTTP|CpuSVME" },
 112   { "CPU_BTVER2_FLAGS",
 113     "CPU_BTVER1_FLAGS|CPU_AVX_FLAGS|CpuBMI|CpuF16C|CpuAES|CpuPCLMUL|CpuMovbe|CpuXsaveopt|CpuPRFCHW" },
 114   { "CPU_8087_FLAGS",
 115     "Cpu8087" },
 116   { "CPU_287_FLAGS",
 117     "Cpu287" },
 118   { "CPU_387_FLAGS",
 119     "Cpu387" },
 120   { "CPU_687_FLAGS",
 121     "CPU_387_FLAGS|Cpu687" },
 122   { "CPU_CMOV_FLAGS",
 123     "CpuCMOV" },
 124   { "CPU_FXSR_FLAGS",
 125     "CpuFXSR" },
 126   { "CPU_CLFLUSH_FLAGS",
 127     "CpuClflush" },
 128   { "CPU_NOP_FLAGS",
 129     "CpuNop" },
 130   { "CPU_SYSCALL_FLAGS",
 131     "CpuSYSCALL" },
 132   { "CPU_MMX_FLAGS",
 133     "CpuMMX" },
 134   { "CPU_SSE_FLAGS",
 135     "CpuSSE" },
 136   { "CPU_SSE2_FLAGS",
 137     "CPU_SSE_FLAGS|CpuSSE2" },
 138   { "CPU_SSE3_FLAGS",
 139     "CPU_SSE2_FLAGS|CpuSSE3" },
 140   { "CPU_SSSE3_FLAGS",
 141     "CPU_SSE3_FLAGS|CpuSSSE3" },
 142   { "CPU_SSE4_1_FLAGS",
 143     "CPU_SSSE3_FLAGS|CpuSSE4_1" },
 144   { "CPU_SSE4_2_FLAGS",
 145     "CPU_SSE4_1_FLAGS|CpuSSE4_2|CpuPOPCNT" },
 146   { "CPU_VMX_FLAGS",
 147     "CpuVMX" },
 148   { "CPU_SMX_FLAGS",
 149     "CpuSMX" },
 150   { "CPU_XSAVE_FLAGS",
 151     "CpuXsave" },
 152   { "CPU_XSAVEOPT_FLAGS",
 153     "CPU_XSAVE_FLAGS|CpuXsaveopt" },
 154   { "CPU_AES_FLAGS",
 155     "CPU_SSE2_FLAGS|CpuAES" },
 156   { "CPU_PCLMUL_FLAGS",
 157     "CPU_SSE2_FLAGS|CpuPCLMUL" },
 158   { "CPU_FMA_FLAGS",
 159     "CPU_AVX_FLAGS|CpuFMA" },
 160   { "CPU_FMA4_FLAGS",
 161     "CPU_AVX_FLAGS|CpuFMA4" },
 162   { "CPU_XOP_FLAGS",
 163     "CPU_SSE4A_FLAGS|CPU_FMA4_FLAGS|CpuXOP" },
 164   { "CPU_LWP_FLAGS",
 165     "CPU_XSAVE_FLAGS|CpuLWP" },
 166   { "CPU_BMI_FLAGS",
 167     "CpuBMI" },
 168   { "CPU_TBM_FLAGS",
 169     "CpuTBM" },
 170   { "CPU_MOVBE_FLAGS",
 171     "CpuMovbe" },
 172   { "CPU_CX16_FLAGS",
 173     "CpuCX16" },
 174   { "CPU_RDTSCP_FLAGS",
 175     "CpuRdtscp" },
 176   { "CPU_EPT_FLAGS",
 177     "CpuEPT" },
 178   { "CPU_FSGSBASE_FLAGS",
 179     "CpuFSGSBase" },
 180   { "CPU_RDRND_FLAGS",
 181     "CpuRdRnd" },
 182   { "CPU_F16C_FLAGS",
 183     "CPU_AVX_FLAGS|CpuF16C" },
 184   { "CPU_BMI2_FLAGS",
 185     "CpuBMI2" },
 186   { "CPU_LZCNT_FLAGS",
 187     "CpuLZCNT" },
 188   { "CPU_POPCNT_FLAGS",
 189     "CpuPOPCNT" },
 190   { "CPU_HLE_FLAGS",
 191     "CpuHLE" },
 192   { "CPU_RTM_FLAGS",
 193     "CpuRTM" },
 194   { "CPU_INVPCID_FLAGS",
 195     "CpuINVPCID" },
 196   { "CPU_VMFUNC_FLAGS",
 197     "CpuVMFUNC" },
 198   { "CPU_3DNOW_FLAGS",
 199     "CPU_MMX_FLAGS|Cpu3dnow" },
 200   { "CPU_3DNOWA_FLAGS",
 201     "CPU_3DNOW_FLAGS|Cpu3dnowA" },
 202   { "CPU_PADLOCK_FLAGS",
 203     "CpuPadLock" },
 204   { "CPU_SVME_FLAGS",
 205     "CpuSVME" },
 206   { "CPU_SSE4A_FLAGS",
 207     "CPU_SSE3_FLAGS|CpuSSE4a" },
 208   { "CPU_ABM_FLAGS",
 209     "CpuLZCNT|CpuPOPCNT" },
 210   { "CPU_AVX_FLAGS",
 211     "CPU_SSE4_2_FLAGS|CPU_XSAVE_FLAGS|CpuAVX" },
 212   { "CPU_AVX2_FLAGS",
 213     "CPU_AVX_FLAGS|CpuAVX2" },
 214   { "CPU_AVX_VNNI_FLAGS",
 215     "CPU_AVX2_FLAGS|CpuAVX_VNNI" },
 216   { "CPU_AVX512F_FLAGS",
 217     "CPU_AVX2_FLAGS|CpuAVX512F" },
 218   { "CPU_AVX512CD_FLAGS",
 219     "CPU_AVX512F_FLAGS|CpuAVX512CD" },
 220   { "CPU_AVX512ER_FLAGS",
 221     "CPU_AVX512F_FLAGS|CpuAVX512ER" },
 222   { "CPU_AVX512PF_FLAGS",
 223     "CPU_AVX512F_FLAGS|CpuAVX512PF" },
 224   { "CPU_AVX512DQ_FLAGS",
 225     "CPU_AVX512F_FLAGS|CpuAVX512DQ" },
 226   { "CPU_AVX512BW_FLAGS",
 227     "CPU_AVX512F_FLAGS|CpuAVX512BW" },
 228   { "CPU_AVX512VL_FLAGS",
 229     "CPU_AVX512F_FLAGS|CpuAVX512VL" },
 230   { "CPU_AVX512IFMA_FLAGS",
 231     "CPU_AVX512F_FLAGS|CpuAVX512IFMA" },
 232   { "CPU_AVX512VBMI_FLAGS",
 233     "CPU_AVX512F_FLAGS|CpuAVX512VBMI" },
 234   { "CPU_AVX512_4FMAPS_FLAGS",
 235     "CPU_AVX512F_FLAGS|CpuAVX512_4FMAPS" },
 236   { "CPU_AVX512_4VNNIW_FLAGS",
 237     "CPU_AVX512F_FLAGS|CpuAVX512_4VNNIW" },
 238   { "CPU_AVX512_VPOPCNTDQ_FLAGS",
 239     "CPU_AVX512F_FLAGS|CpuAVX512_VPOPCNTDQ" },
 240   { "CPU_AVX512_VBMI2_FLAGS",
 241     "CPU_AVX512F_FLAGS|CpuAVX512_VBMI2" },
 242   { "CPU_AVX512_VNNI_FLAGS",
 243     "CPU_AVX512F_FLAGS|CpuAVX512_VNNI" },
 244   { "CPU_AVX512_BITALG_FLAGS",
 245     "CPU_AVX512F_FLAGS|CpuAVX512_BITALG" },
 246   { "CPU_AVX512_BF16_FLAGS",
 247     "CPU_AVX512F_FLAGS|CpuAVX512_BF16" },
 248   { "CPU_AVX512_FP16_FLAGS",
 249     "CPU_AVX512BW_FLAGS|CpuAVX512_FP16" },
 250   { "CPU_PREFETCHI_FLAGS",
 251     "CpuPREFETCHI"},
 252   { "CPU_AVX_IFMA_FLAGS",
 253     "CPU_AVX2_FLAGS|CpuAVX_IFMA" },
 254   { "CPU_AVX_VNNI_INT8_FLAGS",
 255     "CPU_AVX2_FLAGS|CpuAVX_VNNI_INT8" },
 256   { "CPU_CMPCCXADD_FLAGS",
 257     "CpuCMPCCXADD" },
 258   { "CPU_WRMSRNS_FLAGS",
 259     "CpuWRMSRNS" },
 260   { "CPU_MSRLIST_FLAGS",
 261     "CpuMSRLIST" },
 262   { "CPU_AVX_NE_CONVERT_FLAGS",
 263     "CPU_AVX2_FLAGS|CpuAVX_NE_CONVERT" },
 264   { "CPU_RAO_INT_FLAGS",
 265     "CpuRAO_INT" },
 266   { "CPU_IAMCU_FLAGS",
 267     "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuIAMCU" },
 268   { "CPU_ADX_FLAGS",
 269     "CpuADX" },
 270   { "CPU_RDSEED_FLAGS",
 271     "CpuRdSeed" },
 272   { "CPU_PRFCHW_FLAGS",
 273     "CpuPRFCHW" },
 274   { "CPU_SMAP_FLAGS",
 275     "CpuSMAP" },
 276   { "CPU_MPX_FLAGS",
 277     "CPU_XSAVE_FLAGS|CpuMPX" },
 278   { "CPU_SHA_FLAGS",
 279     "CPU_SSE2_FLAGS|CpuSHA" },
 280   { "CPU_CLFLUSHOPT_FLAGS",
 281     "CpuClflushOpt" },
 282   { "CPU_XSAVES_FLAGS",
 283     "CPU_XSAVE_FLAGS|CpuXSAVES" },
 284   { "CPU_XSAVEC_FLAGS",
 285     "CPU_XSAVE_FLAGS|CpuXSAVEC" },
 286   { "CPU_PREFETCHWT1_FLAGS",
 287     "CpuPREFETCHWT1" },
 288   { "CPU_SE1_FLAGS",
 289     "CpuSE1" },
 290   { "CPU_CLWB_FLAGS",
 291     "CpuCLWB" },
 292   { "CPU_CLZERO_FLAGS",
 293     "CpuCLZERO" },
 294   { "CPU_MWAITX_FLAGS",
 295     "CpuMWAITX" },
 296   { "CPU_OSPKE_FLAGS",
 297     "CPU_XSAVE_FLAGS|CpuOSPKE" },
 298   { "CPU_RDPID_FLAGS",
 299     "CpuRDPID" },
 300   { "CPU_PTWRITE_FLAGS",
 301     "CpuPTWRITE" },
 302   { "CPU_IBT_FLAGS",
 303     "CpuIBT" },
 304   { "CPU_SHSTK_FLAGS",
 305     "CpuSHSTK" },
 306   { "CPU_GFNI_FLAGS",
 307     "CpuGFNI" },
 308   { "CPU_VAES_FLAGS",
 309     "CpuVAES" },
 310   { "CPU_VPCLMULQDQ_FLAGS",
 311     "CpuVPCLMULQDQ" },
 312   { "CPU_WBNOINVD_FLAGS",
 313     "CpuWBNOINVD" },
 314   { "CPU_PCONFIG_FLAGS",
 315     "CpuPCONFIG" },
 316   { "CPU_WAITPKG_FLAGS",
 317     "CpuWAITPKG" },
 318   { "CPU_UINTR_FLAGS",
 319     "CpuUINTR" },
 320   { "CPU_CLDEMOTE_FLAGS",
 321     "CpuCLDEMOTE" },
 322   { "CPU_AMX_INT8_FLAGS",
 323     "CPU_AMX_TILE_FLAGS|CpuAMX_INT8" },
 324   { "CPU_AMX_BF16_FLAGS",
 325     "CPU_AMX_TILE_FLAGS|CpuAMX_BF16" },
 326   { "CPU_AMX_FP16_FLAGS",
 327     "CPU_AMX_TILE_FLAGS|CpuAMX_FP16" },
 328   { "CPU_AMX_TILE_FLAGS",
 329     "CpuAMX_TILE" },
 330   { "CPU_MOVDIRI_FLAGS",
 331     "CpuMOVDIRI" },
 332   { "CPU_MOVDIR64B_FLAGS",
 333     "CpuMOVDIR64B" },
 334   { "CPU_ENQCMD_FLAGS",
 335     "CpuENQCMD" },
 336   { "CPU_SERIALIZE_FLAGS",
 337     "CpuSERIALIZE" },
 338   { "CPU_AVX512_VP2INTERSECT_FLAGS",
 339     "CpuAVX512_VP2INTERSECT" },
 340   { "CPU_TDX_FLAGS",
 341     "CpuTDX" },
 342   { "CPU_RDPRU_FLAGS",
 343     "CpuRDPRU" },
 344   { "CPU_MCOMMIT_FLAGS",
 345     "CpuMCOMMIT" },
 346   { "CPU_SEV_ES_FLAGS",
 347     "CpuSEV_ES" },
 348   { "CPU_TSXLDTRK_FLAGS",
 349     "CpuTSXLDTRK"},
 350   { "CPU_KL_FLAGS",
 351     "CpuKL" },
 352   { "CPU_WIDEKL_FLAGS",
 353     "CpuWideKL" },
 354   { "CPU_HRESET_FLAGS",
 355     "CpuHRESET"},
 356   { "CPU_INVLPGB_FLAGS",
 357     "CpuINVLPGB" },
 358   { "CPU_TLBSYNC_FLAGS",
 359     "CpuTLBSYNC" },
 360   { "CPU_SNP_FLAGS",
 361     "CpuSNP" },
 362   { "CPU_RMPQUERY_FLAGS",
 363     "CpuRMPQUERY" },
 364   { "CPU_ANY_X87_FLAGS",
 365     "CPU_ANY_287_FLAGS|Cpu8087" },
 366   { "CPU_ANY_287_FLAGS",
 367     "CPU_ANY_387_FLAGS|Cpu287" },
 368   { "CPU_ANY_387_FLAGS",
 369     "CPU_ANY_687_FLAGS|Cpu387" },
 370   { "CPU_ANY_687_FLAGS",
 371     "Cpu687|CpuFISTTP" },
 372   { "CPU_ANY_CMOV_FLAGS",
 373     "CpuCMOV" },
 374   { "CPU_ANY_FXSR_FLAGS",
 375     "CpuFXSR" },
 376   { "CPU_ANY_MMX_FLAGS",
 377     "CPU_3DNOWA_FLAGS" },
 378   { "CPU_ANY_SSE_FLAGS",
 379     "CPU_ANY_SSE2_FLAGS|CpuSSE" },
 380   { "CPU_ANY_SSE2_FLAGS",
 381     "CPU_ANY_SSE3_FLAGS|CpuSSE2" },
 382   { "CPU_ANY_SSE3_FLAGS",
 383     "CPU_ANY_SSSE3_FLAGS|CpuSSE3|CpuSSE4a" },
 384   { "CPU_ANY_SSSE3_FLAGS",
 385     "CPU_ANY_SSE4_1_FLAGS|CpuSSSE3" },
 386   { "CPU_ANY_SSE4_1_FLAGS",
 387     "CPU_ANY_SSE4_2_FLAGS|CpuSSE4_1" },
 388   { "CPU_ANY_SSE4_2_FLAGS",
 389     "CpuSSE4_2" },
 390   { "CPU_ANY_SSE4A_FLAGS",
 391     "CpuSSE4a" },
 392   { "CPU_ANY_AVX_FLAGS",
 393     "CPU_ANY_AVX2_FLAGS|CpuF16C|CpuFMA|CpuFMA4|CpuXOP|CpuAVX" },
 394   { "CPU_ANY_AVX2_FLAGS",
 395     "CPU_ANY_AVX512F_FLAGS|CpuAVX2|CpuAVX_VNNI|CpuAVX_IFMA|CpuAVX_VNNI_INT8|CpuAVX_NE_CONVERT" },
 396   { "CPU_ANY_AVX512F_FLAGS",
 397     "CpuAVX512F|CpuAVX512CD|CpuAVX512ER|CpuAVX512PF|CpuAVX512DQ|CPU_ANY_AVX512BW_FLAGS|CpuAVX512VL|CpuAVX512IFMA|CpuAVX512VBMI|CpuAVX512_4FMAPS|CpuAVX512_4VNNIW|CpuAVX512_VPOPCNTDQ|CpuAVX512_VBMI2|CpuAVX512_VNNI|CpuAVX512_BITALG|CpuAVX512_BF16|CpuAVX512_VP2INTERSECT" },
 398   { "CPU_ANY_AVX512CD_FLAGS",
 399     "CpuAVX512CD" },
 400   { "CPU_ANY_AVX512ER_FLAGS",
 401     "CpuAVX512ER" },
 402   { "CPU_ANY_AVX512PF_FLAGS",
 403     "CpuAVX512PF" },
 404   { "CPU_ANY_AVX512DQ_FLAGS",
 405     "CpuAVX512DQ" },
 406   { "CPU_ANY_AVX512BW_FLAGS",
 407     "CpuAVX512BW|CPU_ANY_AVX512_FP16_FLAGS" },
 408   { "CPU_ANY_AVX512VL_FLAGS",
 409     "CpuAVX512VL" },
 410   { "CPU_ANY_AVX512IFMA_FLAGS",
 411     "CpuAVX512IFMA" },
 412   { "CPU_ANY_AVX512VBMI_FLAGS",
 413     "CpuAVX512VBMI" },
 414   { "CPU_ANY_AVX512_4FMAPS_FLAGS",
 415     "CpuAVX512_4FMAPS" },
 416   { "CPU_ANY_AVX512_4VNNIW_FLAGS",
 417     "CpuAVX512_4VNNIW" },
 418   { "CPU_ANY_AVX512_VPOPCNTDQ_FLAGS",
 419     "CpuAVX512_VPOPCNTDQ" },
 420   { "CPU_ANY_IBT_FLAGS",
 421     "CpuIBT" },
 422   { "CPU_ANY_SHSTK_FLAGS",
 423     "CpuSHSTK" },
 424   { "CPU_ANY_AVX512_VBMI2_FLAGS",
 425     "CpuAVX512_VBMI2" },
 426   { "CPU_ANY_AVX512_VNNI_FLAGS",
 427     "CpuAVX512_VNNI" },
 428   { "CPU_ANY_AVX512_BITALG_FLAGS",
 429     "CpuAVX512_BITALG" },
 430   { "CPU_ANY_AVX512_BF16_FLAGS",
 431     "CpuAVX512_BF16" },
 432   { "CPU_ANY_AMX_INT8_FLAGS",
 433     "CpuAMX_INT8" },
 434   { "CPU_ANY_AMX_BF16_FLAGS",
 435     "CpuAMX_BF16" },
 436   { "CPU_ANY_AMX_TILE_FLAGS",
 437     "CpuAMX_TILE|CpuAMX_INT8|CpuAMX_BF16|CpuAMX_FP16" },
 438   { "CPU_ANY_AVX_VNNI_FLAGS",
 439     "CpuAVX_VNNI" },
 440   { "CPU_ANY_MOVDIRI_FLAGS",
 441     "CpuMOVDIRI" },
 442   { "CPU_ANY_UINTR_FLAGS",
 443     "CpuUINTR" },
 444   { "CPU_ANY_MOVDIR64B_FLAGS",
 445     "CpuMOVDIR64B" },
 446   { "CPU_ANY_ENQCMD_FLAGS",
 447     "CpuENQCMD" },
 448   { "CPU_ANY_SERIALIZE_FLAGS",
 449     "CpuSERIALIZE" },
 450   { "CPU_ANY_AVX512_VP2INTERSECT_FLAGS",
 451     "CpuAVX512_VP2INTERSECT" },
 452   { "CPU_ANY_TDX_FLAGS",
 453     "CpuTDX" },
 454   { "CPU_ANY_TSXLDTRK_FLAGS",
 455     "CpuTSXLDTRK" },
 456   { "CPU_ANY_KL_FLAGS",
 457     "CpuKL|CpuWideKL" },
 458   { "CPU_ANY_WIDEKL_FLAGS",
 459     "CpuWideKL" },
 460   { "CPU_ANY_HRESET_FLAGS",
 461     "CpuHRESET" },
 462   { "CPU_ANY_AVX512_FP16_FLAGS",
 463     "CpuAVX512_FP16" },
 464   { "CPU_ANY_AVX_IFMA_FLAGS",
 465     "CpuAVX_IFMA" },
 466   { "CPU_ANY_AVX_VNNI_INT8_FLAGS",
 467     "CpuAVX_VNNI_INT8" },
 468   { "CPU_ANY_CMPCCXADD_FLAGS",
 469     "CpuCMPCCXADD" },
 470   { "CPU_ANY_WRMSRNS_FLAGS",
 471     "CpuWRMSRNS" },
 472   { "CPU_ANY_MSRLIST_FLAGS",
 473     "CpuMSRLIST" },
 474   { "CPU_ANY_AVX_NE_CONVERT_FLAGS",
 475     "CpuAVX_NE_CONVERT" },
 476   { "CPU_ANY_RAO_INT_FLAGS",
 477     "CpuRAO_INT"},
 478 };
 479
 480 typedef struct bitfield
 481 {
 482   int position;
 483   int value;
 484   const char *name;
 485 } bitfield;
 486
 487 #define BITFIELD(n) { n, 0, #n }
 488
 489 static bitfield cpu_flags[] =
 490 {
 491   BITFIELD (Cpu186),
 492   BITFIELD (Cpu286),
 493   BITFIELD (Cpu386),
 494   BITFIELD (Cpu486),
 495   BITFIELD (Cpu586),
 496   BITFIELD (Cpu686),
 497   BITFIELD (CpuCMOV),
 498   BITFIELD (CpuFXSR),
 499   BITFIELD (CpuClflush),
 500   BITFIELD (CpuNop),
 501   BITFIELD (CpuSYSCALL),
 502   BITFIELD (Cpu8087),
 503   BITFIELD (Cpu287),
 504   BITFIELD (Cpu387),
 505   BITFIELD (Cpu687),
 506   BITFIELD (CpuFISTTP),
 507   BITFIELD (CpuMMX),
 508   BITFIELD (CpuSSE),
 509   BITFIELD (CpuSSE2),
 510   BITFIELD (CpuSSE3),
 511   BITFIELD (CpuSSSE3),
 512   BITFIELD (CpuSSE4_1),
 513   BITFIELD (CpuSSE4_2),
 514   BITFIELD (CpuAVX),
 515   BITFIELD (CpuAVX2),
 516   BITFIELD (CpuAVX512F),
 517   BITFIELD (CpuAVX512CD),
 518   BITFIELD (CpuAVX512ER),
 519   BITFIELD (CpuAVX512PF),
 520   BITFIELD (CpuAVX512VL),
 521   BITFIELD (CpuAVX512DQ),
 522   BITFIELD (CpuAVX512BW),
 523   BITFIELD (CpuIAMCU),
 524   BITFIELD (CpuSSE4a),
 525   BITFIELD (Cpu3dnow),
 526   BITFIELD (Cpu3dnowA),
 527   BITFIELD (CpuPadLock),
 528   BITFIELD (CpuSVME),
 529   BITFIELD (CpuVMX),
 530   BITFIELD (CpuSMX),
 531   BITFIELD (CpuXsave),
 532   BITFIELD (CpuXsaveopt),
 533   BITFIELD (CpuAES),
 534   BITFIELD (CpuPCLMUL),
 535   BITFIELD (CpuFMA),
 536   BITFIELD (CpuFMA4),
 537   BITFIELD (CpuXOP),
 538   BITFIELD (CpuLWP),
 539   BITFIELD (CpuBMI),
 540   BITFIELD (CpuTBM),
 541   BITFIELD (CpuLM),
 542   BITFIELD (CpuMovbe),
 543   BITFIELD (CpuCX16),
 544   BITFIELD (CpuEPT),
 545   BITFIELD (CpuRdtscp),
 546   BITFIELD (CpuFSGSBase),
 547   BITFIELD (CpuRdRnd),
 548   BITFIELD (CpuF16C),
 549   BITFIELD (CpuBMI2),
 550   BITFIELD (CpuLZCNT),
 551   BITFIELD (CpuPOPCNT),
 552   BITFIELD (CpuHLE),
 553   BITFIELD (CpuRTM),
 554   BITFIELD (CpuINVPCID),
 555   BITFIELD (CpuVMFUNC),
 556   BITFIELD (CpuRDSEED),
 557   BITFIELD (CpuADX),
 558   BITFIELD (CpuPRFCHW),
 559   BITFIELD (CpuSMAP),
 560   BITFIELD (CpuSHA),
 561   BITFIELD (CpuClflushOpt),
 562   BITFIELD (CpuXSAVES),
 563   BITFIELD (CpuXSAVEC),
 564   BITFIELD (CpuPREFETCHWT1),
 565   BITFIELD (CpuSE1),
 566   BITFIELD (CpuCLWB),
 567   BITFIELD (CpuMPX),
 568   BITFIELD (CpuAVX512IFMA),
 569   BITFIELD (CpuAVX512VBMI),
 570   BITFIELD (CpuAVX512_4FMAPS),
 571   BITFIELD (CpuAVX512_4VNNIW),
 572   BITFIELD (CpuAVX512_VPOPCNTDQ),
 573   BITFIELD (CpuAVX512_VBMI2),
 574   BITFIELD (CpuAVX512_VNNI),
 575   BITFIELD (CpuAVX512_BITALG),
 576   BITFIELD (CpuAVX512_BF16),
 577   BITFIELD (CpuAVX512_VP2INTERSECT),
 578   BITFIELD (CpuTDX),
 579   BITFIELD (CpuAVX_VNNI),
 580   BITFIELD (CpuAVX512_FP16),
 581   BITFIELD (CpuPREFETCHI),
 582   BITFIELD (CpuAVX_IFMA),
 583   BITFIELD (CpuAVX_VNNI_INT8),
 584   BITFIELD (CpuCMPCCXADD),
 585   BITFIELD (CpuWRMSRNS),
 586   BITFIELD (CpuMSRLIST),
 587   BITFIELD (CpuAVX_NE_CONVERT),
 588   BITFIELD (CpuRAO_INT),
 589   BITFIELD (CpuMWAITX),
 590   BITFIELD (CpuCLZERO),
 591   BITFIELD (CpuOSPKE),
 592   BITFIELD (CpuRDPID),
 593   BITFIELD (CpuPTWRITE),
 594   BITFIELD (CpuIBT),
 595   BITFIELD (CpuSHSTK),
 596   BITFIELD (CpuGFNI),
 597   BITFIELD (CpuVAES),
 598   BITFIELD (CpuVPCLMULQDQ),
 599   BITFIELD (CpuWBNOINVD),
 600   BITFIELD (CpuPCONFIG),
 601   BITFIELD (CpuWAITPKG),
 602   BITFIELD (CpuUINTR),
 603   BITFIELD (CpuCLDEMOTE),
 604   BITFIELD (CpuAMX_INT8),
 605   BITFIELD (CpuAMX_BF16),
 606   BITFIELD (CpuAMX_FP16),
 607   BITFIELD (CpuAMX_TILE),
 608   BITFIELD (CpuMOVDIRI),
 609   BITFIELD (CpuMOVDIR64B),
 610   BITFIELD (CpuENQCMD),
 611   BITFIELD (CpuSERIALIZE),
 612   BITFIELD (CpuRDPRU),
 613   BITFIELD (CpuMCOMMIT),
 614   BITFIELD (CpuSEV_ES),
 615   BITFIELD (CpuTSXLDTRK),
 616   BITFIELD (CpuKL),
 617   BITFIELD (CpuWideKL),
 618   BITFIELD (CpuHRESET),
 619   BITFIELD (CpuINVLPGB),
 620   BITFIELD (CpuTLBSYNC),
 621   BITFIELD (CpuSNP),
 622   BITFIELD (CpuRMPQUERY),
 623   BITFIELD (Cpu64),
 624   BITFIELD (CpuNo64),
 625 #ifdef CpuUnused
 626   BITFIELD (CpuUnused),
 627 #endif
 628 };
 629
 630 static bitfield opcode_modifiers[] =
 631 {
 632   BITFIELD (D),
 633   BITFIELD (W),
 634   BITFIELD (Load),
 635   BITFIELD (Modrm),
 636   BITFIELD (Jump),
 637   BITFIELD (FloatMF),
 638   BITFIELD (Size),
 639   BITFIELD (CheckRegSize),
 640   BITFIELD (OperandConstraint),
 641   BITFIELD (MnemonicSize),
 642   BITFIELD (No_bSuf),
 643   BITFIELD (No_wSuf),
 644   BITFIELD (No_lSuf),
 645   BITFIELD (No_sSuf),
 646   BITFIELD (No_qSuf),
 647   BITFIELD (FWait),
 648   BITFIELD (IsString),
 649   BITFIELD (RegMem),
 650   BITFIELD (BNDPrefixOk),
 651   BITFIELD (PrefixOk),
 652   BITFIELD (IsPrefix),
 653   BITFIELD (ImmExt),
 654   BITFIELD (NoRex64),
 655   BITFIELD (Vex),
 656   BITFIELD (VexVVVV),
 657   BITFIELD (VexW),
 658   BITFIELD (OpcodeSpace),
 659   BITFIELD (OpcodePrefix),
 660   BITFIELD (VexSources),
 661   BITFIELD (SIB),
 662   BITFIELD (SSE2AVX),
 663   BITFIELD (EVex),
 664   BITFIELD (Masking),
 665   BITFIELD (Broadcast),
 666   BITFIELD (StaticRounding),
 667   BITFIELD (SAE),
 668   BITFIELD (Disp8MemShift),
 669   BITFIELD (Optimize),
 670   BITFIELD (ATTMnemonic),
 671   BITFIELD (ATTSyntax),
 672   BITFIELD (IntelSyntax),
 673   BITFIELD (ISA64),
 674 };
 675
 676 #define CLASS(n) #n, n
 677
 678 static const struct {
 679   const char *name;
 680   enum operand_class value;
 681 } operand_classes[] = {
 682   CLASS (Reg),
 683   CLASS (SReg),
 684   CLASS (RegCR),
 685   CLASS (RegDR),
 686   CLASS (RegTR),
 687   CLASS (RegMMX),
 688   CLASS (RegSIMD),
 689   CLASS (RegMask),
 690   CLASS (RegBND),
 691 };
 692
 693 #undef CLASS
 694
 695 #define INSTANCE(n) #n, n
 696
 697 static const struct {
 698   const char *name;
 699   enum operand_instance value;
 700 } operand_instances[] = {
 701     INSTANCE (Accum),
 702     INSTANCE (RegC),
 703     INSTANCE (RegD),
 704     INSTANCE (RegB),
 705 };
 706
 707 #undef INSTANCE
 708
 709 static bitfield operand_types[] =
 710 {
 711   BITFIELD (Imm1),
 712   BITFIELD (Imm8),
 713   BITFIELD (Imm8S),
 714   BITFIELD (Imm16),
 715   BITFIELD (Imm32),
 716   BITFIELD (Imm32S),
 717   BITFIELD (Imm64),
 718   BITFIELD (BaseIndex),
 719   BITFIELD (Disp8),
 720   BITFIELD (Disp16),
 721   BITFIELD (Disp32),
 722   BITFIELD (Disp64),
 723   BITFIELD (Byte),
 724   BITFIELD (Word),
 725   BITFIELD (Dword),
 726   BITFIELD (Fword),
 727   BITFIELD (Qword),
 728   BITFIELD (Tbyte),
 729   BITFIELD (Xmmword),
 730   BITFIELD (Ymmword),
 731   BITFIELD (Zmmword),
 732   BITFIELD (Tmmword),
 733   BITFIELD (Unspecified),
 734 #ifdef OTUnused
 735   BITFIELD (OTUnused),
 736 #endif
 737 };
 738
 739 static const char *filename;
 740 static i386_cpu_flags active_cpu_flags;
 741 static int active_isstring;
 742
 743 struct template_arg {
 744   const struct template_arg *next;
 745   const char *val;
 746 };
 747
 748 struct template_instance {
 749   const struct template_instance *next;
 750   const char *name;
 751   const struct template_arg *args;
 752 };
 753
 754 struct template_param {
 755   const struct template_param *next;
 756   const char *name;
 757 };
 758
 759 struct template {
 760   struct template *next;
 761   const char *name;
 762   const struct template_instance *instances;
 763   const struct template_param *params;
 764 };
 765
 766 static struct template *templates;
 767
 768 static int
 769 compare (const void *x, const void *y)
 770 {
 771   const bitfield *xp = (const bitfield *) x;
 772   const bitfield *yp = (const bitfield *) y;
 773   return xp->position - yp->position;
 774 }
 775
 776 static void
 777 fail (const char *message, ...)
 778 {
 779   va_list args;
 780
 781   va_start (args, message);
 782   fprintf (stderr, _("%s: error: "), program_name);
 783   vfprintf (stderr, message, args);
 784   va_end (args);
 785   xexit (1);
 786 }
 787
 788 static void
 789 process_copyright (FILE *fp)
 790 {
 791   fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
 792 /* Copyright (C) 2007-2022 Free Software Foundation, Inc.\n\
 793 \n\
 794    This file is part of the GNU opcodes library.\n\
 795 \n\
 796    This library is free software; you can redistribute it and/or modify\n\
 797    it under the terms of the GNU General Public License as published by\n\
 798    the Free Software Foundation; either version 3, or (at your option)\n\
 799    any later version.\n\
 800 \n\
 801    It is distributed in the hope that it will be useful, but WITHOUT\n\
 802    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
 803    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
 804    License for more details.\n\
 805 \n\
 806    You should have received a copy of the GNU General Public License\n\
 807    along with this program; if not, write to the Free Software\n\
 808    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
 809    MA 02110-1301, USA.  */\n");
 810 }
 811
 812 /* Remove leading white spaces.  */
 813
 814 static char *
 815 remove_leading_whitespaces (char *str)
 816 {
 817   while (ISSPACE (*str))
 818     str++;
 819   return str;
 820 }
 821
 822 /* Remove trailing white spaces.  */
 823
 824 static void
 825 remove_trailing_whitespaces (char *str)
 826 {
 827   size_t last = strlen (str);
 828
 829   if (last == 0)
 830     return;
 831
 832   do
 833     {
 834       last--;
 835       if (ISSPACE (str [last]))
 836         str[last] = '\0';
 837       else
 838         break;
 839     }
 840   while (last != 0);
 841 }
 842
 843 /* Find next field separated by SEP and terminate it. Return a
 844    pointer to the one after it.  */
 845
 846 static char *
 847 next_field (char *str, char sep, char **next, char *last)
 848 {
 849   char *p;
 850
 851   p = remove_leading_whitespaces (str);
 852   for (str = p; *str != sep && *str != '\0'; str++);
 853
 854   *str = '\0';
 855   remove_trailing_whitespaces (p);
 856
 857   *next = str + 1;
 858
 859   if (p >= last)
 860     abort ();
 861
 862   return p;
 863 }
 864
 865 static void set_bitfield (char *, bitfield *, int, unsigned int, int);
 866
 867 static int
 868 set_bitfield_from_cpu_flag_init (char *f, bitfield *array, unsigned int size,
 869                                  int lineno)
 870 {
 871   char *str, *next, *last;
 872   unsigned int i;
 873
 874   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
 875     if (strcmp (cpu_flag_init[i].name, f) == 0)
 876       {
 877         /* Turn on selective bits.  */
 878         char *init = xstrdup (cpu_flag_init[i].init);
 879         last = init + strlen (init);
 880         for (next = init; next && next < last; )
 881           {
 882             str = next_field (next, '|', &next, last);
 883             if (str)
 884               set_bitfield (str, array, 1, size, lineno);
 885           }
 886         free (init);
 887         return 0;
 888       }
 889
 890   return -1;
 891 }
 892
 893 static void
 894 set_bitfield (char *f, bitfield *array, int value,
 895               unsigned int size, int lineno)
 896 {
 897   unsigned int i;
 898
 899   /* Ignore empty fields; they may result from template expansions.  */
 900   if (*f == '\0')
 901     return;
 902
 903   for (i = 0; i < size; i++)
 904     if (strcasecmp (array[i].name, f) == 0)
 905       {
 906         array[i].value = value;
 907         return;
 908       }
 909
 910   if (value)
 911     {
 912       const char *v = strchr (f, '=');
 913
 914       if (v)
 915         {
 916           size_t n = v - f;
 917           char *end;
 918
 919           for (i = 0; i < size; i++)
 920             if (strncasecmp (array[i].name, f, n) == 0)
 921               {
 922                 value = strtol (v + 1, &end, 0);
 923                 if (*end == '\0')
 924                   {
 925                     array[i].value = value;
 926                     return;
 927                   }
 928                 break;
 929               }
 930         }
 931     }
 932
 933   /* Handle CPU_XXX_FLAGS.  */
 934   if (value == 1 && !set_bitfield_from_cpu_flag_init (f, array, size, lineno))
 935     return;
 936
 937   if (lineno != -1)
 938     fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
 939   else
 940     fail (_("unknown bitfield: %s\n"), f);
 941 }
 942
 943 static void
 944 output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
 945                   int macro, const char *comma, const char *indent)
 946 {
 947   unsigned int i;
 948
 949   memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
 950
 951   fprintf (table, "%s{ { ", indent);
 952
 953   for (i = 0; i < size - 1; i++)
 954     {
 955       if (((i + 1) % 20) != 0)
 956         fprintf (table, "%d, ", flags[i].value);
 957       else
 958         fprintf (table, "%d,", flags[i].value);
 959       if (((i + 1) % 20) == 0)
 960         {
 961           /* We need \\ for macro.  */
 962           if (macro)
 963             fprintf (table, " \\\n    %s", indent);
 964           else
 965             fprintf (table, "\n    %s", indent);
 966         }
 967       if (flags[i].value)
 968         active_cpu_flags.array[i / 32] |= 1U << (i % 32);
 969     }
 970
 971   fprintf (table, "%d } }%s\n", flags[i].value, comma);
 972 }
 973
 974 static void
 975 process_i386_cpu_flag (FILE *table, char *flag, int macro,
 976                        const char *comma, const char *indent,
 977                        int lineno)
 978 {
 979   char *str, *next = flag, *last;
 980   unsigned int i;
 981   int value = 1;
 982   bitfield flags [ARRAY_SIZE (cpu_flags)];
 983
 984   /* Copy the default cpu flags.  */
 985   memcpy (flags, cpu_flags, sizeof (cpu_flags));
 986
 987   if (flag[0] == '~')
 988     {
 989       last = flag + strlen (flag);
 990
 991       if (flag[1] == '(')
 992         {
 993           last -= 1;
 994           next = flag + 2;
 995           if (*last != ')')
 996             fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
 997                   lineno, flag);
 998           *last = '\0';
 999         }
1000       else
1001         next = flag + 1;
1002
1003       /* First we turn on everything except for cpu64, cpuno64, and - if
1004          present - the padding field.  */
1005       for (i = 0; i < ARRAY_SIZE (flags); i++)
1006         if (flags[i].position < Cpu64)
1007           flags[i].value = 1;
1008
1009       /* Turn off selective bits.  */
1010       value = 0;
1011     }
1012
1013   if (strcmp (flag, "0"))
1014     {
1015       /* Turn on/off selective bits.  */
1016       last = flag + strlen (flag);
1017       for (; next && next < last; )
1018         {
1019           str = next_field (next, '|', &next, last);
1020           if (str)
1021             set_bitfield (str, flags, value, ARRAY_SIZE (flags), lineno);
1022         }
1023     }
1024
1025   output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
1026                     comma, indent);
1027 }
1028
1029 static void
1030 output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1031 {
1032   unsigned int i;
1033
1034   fprintf (table, "    { ");
1035
1036   for (i = 0; i < size - 1; i++)
1037     {
1038       if (((i + 1) % 20) != 0)
1039         fprintf (table, "%d, ", modifier[i].value);
1040       else
1041         fprintf (table, "%d,", modifier[i].value);
1042       if (((i + 1) % 20) == 0)
1043         fprintf (table, "\n      ");
1044     }
1045
1046   fprintf (table, "%d },\n", modifier[i].value);
1047 }
1048
1049 /* Returns LOG2 of element size.  */
1050 static int
1051 get_element_size (char **opnd, int lineno)
1052 {
1053   char *str, *next, *last, *op;
1054   const char *full = opnd[0];
1055   int elem_size = INT_MAX;
1056
1057   /* Find the memory operand.  */
1058   while (full != NULL && strstr(full, "BaseIndex") == NULL)
1059     full = *++opnd;
1060   if (full == NULL)
1061     fail (_("%s: %d: no memory operand\n"), filename, lineno);
1062
1063   op = xstrdup (full);
1064   last = op + strlen (op);
1065   for (next = op; next && next < last; )
1066     {
1067       str = next_field (next, '|', &next, last);
1068       if (str)
1069         {
1070           if (strcasecmp(str, "Byte") == 0)
1071             {
1072               /* The smallest element size, no need to check
1073                  further.  */
1074               elem_size = 0;
1075               break;
1076             }
1077           else if (strcasecmp(str, "Word") == 0)
1078             {
1079               if (elem_size > 1)
1080                 elem_size = 1;
1081             }
1082           else if (strcasecmp(str, "Dword") == 0)
1083             {
1084               if (elem_size > 2)
1085                 elem_size = 2;
1086             }
1087           else if (strcasecmp(str, "Qword") == 0)
1088             {
1089               if (elem_size > 3)
1090                 elem_size = 3;
1091             }
1092         }
1093     }
1094   free (op);
1095
1096   if (elem_size == INT_MAX)
1097     fail (_("%s: %d: unknown element size: %s\n"), filename, lineno, full);
1098
1099   return elem_size;
1100 }
1101
1102 static void
1103 process_i386_opcode_modifier (FILE *table, char *mod, unsigned int space,
1104                               unsigned int prefix, char **opnd, int lineno)
1105 {
1106   char *str, *next, *last;
1107   bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1108
1109   active_isstring = 0;
1110
1111   /* Copy the default opcode modifier.  */
1112   memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1113
1114   if (strcmp (mod, "0"))
1115     {
1116       unsigned int have_w = 0, bwlq_suf = 0xf;
1117
1118       last = mod + strlen (mod);
1119       for (next = mod; next && next < last; )
1120         {
1121           str = next_field (next, '|', &next, last);
1122           if (str)
1123             {
1124               int val = 1;
1125               if (strcasecmp(str, "Broadcast") == 0)
1126                 val = get_element_size (opnd, lineno) + BYTE_BROADCAST;
1127               else if (strcasecmp(str, "Disp8MemShift") == 0)
1128                 val = get_element_size (opnd, lineno);
1129
1130               set_bitfield (str, modifiers, val, ARRAY_SIZE (modifiers),
1131                             lineno);
1132               if (strcasecmp(str, "IsString") == 0)
1133                 active_isstring = 1;
1134
1135               if (strcasecmp(str, "W") == 0)
1136                 have_w = 1;
1137
1138               if (strcasecmp(str, "No_bSuf") == 0)
1139                 bwlq_suf &= ~1;
1140               if (strcasecmp(str, "No_wSuf") == 0)
1141                 bwlq_suf &= ~2;
1142               if (strcasecmp(str, "No_lSuf") == 0)
1143                 bwlq_suf &= ~4;
1144               if (strcasecmp(str, "No_qSuf") == 0)
1145                 bwlq_suf &= ~8;
1146             }
1147         }
1148
1149       if (space)
1150         {
1151           if (!modifiers[OpcodeSpace].value)
1152             modifiers[OpcodeSpace].value = space;
1153           else if (modifiers[OpcodeSpace].value != space)
1154             fail (_("%s:%d: Conflicting opcode space specifications\n"),
1155                   filename, lineno);
1156           else
1157             fprintf (stderr,
1158                      _("%s:%d: Warning: redundant opcode space specification\n"),
1159                      filename, lineno);
1160         }
1161
1162       if (prefix)
1163         {
1164           if (!modifiers[OpcodePrefix].value)
1165             modifiers[OpcodePrefix].value = prefix;
1166           else if (modifiers[OpcodePrefix].value != prefix)
1167             fail (_("%s:%d: Conflicting prefix specifications\n"),
1168                   filename, lineno);
1169           else
1170             fprintf (stderr,
1171                      _("%s:%d: Warning: redundant prefix specification\n"),
1172                      filename, lineno);
1173         }
1174
1175       if (have_w && !bwlq_suf)
1176         fail ("%s: %d: stray W modifier\n", filename, lineno);
1177       if (have_w && !(bwlq_suf & 1))
1178         fprintf (stderr, "%s: %d: W modifier without Byte operand(s)\n",
1179                  filename, lineno);
1180       if (have_w && !(bwlq_suf & ~1))
1181         fprintf (stderr,
1182                  "%s: %d: W modifier without Word/Dword/Qword operand(s)\n",
1183                  filename, lineno);
1184     }
1185   output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1186 }
1187
1188 enum stage {
1189   stage_macros,
1190   stage_opcodes,
1191   stage_registers,
1192 };
1193
1194 static void
1195 output_operand_type (FILE *table, enum operand_class class,
1196                      enum operand_instance instance,
1197                      const bitfield *types, unsigned int size,
1198                      enum stage stage, const char *indent)
1199 {
1200   unsigned int i;
1201
1202   fprintf (table, "{ { %d, %d, ", class, instance);
1203
1204   for (i = 0; i < size - 1; i++)
1205     {
1206       if (((i + 3) % 20) != 0)
1207         fprintf (table, "%d, ", types[i].value);
1208       else
1209         fprintf (table, "%d,", types[i].value);
1210       if (((i + 3) % 20) == 0)
1211         {
1212           /* We need \\ for macro.  */
1213           if (stage == stage_macros)
1214             fprintf (table, " \\\n%s", indent);
1215           else
1216             fprintf (table, "\n%s", indent);
1217         }
1218     }
1219
1220   fprintf (table, "%d } }", types[i].value);
1221 }
1222
1223 static void
1224 process_i386_operand_type (FILE *table, char *op, enum stage stage,
1225                            const char *indent, int lineno)
1226 {
1227   char *str, *next, *last;
1228   enum operand_class class = ClassNone;
1229   enum operand_instance instance = InstanceNone;
1230   bitfield types [ARRAY_SIZE (operand_types)];
1231
1232   /* Copy the default operand type.  */
1233   memcpy (types, operand_types, sizeof (types));
1234
1235   if (strcmp (op, "0"))
1236     {
1237       int baseindex = 0;
1238
1239       last = op + strlen (op);
1240       for (next = op; next && next < last; )
1241         {
1242           str = next_field (next, '|', &next, last);
1243           if (str)
1244             {
1245               unsigned int i;
1246
1247               if (!strncmp(str, "Class=", 6))
1248                 {
1249                   for (i = 0; i < ARRAY_SIZE(operand_classes); ++i)
1250                     if (!strcmp(str + 6, operand_classes[i].name))
1251                       {
1252                         class = operand_classes[i].value;
1253                         str = NULL;
1254                         break;
1255                       }
1256                 }
1257
1258               if (str && !strncmp(str, "Instance=", 9))
1259                 {
1260                   for (i = 0; i < ARRAY_SIZE(operand_instances); ++i)
1261                     if (!strcmp(str + 9, operand_instances[i].name))
1262                       {
1263                         instance = operand_instances[i].value;
1264                         str = NULL;
1265                         break;
1266                       }
1267                 }
1268             }
1269           if (str)
1270             {
1271               set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1272               if (strcasecmp(str, "BaseIndex") == 0)
1273                 baseindex = 1;
1274             }
1275         }
1276
1277       if (stage == stage_opcodes && baseindex && !active_isstring)
1278         {
1279           set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1280           if (!active_cpu_flags.bitfield.cpu64
1281               && !active_cpu_flags.bitfield.cpumpx)
1282             set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1283           set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1284         }
1285     }
1286   output_operand_type (table, class, instance, types, ARRAY_SIZE (types),
1287                        stage, indent);
1288 }
1289
1290 static void
1291 output_i386_opcode (FILE *table, const char *name, char *str,
1292                     char *last, int lineno)
1293 {
1294   unsigned int i, length, prefix = 0, space = 0;
1295   char *base_opcode, *extension_opcode, *end;
1296   char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1297   unsigned long long opcode;
1298
1299   /* Find base_opcode.  */
1300   base_opcode = next_field (str, ',', &str, last);
1301
1302   /* Find extension_opcode, if any.  */
1303   extension_opcode = strchr (base_opcode, '/');
1304   if (extension_opcode)
1305     *extension_opcode++ = '\0';
1306
1307   /* Find cpu_flags.  */
1308   cpu_flags = next_field (str, ',', &str, last);
1309
1310   /* Find opcode_modifier.  */
1311   opcode_modifier = next_field (str, ',', &str, last);
1312
1313   /* Remove the first {.  */
1314   str = remove_leading_whitespaces (str);
1315   if (*str != '{')
1316     abort ();
1317   str = remove_leading_whitespaces (str + 1);
1318   remove_trailing_whitespaces (str);
1319
1320   /* Remove } and trailing white space. */
1321   i = strlen (str);
1322   if (!i || str[i - 1] != '}')
1323     abort ();
1324   str[--i] = '\0';
1325   remove_trailing_whitespaces (str);
1326
1327   if (!*str)
1328     operand_types [i = 0] = NULL;
1329   else
1330     {
1331       last = str + strlen (str);
1332
1333       /* Find operand_types.  */
1334       for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1335         {
1336           if (str >= last)
1337             {
1338               operand_types [i] = NULL;
1339               break;
1340             }
1341
1342           operand_types [i] = next_field (str, ',', &str, last);
1343         }
1344     }
1345
1346   opcode = strtoull (base_opcode, &end, 0);
1347
1348   /* Determine opcode length.  */
1349   for (length = 1; length < 8; ++length)
1350     if (!(opcode >> (8 * length)))
1351        break;
1352
1353   /* Transform prefixes encoded in the opcode into opcode modifier
1354      representation.  */
1355   if (length > 1)
1356     {
1357       switch (opcode >> (8 * length - 8))
1358         {
1359         case 0x66: prefix = PREFIX_0X66; break;
1360         case 0xF3: prefix = PREFIX_0XF3; break;
1361         case 0xF2: prefix = PREFIX_0XF2; break;
1362         }
1363
1364       if (prefix)
1365         opcode &= (1ULL << (8 * --length)) - 1;
1366     }
1367
1368   /* Transform opcode space encoded in the opcode into opcode modifier
1369      representation.  */
1370   if (length > 1 && (opcode >> (8 * length - 8)) == 0xf)
1371     {
1372       switch ((opcode >> (8 * length - 16)) & 0xff)
1373         {
1374         default:   space = SPACE_0F;   break;
1375         case 0x38: space = SPACE_0F38; break;
1376         case 0x3A: space = SPACE_0F3A; break;
1377         }
1378
1379       if (space != SPACE_0F && --length == 1)
1380         fail (_("%s:%d: %s: unrecognized opcode encoding space\n"),
1381               filename, lineno, name);
1382       opcode &= (1ULL << (8 * --length)) - 1;
1383     }
1384
1385   if (length > 2)
1386     fail (_("%s:%d: %s: residual opcode (0x%0*llx) too large\n"),
1387           filename, lineno, name, 2 * length, opcode);
1388
1389   fprintf (table, "  { \"%s\", 0x%0*llx%s, %lu, %s,\n",
1390            name, 2 * (int)length, opcode, end, i,
1391            extension_opcode ? extension_opcode : "None");
1392
1393   process_i386_opcode_modifier (table, opcode_modifier, space, prefix,
1394                                 operand_types, lineno);
1395
1396   process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
1397
1398   fprintf (table, "    { ");
1399
1400   for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1401     {
1402       if (!operand_types[i])
1403         {
1404           if (i == 0)
1405             process_i386_operand_type (table, "0", stage_opcodes, "\t  ",
1406                                        lineno);
1407           break;
1408         }
1409
1410       if (i != 0)
1411         fprintf (table, ",\n      ");
1412
1413       process_i386_operand_type (table, operand_types[i], stage_opcodes,
1414                                  "\t  ", lineno);
1415     }
1416   fprintf (table, " } },\n");
1417 }
1418
1419 struct opcode_hash_entry
1420 {
1421   struct opcode_hash_entry *next;
1422   char *name;
1423   char *opcode;
1424   int lineno;
1425 };
1426
1427 /* Calculate the hash value of an opcode hash entry P.  */
1428
1429 static hashval_t
1430 opcode_hash_hash (const void *p)
1431 {
1432   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1433   return htab_hash_string (entry->name);
1434 }
1435
1436 /* Compare a string Q against an opcode hash entry P.  */
1437
1438 static int
1439 opcode_hash_eq (const void *p, const void *q)
1440 {
1441   struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1442   const char *name = (const char *) q;
1443   return strcmp (name, entry->name) == 0;
1444 }
1445
1446 static void
1447 parse_template (char *buf, int lineno)
1448 {
1449   char sep, *end, *name;
1450   struct template *tmpl;
1451   struct template_instance *last_inst = NULL;
1452
1453   buf = remove_leading_whitespaces (buf + 1);
1454   end = strchr (buf, ':');
1455   if (end == NULL)
1456     {
1457       struct template *prev = NULL;
1458
1459       end = strchr (buf, '>');
1460       if (end == NULL)
1461         fail ("%s: %d: missing ':' or '>'\n", filename, lineno);
1462       if (*remove_leading_whitespaces (end + 1))
1463         fail ("%s: %d: malformed template purge\n", filename, lineno);
1464       *end = '\0';
1465       remove_trailing_whitespaces (buf);
1466       /* Don't bother freeing the various structures.  */
1467       for (tmpl = templates; tmpl != NULL; tmpl = (prev = tmpl)->next)
1468         if (!strcmp (buf, tmpl->name))
1469           break;
1470       if (tmpl == NULL)
1471         fail ("%s: %d: no template '%s'\n", filename, lineno, buf);
1472       if (prev)
1473         prev->next = tmpl->next;
1474       else
1475         templates = tmpl->next;
1476       return;
1477     }
1478   *end++ = '\0';
1479   remove_trailing_whitespaces (buf);
1480
1481   if (*buf == '\0')
1482     fail ("%s: %d: missing template identifier\n", filename, lineno);
1483   tmpl = xmalloc (sizeof (*tmpl));
1484   tmpl->name = xstrdup (buf);
1485
1486   tmpl->params = NULL;
1487   do {
1488       struct template_param *param;
1489
1490       buf = remove_leading_whitespaces (end);
1491       end = strpbrk (buf, ":,");
1492       if (end == NULL)
1493         fail ("%s: %d: missing ':' or ','\n", filename, lineno);
1494
1495       sep = *end;
1496       *end++ = '\0';
1497       remove_trailing_whitespaces (buf);
1498
1499       param = xmalloc (sizeof (*param));
1500       param->name = xstrdup (buf);
1501       param->next = tmpl->params;
1502       tmpl->params = param;
1503   } while (sep == ':');
1504
1505   tmpl->instances = NULL;
1506   do {
1507       struct template_instance *inst;
1508       char *cur, *next;
1509       const struct template_param *param;
1510
1511       buf = remove_leading_whitespaces (end);
1512       end = strpbrk (buf, ",>");
1513       if (end == NULL)
1514         fail ("%s: %d: missing ',' or '>'\n", filename, lineno);
1515
1516       sep = *end;
1517       *end++ = '\0';
1518
1519       inst = xmalloc (sizeof (*inst));
1520       inst->next = NULL;
1521       inst->args = NULL;
1522
1523       cur = next_field (buf, ':', &next, end);
1524       inst->name = *cur != '$' ? xstrdup (cur) : "";
1525
1526       for (param = tmpl->params; param; param = param->next)
1527         {
1528           struct template_arg *arg = xmalloc (sizeof (*arg));
1529
1530           cur = next_field (next, ':', &next, end);
1531           if (next > end)
1532             fail ("%s: %d: missing argument for '%s'\n", filename, lineno, param->name);
1533           arg->val = xstrdup (cur);
1534           arg->next = inst->args;
1535           inst->args = arg;
1536         }
1537
1538       if (tmpl->instances)
1539         last_inst->next = inst;
1540       else
1541         tmpl->instances = inst;
1542       last_inst = inst;
1543   } while (sep == ',');
1544
1545   buf = remove_leading_whitespaces (end);
1546   if (*buf)
1547     fprintf(stderr, "%s: %d: excess characters '%s'\n",
1548             filename, lineno, buf);
1549
1550   tmpl->next = templates;
1551   templates = tmpl;
1552 }
1553
1554 static unsigned int
1555 expand_templates (char *name, const char *str, htab_t opcode_hash_table,
1556                   struct opcode_hash_entry ***opcode_array_p, int lineno)
1557 {
1558   static unsigned int idx, opcode_array_size;
1559   struct opcode_hash_entry **opcode_array = *opcode_array_p;
1560   struct opcode_hash_entry **hash_slot, **entry;
1561   char *ptr1 = strchr(name, '<'), *ptr2;
1562
1563   if (ptr1 == NULL)
1564     {
1565       /* Get the slot in hash table.  */
1566       hash_slot = (struct opcode_hash_entry **)
1567         htab_find_slot_with_hash (opcode_hash_table, name,
1568                                   htab_hash_string (name),
1569                                   INSERT);
1570
1571       if (*hash_slot == NULL)
1572         {
1573           /* It is the new one.  Put it on opcode array.  */
1574           if (idx >= opcode_array_size)
1575             {
1576               /* Grow the opcode array when needed.  */
1577               opcode_array_size += 1024;
1578               opcode_array = (struct opcode_hash_entry **)
1579                 xrealloc (opcode_array,
1580                           sizeof (*opcode_array) * opcode_array_size);
1581                 *opcode_array_p = opcode_array;
1582             }
1583
1584           opcode_array[idx] = (struct opcode_hash_entry *)
1585             xmalloc (sizeof (struct opcode_hash_entry));
1586           opcode_array[idx]->next = NULL;
1587           opcode_array[idx]->name = xstrdup (name);
1588           opcode_array[idx]->opcode = xstrdup (str);
1589           opcode_array[idx]->lineno = lineno;
1590           *hash_slot = opcode_array[idx];
1591           idx++;
1592         }
1593       else
1594         {
1595           /* Append it to the existing one.  */
1596           entry = hash_slot;
1597           while ((*entry) != NULL)
1598             entry = &(*entry)->next;
1599           *entry = (struct opcode_hash_entry *)
1600             xmalloc (sizeof (struct opcode_hash_entry));
1601           (*entry)->next = NULL;
1602           (*entry)->name = (*hash_slot)->name;
1603           (*entry)->opcode = xstrdup (str);
1604           (*entry)->lineno = lineno;
1605         }
1606     }
1607   else if ((ptr2 = strchr(ptr1 + 1, '>')) == NULL)
1608     fail ("%s: %d: missing '>'\n", filename, lineno);
1609   else
1610     {
1611       const struct template *tmpl;
1612       const struct template_instance *inst;
1613
1614       *ptr1 = '\0';
1615       ptr1 = remove_leading_whitespaces (ptr1 + 1);
1616       remove_trailing_whitespaces (ptr1);
1617
1618       *ptr2++ = '\0';
1619
1620       for ( tmpl = templates; tmpl; tmpl = tmpl->next )
1621         if (!strcmp(ptr1, tmpl->name))
1622           break;
1623       if (!tmpl)
1624         fail ("reference to unknown template '%s'\n", ptr1);
1625
1626       for (inst = tmpl->instances; inst; inst = inst->next)
1627         {
1628           char *name2 = xmalloc(strlen(name) + strlen(inst->name) + strlen(ptr2) + 1);
1629           char *str2 = xmalloc(2 * strlen(str));
1630           const char *src;
1631
1632           strcpy (name2, name);
1633           strcat (name2, inst->name);
1634           strcat (name2, ptr2);
1635
1636           for (ptr1 = str2, src = str; *src; )
1637             {
1638               const char *ident = tmpl->name, *end;
1639               const struct template_param *param;
1640               const struct template_arg *arg;
1641
1642               if ((*ptr1 = *src++) != '<')
1643                 {
1644                   ++ptr1;
1645                   continue;
1646                 }
1647               while (ISSPACE(*src))
1648                 ++src;
1649               while (*ident && *src == *ident)
1650                 ++src, ++ident;
1651               while (ISSPACE(*src))
1652                 ++src;
1653               if (*src != ':' || *ident != '\0')
1654                 {
1655                   memcpy (++ptr1, tmpl->name, ident - tmpl->name);
1656                   ptr1 += ident - tmpl->name;
1657                   continue;
1658                 }
1659               while (ISSPACE(*++src))
1660                 ;
1661
1662               end = src;
1663               while (*end != '\0' && !ISSPACE(*end) && *end != '>')
1664                 ++end;
1665
1666               for (param = tmpl->params, arg = inst->args; param;
1667                    param = param->next, arg = arg->next)
1668                 {
1669                   if (end - src == strlen (param->name)
1670                       && !memcmp (src, param->name, end - src))
1671                     {
1672                       src = end;
1673                       break;
1674                     }
1675                 }
1676
1677               if (param == NULL)
1678                 fail ("template '%s' has no parameter '%.*s'\n",
1679                       tmpl->name, (int)(end - src), src);
1680
1681               while (ISSPACE(*src))
1682                 ++src;
1683               if (*src != '>')
1684                 fail ("%s: %d: missing '>'\n", filename, lineno);
1685
1686               memcpy(ptr1, arg->val, strlen(arg->val));
1687               ptr1 += strlen(arg->val);
1688               ++src;
1689             }
1690
1691           *ptr1 = '\0';
1692
1693           expand_templates (name2, str2, opcode_hash_table, opcode_array_p,
1694                             lineno);
1695
1696           free (str2);
1697           free (name2);
1698         }
1699     }
1700
1701   return idx;
1702 }
1703
1704 static void
1705 process_i386_opcodes (FILE *table)
1706 {
1707   FILE *fp;
1708   char buf[2048];
1709   unsigned int i, j, nr;
1710   char *str, *p, *last, *name;
1711   htab_t opcode_hash_table;
1712   struct opcode_hash_entry **opcode_array = NULL;
1713   int lineno = 0, marker = 0;
1714
1715   filename = "i386-opc.tbl";
1716   fp = stdin;
1717
1718   i = 0;
1719   opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1720                                          opcode_hash_eq, NULL,
1721                                          xcalloc, free);
1722
1723   fprintf (table, "\n/* i386 opcode table.  */\n\n");
1724   fprintf (table, "static const insn_template i386_optab[] =\n{\n");
1725
1726   /* Put everything on opcode array.  */
1727   while (!feof (fp))
1728     {
1729       if (fgets (buf, sizeof (buf), fp) == NULL)
1730         break;
1731
1732       p = remove_leading_whitespaces (buf);
1733
1734       for ( ; ; )
1735         {
1736           lineno++;
1737
1738           /* Skip comments.  */
1739           str = strstr (p, "//");
1740           if (str != NULL)
1741             {
1742               str[0] = '\0';
1743               remove_trailing_whitespaces (p);
1744               break;
1745             }
1746
1747           /* Look for line continuation character.  */
1748           remove_trailing_whitespaces (p);
1749           j = strlen (buf);
1750           if (!j || buf[j - 1] != '+')
1751             break;
1752           if (j >= sizeof (buf) - 1)
1753             fail (_("%s: %d: (continued) line too long\n"), filename, lineno);
1754
1755           if (fgets (buf + j - 1, sizeof (buf) - j + 1, fp) == NULL)
1756             {
1757               fprintf (stderr, "%s: Line continuation on last line?\n",
1758                        filename);
1759               break;
1760             }
1761         }
1762
1763       switch (p[0])
1764         {
1765         case '#':
1766           if (!strcmp("### MARKER ###", buf))
1767             marker = 1;
1768           else
1769             {
1770               /* Since we ignore all included files (we only care about their
1771                  #define-s here), we don't need to monitor filenames.  The final
1772                  line number directive is going to refer to the main source file
1773                  again.  */
1774               char *end;
1775               unsigned long ln;
1776
1777               p = remove_leading_whitespaces (p + 1);
1778               if (!strncmp(p, "line", 4))
1779                 p += 4;
1780               ln = strtoul (p, &end, 10);
1781               if (ln > 1 && ln < INT_MAX
1782                   && *remove_leading_whitespaces (end) == '"')
1783                 lineno = ln - 1;
1784             }
1785           /* Ignore comments.  */
1786         case '\0':
1787           continue;
1788           break;
1789         case '<':
1790           parse_template (p, lineno);
1791           continue;
1792         default:
1793           if (!marker)
1794             continue;
1795           break;
1796         }
1797
1798       last = p + strlen (p);
1799
1800       /* Find name.  */
1801       name = next_field (p, ',', &str, last);
1802
1803       i = expand_templates (name, str, opcode_hash_table, &opcode_array,
1804                             lineno);
1805     }
1806
1807   /* Process opcode array.  */
1808   for (j = 0; j < i; j++)
1809     {
1810       struct opcode_hash_entry *next;
1811
1812       for (next = opcode_array[j]; next; next = next->next)
1813         {
1814           name = next->name;
1815           str = next->opcode;
1816           lineno = next->lineno;
1817           last = str + strlen (str);
1818           output_i386_opcode (table, name, str, last, lineno);
1819         }
1820     }
1821
1822   fclose (fp);
1823
1824   fprintf (table, "};\n");
1825
1826   /* Generate opcode sets array.  */
1827   fprintf (table, "\n/* i386 opcode sets table.  */\n\n");
1828   fprintf (table, "static const insn_template *const i386_op_sets[] =\n{\n");
1829   fprintf (table, "  i386_optab,\n");
1830
1831   for (nr = j = 0; j < i; j++)
1832     {
1833       struct opcode_hash_entry *next = opcode_array[j];
1834
1835       do
1836         {
1837           ++nr;
1838           next = next->next;
1839         }
1840       while (next);
1841       fprintf (table, "  i386_optab + %u,\n", nr);
1842     }
1843
1844   fprintf (table, "};\n");
1845 }
1846
1847 static void
1848 process_i386_registers (FILE *table)
1849 {
1850   FILE *fp;
1851   char buf[2048];
1852   char *str, *p, *last;
1853   char *reg_name, *reg_type, *reg_flags, *reg_num;
1854   char *dw2_32_num, *dw2_64_num;
1855   int lineno = 0;
1856
1857   filename = "i386-reg.tbl";
1858   fp = fopen (filename, "r");
1859   if (fp == NULL)
1860     fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1861           xstrerror (errno));
1862
1863   fprintf (table, "\n/* i386 register table.  */\n\n");
1864   fprintf (table, "static const reg_entry i386_regtab[] =\n{\n");
1865
1866   while (!feof (fp))
1867     {
1868       if (fgets (buf, sizeof (buf), fp) == NULL)
1869         break;
1870
1871       lineno++;
1872
1873       p = remove_leading_whitespaces (buf);
1874
1875       /* Skip comments.  */
1876       str = strstr (p, "//");
1877       if (str != NULL)
1878         str[0] = '\0';
1879
1880       /* Remove trailing white spaces.  */
1881       remove_trailing_whitespaces (p);
1882
1883       switch (p[0])
1884         {
1885         case '#':
1886           fprintf (table, "%s\n", p);
1887         case '\0':
1888           continue;
1889           break;
1890         default:
1891           break;
1892         }
1893
1894       last = p + strlen (p);
1895
1896       /* Find reg_name.  */
1897       reg_name = next_field (p, ',', &str, last);
1898
1899       /* Find reg_type.  */
1900       reg_type = next_field (str, ',', &str, last);
1901
1902       /* Find reg_flags.  */
1903       reg_flags = next_field (str, ',', &str, last);
1904
1905       /* Find reg_num.  */
1906       reg_num = next_field (str, ',', &str, last);
1907
1908       fprintf (table, "  { \"%s\",\n    ", reg_name);
1909
1910       process_i386_operand_type (table, reg_type, stage_registers, "\t",
1911                                  lineno);
1912
1913       /* Find 32-bit Dwarf2 register number.  */
1914       dw2_32_num = next_field (str, ',', &str, last);
1915
1916       /* Find 64-bit Dwarf2 register number.  */
1917       dw2_64_num = next_field (str, ',', &str, last);
1918
1919       fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
1920                reg_flags, reg_num, dw2_32_num, dw2_64_num);
1921     }
1922
1923   fclose (fp);
1924
1925   fprintf (table, "};\n");
1926
1927   fprintf (table, "\nstatic const unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1928 }
1929
1930 static void
1931 process_i386_initializers (void)
1932 {
1933   unsigned int i;
1934   FILE *fp = fopen ("i386-init.h", "w");
1935   char *init;
1936
1937   if (fp == NULL)
1938     fail (_("can't create i386-init.h, errno = %s\n"),
1939           xstrerror (errno));
1940
1941   process_copyright (fp);
1942
1943   for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1944     {
1945       fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1946       init = xstrdup (cpu_flag_init[i].init);
1947       process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
1948       free (init);
1949     }
1950
1951   fprintf (fp, "\n");
1952
1953   fclose (fp);
1954 }
1955
1956 /* Program options.  */
1957 #define OPTION_SRCDIR   200
1958
1959 struct option long_options[] =
1960 {
1961   {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
1962   {"debug",   no_argument,       NULL, 'd'},
1963   {"version", no_argument,       NULL, 'V'},
1964   {"help",    no_argument,       NULL, 'h'},
1965   {0,         no_argument,       NULL, 0}
1966 };
1967
1968 static void
1969 print_version (void)
1970 {
1971   printf ("%s: version 1.0\n", program_name);
1972   xexit (0);
1973 }
1974
1975 static void
1976 usage (FILE * stream, int status)
1977 {
1978   fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1979            program_name);
1980   xexit (status);
1981 }
1982
1983 int
1984 main (int argc, char **argv)
1985 {
1986   extern int chdir (char *);
1987   char *srcdir = NULL;
1988   int c;
1989   unsigned int i, cpumax;
1990   FILE *table;
1991
1992   program_name = *argv;
1993   xmalloc_set_program_name (program_name);
1994
1995   while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1996     switch (c)
1997       {
1998       case OPTION_SRCDIR:
1999         srcdir = optarg;
2000         break;
2001       case 'V':
2002       case 'v':
2003         print_version ();
2004         break;
2005       case 'd':
2006         debug = 1;
2007         break;
2008       case 'h':
2009       case '?':
2010         usage (stderr, 0);
2011       default:
2012       case 0:
2013         break;
2014       }
2015
2016   if (optind != argc)
2017     usage (stdout, 1);
2018
2019   if (srcdir != NULL)
2020     if (chdir (srcdir) != 0)
2021       fail (_("unable to change directory to \"%s\", errno = %s\n"),
2022             srcdir, xstrerror (errno));
2023
2024   /* cpu_flags isn't sorted by position.  */
2025   cpumax = 0;
2026   for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
2027     if (cpu_flags[i].position > cpumax)
2028       cpumax = cpu_flags[i].position;
2029
2030   /* Check the unused bitfield in i386_cpu_flags.  */
2031 #ifdef CpuUnused
2032   static_assert (ARRAY_SIZE (cpu_flags) == CpuMax + 2);
2033
2034   if ((cpumax - 1) != CpuMax)
2035     fail (_("CpuMax != %d!\n"), cpumax);
2036 #else
2037   static_assert (ARRAY_SIZE (cpu_flags) == CpuMax + 1);
2038
2039   if (cpumax != CpuMax)
2040     fail (_("CpuMax != %d!\n"), cpumax);
2041
2042   c = CpuNumOfBits - CpuMax - 1;
2043   if (c)
2044     fail (_("%d unused bits in i386_cpu_flags.\n"), c);
2045 #endif
2046
2047   static_assert (ARRAY_SIZE (opcode_modifiers) == Opcode_Modifier_Num);
2048
2049   /* Check the unused bitfield in i386_operand_type.  */
2050 #ifdef OTUnused
2051   static_assert (ARRAY_SIZE (operand_types) + CLASS_WIDTH + INSTANCE_WIDTH
2052                  == OTNum + 1);
2053 #else
2054   static_assert (ARRAY_SIZE (operand_types) + CLASS_WIDTH + INSTANCE_WIDTH
2055                  == OTNum);
2056
2057   c = OTNumOfBits - OTNum;
2058   if (c)
2059     fail (_("%d unused bits in i386_operand_type.\n"), c);
2060 #endif
2061
2062   qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
2063          compare);
2064
2065   qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
2066          sizeof (opcode_modifiers [0]), compare);
2067
2068   qsort (operand_types, ARRAY_SIZE (operand_types),
2069          sizeof (operand_types [0]), compare);
2070
2071   table = fopen ("i386-tbl.h", "w");
2072   if (table == NULL)
2073     fail (_("can't create i386-tbl.h, errno = %s\n"),
2074           xstrerror (errno));
2075
2076   process_copyright (table);
2077
2078   process_i386_opcodes (table);
2079   process_i386_registers (table);
2080   process_i386_initializers ();
2081
2082   fclose (table);
2083
2084   exit (0);
2085 }