opcodes/i386-gen.c

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