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