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