opcodes/i386-gen.c

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