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