opcodes/i386-gen.c

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