opcodes/i386-gen.c

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