opcodes/i386-gen.c

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