opcodes/i386-gen.c

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