Rework patch to check by both armap entry and archive offset. Also,
[binutils.git] / opcodes / i386-gen.c
blobddac29205b18a5de422a58cd2fabaa6ec9266791
1 /* Copyright 2007 Free Software Foundation, Inc.
3 This file is part of the GNU opcodes library.
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.
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.
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. */
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"
27 #include "i386-opc.h"
29 #include <libintl.h>
30 #define _(String) gettext (String)
32 static const char *program_name = NULL;
33 static int debug = 0;
35 typedef struct initializer
37 const char *name;
38 const char *init;
39 } initializer;
41 static initializer cpu_flag_init [] =
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"}
115 static initializer operand_type_init [] =
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" },
207 typedef struct bitfield
209 int position;
210 int value;
211 const char *name;
212 } bitfield;
214 #define BITFIELD(n) { n, 0, #n }
216 static bitfield cpu_flags[] =
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 (CpuABM),
243 BITFIELD (CpuLM),
244 BITFIELD (Cpu64),
245 BITFIELD (CpuNo64),
246 #ifdef CpuUnused
247 BITFIELD (CpuUnused),
248 #endif
251 static bitfield opcode_modifiers[] =
253 BITFIELD (D),
254 BITFIELD (W),
255 BITFIELD (Modrm),
256 BITFIELD (ShortForm),
257 BITFIELD (Jump),
258 BITFIELD (JumpDword),
259 BITFIELD (JumpByte),
260 BITFIELD (JumpInterSegment),
261 BITFIELD (FloatMF),
262 BITFIELD (FloatR),
263 BITFIELD (FloatD),
264 BITFIELD (Size16),
265 BITFIELD (Size32),
266 BITFIELD (Size64),
267 BITFIELD (IgnoreSize),
268 BITFIELD (DefaultSize),
269 BITFIELD (No_bSuf),
270 BITFIELD (No_wSuf),
271 BITFIELD (No_lSuf),
272 BITFIELD (No_sSuf),
273 BITFIELD (No_qSuf),
274 BITFIELD (No_xSuf),
275 BITFIELD (FWait),
276 BITFIELD (IsString),
277 BITFIELD (RegKludge),
278 BITFIELD (IsPrefix),
279 BITFIELD (ImmExt),
280 BITFIELD (NoRex64),
281 BITFIELD (Rex64),
282 BITFIELD (Ugh),
283 BITFIELD (Drex),
284 BITFIELD (Drexv),
285 BITFIELD (Drexc),
288 static bitfield operand_types[] =
290 BITFIELD (Reg8),
291 BITFIELD (Reg16),
292 BITFIELD (Reg32),
293 BITFIELD (Reg64),
294 BITFIELD (FloatReg),
295 BITFIELD (RegMMX),
296 BITFIELD (RegXMM),
297 BITFIELD (Imm8),
298 BITFIELD (Imm8S),
299 BITFIELD (Imm16),
300 BITFIELD (Imm32),
301 BITFIELD (Imm32S),
302 BITFIELD (Imm64),
303 BITFIELD (Imm1),
304 BITFIELD (BaseIndex),
305 BITFIELD (Disp8),
306 BITFIELD (Disp16),
307 BITFIELD (Disp32),
308 BITFIELD (Disp32S),
309 BITFIELD (Disp64),
310 BITFIELD (InOutPortReg),
311 BITFIELD (ShiftCount),
312 BITFIELD (Control),
313 BITFIELD (Debug),
314 BITFIELD (Test),
315 BITFIELD (SReg2),
316 BITFIELD (SReg3),
317 BITFIELD (Acc),
318 BITFIELD (FloatAcc),
319 BITFIELD (JumpAbsolute),
320 BITFIELD (EsSeg),
321 BITFIELD (RegMem),
322 #ifdef OTUnused
323 BITFIELD (OTUnused),
324 #endif
327 static int
328 compare (const void *x, const void *y)
330 const bitfield *xp = (const bitfield *) x;
331 const bitfield *yp = (const bitfield *) y;
332 return xp->position - yp->position;
335 static void
336 fail (const char *message, ...)
338 va_list args;
340 va_start (args, message);
341 fprintf (stderr, _("%s: Error: "), program_name);
342 vfprintf (stderr, message, args);
343 va_end (args);
344 xexit (1);
347 static void
348 process_copyright (FILE *fp)
350 fprintf (fp, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
351 /* Copyright 2007 Free Software Foundation, Inc.\n\
353 This file is part of the GNU opcodes library.\n\
355 This library is free software; you can redistribute it and/or modify\n\
356 it under the terms of the GNU General Public License as published by\n\
357 the Free Software Foundation; either version 3, or (at your option)\n\
358 any later version.\n\
360 It is distributed in the hope that it will be useful, but WITHOUT\n\
361 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
362 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
363 License for more details.\n\
365 You should have received a copy of the GNU General Public License\n\
366 along with this program; if not, write to the Free Software\n\
367 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
368 MA 02110-1301, USA. */\n");
371 /* Remove leading white spaces. */
373 static char *
374 remove_leading_whitespaces (char *str)
376 while (ISSPACE (*str))
377 str++;
378 return str;
381 /* Remove trailing white spaces. */
383 static void
384 remove_trailing_whitespaces (char *str)
386 size_t last = strlen (str);
388 if (last == 0)
389 return;
393 last--;
394 if (ISSPACE (str [last]))
395 str[last] = '\0';
396 else
397 break;
399 while (last != 0);
402 /* Find next field separated by SEP and terminate it. Return a
403 pointer to the one after it. */
405 static char *
406 next_field (char *str, char sep, char **next)
408 char *p;
410 p = remove_leading_whitespaces (str);
411 for (str = p; *str != sep && *str != '\0'; str++);
413 *str = '\0';
414 remove_trailing_whitespaces (p);
416 *next = str + 1;
418 return p;
421 static void
422 set_bitfield (const char *f, bitfield *array, unsigned int size)
424 unsigned int i;
426 if (strcmp (f, "CpuSledgehammer") == 0)
427 f= "CpuK8";
429 for (i = 0; i < size; i++)
430 if (strcasecmp (array[i].name, f) == 0)
432 array[i].value = 1;
433 return;
436 printf ("Unknown bitfield: %s\n", f);
437 abort ();
440 static void
441 output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
442 int macro, const char *comma, const char *indent)
444 unsigned int i;
446 fprintf (table, "%s{ { ", indent);
448 for (i = 0; i < size - 1; i++)
450 fprintf (table, "%d, ", flags[i].value);
451 if (((i + 1) % 20) == 0)
453 /* We need \\ for macro. */
454 if (macro)
455 fprintf (table, " \\\n %s", indent);
456 else
457 fprintf (table, "\n %s", indent);
461 fprintf (table, "%d } }%s\n", flags[i].value, comma);
464 static void
465 process_i386_cpu_flag (FILE *table, char *flag, int macro,
466 const char *comma, const char *indent)
468 char *str, *next, *last;
469 bitfield flags [ARRAY_SIZE (cpu_flags)];
471 /* Copy the default cpu flags. */
472 memcpy (flags, cpu_flags, sizeof (cpu_flags));
474 if (strcasecmp (flag, "unknown") == 0)
476 unsigned int i;
478 /* We turn on everything except for cpu64 in case of
479 CPU_UNKNOWN_FLAGS. */
480 for (i = 0; i < ARRAY_SIZE (flags); i++)
481 if (flags[i].position != Cpu64)
482 flags[i].value = 1;
484 else if (strcmp (flag, "0"))
486 last = flag + strlen (flag);
487 for (next = flag; next && next < last; )
489 str = next_field (next, '|', &next);
490 if (str)
491 set_bitfield (str, flags, ARRAY_SIZE (flags));
495 output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
496 comma, indent);
499 static void
500 output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
502 unsigned int i;
504 fprintf (table, " { ");
506 for (i = 0; i < size - 1; i++)
508 fprintf (table, "%d, ", modifier[i].value);
509 if (((i + 1) % 20) == 0)
510 fprintf (table, "\n ");
513 fprintf (table, "%d },\n", modifier[i].value);
516 static void
517 process_i386_opcode_modifier (FILE *table, char *mod)
519 char *str, *next, *last;
520 bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
522 /* Copy the default opcode modifier. */
523 memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
525 if (strcmp (mod, "0"))
527 last = mod + strlen (mod);
528 for (next = mod; next && next < last; )
530 str = next_field (next, '|', &next);
531 if (str)
532 set_bitfield (str, modifiers, ARRAY_SIZE (modifiers));
535 output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
538 static void
539 output_operand_type (FILE *table, bitfield *types, unsigned int size,
540 int macro, const char *indent)
542 unsigned int i;
544 fprintf (table, "{ { ");
546 for (i = 0; i < size - 1; i++)
548 fprintf (table, "%d, ", types[i].value);
549 if (((i + 1) % 20) == 0)
551 /* We need \\ for macro. */
552 if (macro)
553 fprintf (table, "\\\n%s", indent);
554 else
555 fprintf (table, "\n%s", indent);
559 fprintf (table, "%d } }", types[i].value);
562 static void
563 process_i386_operand_type (FILE *table, char *op, int macro,
564 const char *indent)
566 char *str, *next, *last;
567 bitfield types [ARRAY_SIZE (operand_types)];
569 /* Copy the default operand type. */
570 memcpy (types, operand_types, sizeof (types));
572 if (strcmp (op, "0"))
574 last = op + strlen (op);
575 for (next = op; next && next < last; )
577 str = next_field (next, '|', &next);
578 if (str)
579 set_bitfield (str, types, ARRAY_SIZE (types));
582 output_operand_type (table, types, ARRAY_SIZE (types), macro,
583 indent);
586 static void
587 process_i386_opcodes (FILE *table)
589 FILE *fp = fopen ("i386-opc.tbl", "r");
590 char buf[2048];
591 unsigned int i;
592 char *str, *p, *last;
593 char *name, *operands, *base_opcode, *extension_opcode;
594 char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
596 if (fp == NULL)
597 fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
598 xstrerror (errno));
600 fprintf (table, "\n/* i386 opcode table. */\n\n");
601 fprintf (table, "const template i386_optab[] =\n{\n");
603 while (!feof (fp))
605 if (fgets (buf, sizeof (buf), fp) == NULL)
606 break;
608 p = remove_leading_whitespaces (buf);
610 /* Skip comments. */
611 str = strstr (p, "//");
612 if (str != NULL)
613 str[0] = '\0';
615 /* Remove trailing white spaces. */
616 remove_trailing_whitespaces (p);
618 switch (p[0])
620 case '#':
621 fprintf (table, "%s\n", p);
622 case '\0':
623 continue;
624 break;
625 default:
626 break;
629 last = p + strlen (p);
631 /* Find name. */
632 name = next_field (p, ',', &str);
634 if (str >= last)
635 abort ();
637 /* Find number of operands. */
638 operands = next_field (str, ',', &str);
640 if (str >= last)
641 abort ();
643 /* Find base_opcode. */
644 base_opcode = next_field (str, ',', &str);
646 if (str >= last)
647 abort ();
649 /* Find extension_opcode. */
650 extension_opcode = next_field (str, ',', &str);
652 if (str >= last)
653 abort ();
655 /* Find cpu_flags. */
656 cpu_flags = next_field (str, ',', &str);
658 if (str >= last)
659 abort ();
661 /* Find opcode_modifier. */
662 opcode_modifier = next_field (str, ',', &str);
664 if (str >= last)
665 abort ();
667 /* Remove the first {. */
668 str = remove_leading_whitespaces (str);
669 if (*str != '{')
670 abort ();
671 str = remove_leading_whitespaces (str + 1);
673 i = strlen (str);
675 /* There are at least "X}". */
676 if (i < 2)
677 abort ();
679 /* Remove trailing white spaces and }. */
682 i--;
683 if (ISSPACE (str[i]) || str[i] == '}')
684 str[i] = '\0';
685 else
686 break;
688 while (i != 0);
690 last = str + i;
692 /* Find operand_types. */
693 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
695 if (str >= last)
697 operand_types [i] = NULL;
698 break;
701 operand_types [i] = next_field (str, ',', &str);
702 if (*operand_types[i] == '0')
704 if (i != 0)
705 operand_types[i] = NULL;
706 break;
710 fprintf (table, " { \"%s\", %s, %s, %s,\n",
711 name, operands, base_opcode, extension_opcode);
713 process_i386_cpu_flag (table, cpu_flags, 0, ",", " ");
715 process_i386_opcode_modifier (table, opcode_modifier);
717 fprintf (table, " { ");
719 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
721 if (operand_types[i] == NULL
722 || *operand_types[i] == '0')
724 if (i == 0)
725 process_i386_operand_type (table, "0", 0, "\t ");
726 break;
729 if (i != 0)
730 fprintf (table, ",\n ");
732 process_i386_operand_type (table, operand_types[i], 0,
733 "\t ");
735 fprintf (table, " } },\n");
738 fclose (fp);
740 fprintf (table, " { NULL, 0, 0, 0,\n");
742 process_i386_cpu_flag (table, "0", 0, ",", " ");
744 process_i386_opcode_modifier (table, "0");
746 fprintf (table, " { ");
747 process_i386_operand_type (table, "0", 0, "\t ");
748 fprintf (table, " } }\n");
750 fprintf (table, "};\n");
753 static void
754 process_i386_registers (FILE *table)
756 FILE *fp = fopen ("i386-reg.tbl", "r");
757 char buf[2048];
758 char *str, *p, *last;
759 char *reg_name, *reg_type, *reg_flags, *reg_num;
761 if (fp == NULL)
762 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
763 xstrerror (errno));
765 fprintf (table, "\n/* i386 register table. */\n\n");
766 fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
768 while (!feof (fp))
770 if (fgets (buf, sizeof (buf), fp) == NULL)
771 break;
773 p = remove_leading_whitespaces (buf);
775 /* Skip comments. */
776 str = strstr (p, "//");
777 if (str != NULL)
778 str[0] = '\0';
780 /* Remove trailing white spaces. */
781 remove_trailing_whitespaces (p);
783 switch (p[0])
785 case '#':
786 fprintf (table, "%s\n", p);
787 case '\0':
788 continue;
789 break;
790 default:
791 break;
794 last = p + strlen (p);
796 /* Find reg_name. */
797 reg_name = next_field (p, ',', &str);
799 if (str >= last)
800 abort ();
802 /* Find reg_type. */
803 reg_type = next_field (str, ',', &str);
805 if (str >= last)
806 abort ();
808 /* Find reg_flags. */
809 reg_flags = next_field (str, ',', &str);
811 if (str >= last)
812 abort ();
814 /* Find reg_num. */
815 reg_num = next_field (str, ',', &str);
817 fprintf (table, " { \"%s\",\n ", reg_name);
819 process_i386_operand_type (table, reg_type, 0, "\t");
821 fprintf (table, ",\n %s, %s },\n", reg_flags, reg_num);
824 fclose (fp);
826 fprintf (table, "};\n");
828 fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
831 static void
832 process_i386_initializers (void)
834 unsigned int i;
835 FILE *fp = fopen ("i386-init.h", "w");
836 char *init;
838 if (fp == NULL)
839 fail (_("can't create i386-init.h, errno = %s\n"),
840 xstrerror (errno));
842 process_copyright (fp);
844 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
846 fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
847 init = xstrdup (cpu_flag_init[i].init);
848 process_i386_cpu_flag (fp, init, 1, "", " ");
849 free (init);
852 for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
854 fprintf (fp, "\n\n#define %s \\\n ", operand_type_init[i].name);
855 init = xstrdup (operand_type_init[i].init);
856 process_i386_operand_type (fp, init, 1, " ");
857 free (init);
859 fprintf (fp, "\n");
861 fclose (fp);
864 /* Program options. */
865 #define OPTION_SRCDIR 200
867 struct option long_options[] =
869 {"srcdir", required_argument, NULL, OPTION_SRCDIR},
870 {"debug", no_argument, NULL, 'd'},
871 {"version", no_argument, NULL, 'V'},
872 {"help", no_argument, NULL, 'h'},
873 {0, no_argument, NULL, 0}
876 static void
877 print_version (void)
879 printf ("%s: version 1.0\n", program_name);
880 xexit (0);
883 static void
884 usage (FILE * stream, int status)
886 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
887 program_name);
888 xexit (status);
892 main (int argc, char **argv)
894 extern int chdir (char *);
895 char *srcdir = NULL;
896 int c;
897 FILE *table;
899 program_name = *argv;
900 xmalloc_set_program_name (program_name);
902 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
903 switch (c)
905 case OPTION_SRCDIR:
906 srcdir = optarg;
907 break;
908 case 'V':
909 case 'v':
910 print_version ();
911 break;
912 case 'd':
913 debug = 1;
914 break;
915 case 'h':
916 case '?':
917 usage (stderr, 0);
918 default:
919 case 0:
920 break;
923 if (optind != argc)
924 usage (stdout, 1);
926 if (srcdir != NULL)
927 if (chdir (srcdir) != 0)
928 fail (_("unable to change directory to \"%s\", errno = %s\n"),
929 srcdir, xstrerror (errno));
931 /* Check the unused bitfield in i386_cpu_flags. */
932 #ifndef CpuUnused
933 c = CpuNumOfBits - CpuMax - 1;
934 if (c)
935 fail (_("%d unused bits in i386_cpu_flags.\n"), c);
936 #endif
938 /* Check the unused bitfield in i386_operand_type. */
939 #ifndef OTUnused
940 c = OTNumOfBits - OTMax - 1;
941 if (c)
942 fail (_("%d unused bits in i386_operand_type.\n"), c);
943 #endif
945 qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
946 compare);
948 qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
949 sizeof (opcode_modifiers [0]), compare);
951 qsort (operand_types, ARRAY_SIZE (operand_types),
952 sizeof (operand_types [0]), compare);
954 table = fopen ("i386-tbl.h", "w");
955 if (table == NULL)
956 fail (_("can't create i386-tbl.h, errno = %s\n"),
957 xstrerror (errno));
959 process_copyright (table);
961 process_i386_opcodes (table);
962 process_i386_registers (table);
963 process_i386_initializers ();
965 fclose (table);
967 exit (0);