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