opcodes/i386-gen.c

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