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