opcodes/i386-gen.c

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