opcodes/i386-gen.c

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