1 /* Copyright (C) 2007-2020 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)
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. */
24 #include "libiberty.h"
26 #include "safe-ctype.h"
31 #define _(String) gettext (String)
33 /* Build-time checks are preferrable over runtime ones. Use this construct
34 in preference where possible. */
35 #define static_assert(e) ((void)sizeof (struct { int _:1 - 2 * !(e); }))
37 static const char *program_name
= NULL
;
40 typedef struct initializer
46 static initializer cpu_flag_init
[] =
48 { "CPU_UNKNOWN_FLAGS",
49 "~(CpuL1OM|CpuK1OM)" },
50 { "CPU_GENERIC32_FLAGS",
51 "Cpu186|Cpu286|Cpu386" },
52 { "CPU_GENERIC64_FLAGS",
53 "CPU_PENTIUMPRO_FLAGS|CpuClflush|CpuSYSCALL|CPU_MMX_FLAGS|CPU_SSE2_FLAGS|CpuLM" },
59 "CPU_I186_FLAGS|Cpu286" },
61 "CPU_I286_FLAGS|Cpu386" },
63 "CPU_I386_FLAGS|Cpu486" },
65 "CPU_I486_FLAGS|Cpu387|Cpu586" },
67 "CPU_I586_FLAGS|Cpu686|Cpu687|CpuCMOV|CpuFXSR" },
68 { "CPU_PENTIUMPRO_FLAGS",
69 "CPU_I686_FLAGS|CpuNop" },
71 "CPU_PENTIUMPRO_FLAGS|CPU_MMX_FLAGS" },
73 "CPU_P2_FLAGS|CPU_SSE_FLAGS" },
75 "CPU_P3_FLAGS|CpuClflush|CPU_SSE2_FLAGS" },
77 "CPU_GENERIC64_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
79 "CPU_P4_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
81 "CPU_NOCONA_FLAGS|CPU_SSSE3_FLAGS" },
83 "CPU_CORE2_FLAGS|CPU_SSE4_2_FLAGS|CpuRdtscp" },
85 "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CPU_MMX_FLAGS" },
87 "CPU_K6_FLAGS|Cpu3dnow" },
89 "CPU_K6_2_FLAGS|Cpu686|Cpu687|CpuNop|Cpu3dnowA" },
91 "CPU_ATHLON_FLAGS|CpuRdtscp|CPU_SSE2_FLAGS|CpuLM" },
92 { "CPU_AMDFAM10_FLAGS",
93 "CPU_K8_FLAGS|CpuFISTTP|CPU_SSE4A_FLAGS|CpuABM" },
95 "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuRdtscp|CpuCX16|CPU_XOP_FLAGS|CpuABM|CpuLWP|CpuSVME|CpuAES|CpuPCLMUL|CpuLZCNT|CpuPRFCHW" },
97 "CPU_BDVER1_FLAGS|CpuFMA|CpuBMI|CpuTBM|CpuF16C" },
99 "CPU_BDVER2_FLAGS|CpuXsaveopt|CpuFSGSBase" },
100 { "CPU_BDVER4_FLAGS",
101 "CPU_BDVER3_FLAGS|CpuAVX2|CpuMovbe|CpuBMI2|CpuRdRnd|CpuMWAITX" },
102 { "CPU_ZNVER1_FLAGS",
103 "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuRdtscp|CpuCX16|CPU_AVX2_FLAGS|CpuSSE4A|CpuABM|CpuSVME|CpuAES|CpuPCLMUL|CpuLZCNT|CpuPRFCHW|CpuFMA|CpuBMI|CpuF16C|CpuXsaveopt|CpuFSGSBase|CpuMovbe|CpuBMI2|CpuRdRnd|CpuADX|CpuRdSeed|CpuSMAP|CpuSHA|CpuXSAVEC|CpuXSAVES|CpuClflushOpt|CpuCLZERO|CpuMWAITX" },
104 { "CPU_ZNVER2_FLAGS",
105 "CPU_ZNVER1_FLAGS|CpuCLWB|CpuRDPID|CpuRDPRU|CpuMCOMMIT|CpuWBNOINVD" },
106 { "CPU_BTVER1_FLAGS",
107 "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuCX16|CpuRdtscp|CPU_SSSE3_FLAGS|CpuSSE4A|CpuABM|CpuPRFCHW|CpuCX16|CpuClflush|CpuFISTTP|CpuSVME|CpuLZCNT" },
108 { "CPU_BTVER2_FLAGS",
109 "CPU_BTVER1_FLAGS|CPU_AVX_FLAGS|CpuBMI|CpuF16C|CpuAES|CpuPCLMUL|CpuMovbe|CpuXsaveopt|CpuPRFCHW" },
117 "CPU_387_FLAGS|Cpu687" },
122 { "CPU_CLFLUSH_FLAGS",
126 { "CPU_SYSCALL_FLAGS",
133 "CPU_SSE_FLAGS|CpuSSE2" },
135 "CPU_SSE2_FLAGS|CpuSSE3" },
137 "CPU_SSE3_FLAGS|CpuSSSE3" },
138 { "CPU_SSE4_1_FLAGS",
139 "CPU_SSSE3_FLAGS|CpuSSE4_1" },
140 { "CPU_SSE4_2_FLAGS",
141 "CPU_SSE4_1_FLAGS|CpuSSE4_2" },
148 { "CPU_XSAVEOPT_FLAGS",
149 "CPU_XSAVE_FLAGS|CpuXsaveopt" },
151 "CPU_SSE2_FLAGS|CpuAES" },
152 { "CPU_PCLMUL_FLAGS",
153 "CPU_SSE2_FLAGS|CpuPCLMUL" },
155 "CPU_AVX_FLAGS|CpuFMA" },
157 "CPU_AVX_FLAGS|CpuFMA4" },
159 "CPU_SSE4A_FLAGS|CPU_FMA4_FLAGS|CpuXOP" },
161 "CPU_XSAVE_FLAGS|CpuLWP" },
170 { "CPU_RDTSCP_FLAGS",
174 { "CPU_FSGSBASE_FLAGS",
179 "CPU_AVX_FLAGS|CpuF16C" },
188 { "CPU_INVPCID_FLAGS",
190 { "CPU_VMFUNC_FLAGS",
193 "CPU_MMX_FLAGS|Cpu3dnow" },
194 { "CPU_3DNOWA_FLAGS",
195 "CPU_3DNOW_FLAGS|Cpu3dnowA" },
196 { "CPU_PADLOCK_FLAGS",
201 "CPU_SSE3_FLAGS|CpuSSE4a" },
205 "CPU_SSE4_2_FLAGS|CPU_XSAVE_FLAGS|CpuAVX" },
207 "CPU_AVX_FLAGS|CpuAVX2" },
208 { "CPU_AVX512F_FLAGS",
209 "CPU_AVX2_FLAGS|CpuAVX512F" },
210 { "CPU_AVX512CD_FLAGS",
211 "CPU_AVX512F_FLAGS|CpuAVX512CD" },
212 { "CPU_AVX512ER_FLAGS",
213 "CPU_AVX512F_FLAGS|CpuAVX512ER" },
214 { "CPU_AVX512PF_FLAGS",
215 "CPU_AVX512F_FLAGS|CpuAVX512PF" },
216 { "CPU_AVX512DQ_FLAGS",
217 "CPU_AVX512F_FLAGS|CpuAVX512DQ" },
218 { "CPU_AVX512BW_FLAGS",
219 "CPU_AVX512F_FLAGS|CpuAVX512BW" },
220 { "CPU_AVX512VL_FLAGS",
221 "CPU_AVX512F_FLAGS|CpuAVX512VL" },
222 { "CPU_AVX512IFMA_FLAGS",
223 "CPU_AVX512F_FLAGS|CpuAVX512IFMA" },
224 { "CPU_AVX512VBMI_FLAGS",
225 "CPU_AVX512F_FLAGS|CpuAVX512VBMI" },
226 { "CPU_AVX512_4FMAPS_FLAGS",
227 "CPU_AVX512F_FLAGS|CpuAVX512_4FMAPS" },
228 { "CPU_AVX512_4VNNIW_FLAGS",
229 "CPU_AVX512F_FLAGS|CpuAVX512_4VNNIW" },
230 { "CPU_AVX512_VPOPCNTDQ_FLAGS",
231 "CPU_AVX512F_FLAGS|CpuAVX512_VPOPCNTDQ" },
232 { "CPU_AVX512_VBMI2_FLAGS",
233 "CPU_AVX512F_FLAGS|CpuAVX512_VBMI2" },
234 { "CPU_AVX512_VNNI_FLAGS",
235 "CPU_AVX512F_FLAGS|CpuAVX512_VNNI" },
236 { "CPU_AVX512_BITALG_FLAGS",
237 "CPU_AVX512F_FLAGS|CpuAVX512_BITALG" },
238 { "CPU_AVX512_BF16_FLAGS",
239 "CPU_AVX512F_FLAGS|CpuAVX512_BF16" },
245 "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586" },
248 { "CPU_RDSEED_FLAGS",
250 { "CPU_PRFCHW_FLAGS",
255 "CPU_XSAVE_FLAGS|CpuMPX" },
257 "CPU_SSE2_FLAGS|CpuSHA" },
258 { "CPU_CLFLUSHOPT_FLAGS",
260 { "CPU_XSAVES_FLAGS",
261 "CPU_XSAVE_FLAGS|CpuXSAVES" },
262 { "CPU_XSAVEC_FLAGS",
263 "CPU_XSAVE_FLAGS|CpuXSAVEC" },
264 { "CPU_PREFETCHWT1_FLAGS",
270 { "CPU_CLZERO_FLAGS",
272 { "CPU_MWAITX_FLAGS",
275 "CPU_XSAVE_FLAGS|CpuOSPKE" },
278 { "CPU_PTWRITE_FLAGS",
288 { "CPU_VPCLMULQDQ_FLAGS",
290 { "CPU_WBNOINVD_FLAGS",
292 { "CPU_PCONFIG_FLAGS",
294 { "CPU_WAITPKG_FLAGS",
296 { "CPU_CLDEMOTE_FLAGS",
298 { "CPU_MOVDIRI_FLAGS",
300 { "CPU_MOVDIR64B_FLAGS",
302 { "CPU_ENQCMD_FLAGS",
304 { "CPU_AVX512_VP2INTERSECT_FLAGS",
305 "CpuAVX512_VP2INTERSECT" },
308 { "CPU_MCOMMIT_FLAGS",
310 { "CPU_ANY_X87_FLAGS",
311 "CPU_ANY_287_FLAGS|Cpu8087" },
312 { "CPU_ANY_287_FLAGS",
313 "CPU_ANY_387_FLAGS|Cpu287" },
314 { "CPU_ANY_387_FLAGS",
315 "CPU_ANY_687_FLAGS|Cpu387" },
316 { "CPU_ANY_687_FLAGS",
317 "Cpu687|CpuFISTTP" },
318 { "CPU_ANY_CMOV_FLAGS",
320 { "CPU_ANY_FXSR_FLAGS",
322 { "CPU_ANY_MMX_FLAGS",
323 "CPU_3DNOWA_FLAGS" },
324 { "CPU_ANY_SSE_FLAGS",
325 "CPU_ANY_SSE2_FLAGS|CpuSSE|CpuSSE4a" },
326 { "CPU_ANY_SSE2_FLAGS",
327 "CPU_ANY_SSE3_FLAGS|CpuSSE2" },
328 { "CPU_ANY_SSE3_FLAGS",
329 "CPU_ANY_SSSE3_FLAGS|CpuSSE3" },
330 { "CPU_ANY_SSSE3_FLAGS",
331 "CPU_ANY_SSE4_1_FLAGS|CpuSSSE3" },
332 { "CPU_ANY_SSE4_1_FLAGS",
333 "CPU_ANY_SSE4_2_FLAGS|CpuSSE4_1" },
334 { "CPU_ANY_SSE4_2_FLAGS",
336 { "CPU_ANY_AVX_FLAGS",
337 "CPU_ANY_AVX2_FLAGS|CpuF16C|CpuFMA|CpuFMA4|CpuXOP|CpuAVX" },
338 { "CPU_ANY_AVX2_FLAGS",
339 "CPU_ANY_AVX512F_FLAGS|CpuAVX2" },
340 { "CPU_ANY_AVX512F_FLAGS",
341 "CpuAVX512F|CpuAVX512CD|CpuAVX512ER|CpuAVX512PF|CpuAVX512DQ|CpuAVX512BW|CpuAVX512VL|CpuAVX512IFMA|CpuAVX512VBMI|CpuAVX512_4FMAPS|CpuAVX512_4VNNIW|CpuAVX512_VPOPCNTDQ|CpuAVX512_VBMI2|CpuAVX512_VNNI|CpuAVX512_BITALG|CpuAVX512_BF16|CpuAVX512_VP2INTERSECT" },
342 { "CPU_ANY_AVX512CD_FLAGS",
344 { "CPU_ANY_AVX512ER_FLAGS",
346 { "CPU_ANY_AVX512PF_FLAGS",
348 { "CPU_ANY_AVX512DQ_FLAGS",
350 { "CPU_ANY_AVX512BW_FLAGS",
352 { "CPU_ANY_AVX512VL_FLAGS",
354 { "CPU_ANY_AVX512IFMA_FLAGS",
356 { "CPU_ANY_AVX512VBMI_FLAGS",
358 { "CPU_ANY_AVX512_4FMAPS_FLAGS",
359 "CpuAVX512_4FMAPS" },
360 { "CPU_ANY_AVX512_4VNNIW_FLAGS",
361 "CpuAVX512_4VNNIW" },
362 { "CPU_ANY_AVX512_VPOPCNTDQ_FLAGS",
363 "CpuAVX512_VPOPCNTDQ" },
364 { "CPU_ANY_IBT_FLAGS",
366 { "CPU_ANY_SHSTK_FLAGS",
368 { "CPU_ANY_AVX512_VBMI2_FLAGS",
370 { "CPU_ANY_AVX512_VNNI_FLAGS",
372 { "CPU_ANY_AVX512_BITALG_FLAGS",
373 "CpuAVX512_BITALG" },
374 { "CPU_ANY_AVX512_BF16_FLAGS",
376 { "CPU_ANY_MOVDIRI_FLAGS",
378 { "CPU_ANY_MOVDIR64B_FLAGS",
380 { "CPU_ANY_ENQCMD_FLAGS",
382 { "CPU_ANY_AVX512_VP2INTERSECT_FLAGS",
383 "CpuAVX512_VP2INTERSECT" },
386 static initializer operand_type_init
[] =
388 { "OPERAND_TYPE_NONE",
390 { "OPERAND_TYPE_REG8",
392 { "OPERAND_TYPE_REG16",
394 { "OPERAND_TYPE_REG32",
396 { "OPERAND_TYPE_REG64",
398 { "OPERAND_TYPE_IMM1",
400 { "OPERAND_TYPE_IMM8",
402 { "OPERAND_TYPE_IMM8S",
404 { "OPERAND_TYPE_IMM16",
406 { "OPERAND_TYPE_IMM32",
408 { "OPERAND_TYPE_IMM32S",
410 { "OPERAND_TYPE_IMM64",
412 { "OPERAND_TYPE_BASEINDEX",
414 { "OPERAND_TYPE_DISP8",
416 { "OPERAND_TYPE_DISP16",
418 { "OPERAND_TYPE_DISP32",
420 { "OPERAND_TYPE_DISP32S",
422 { "OPERAND_TYPE_DISP64",
424 { "OPERAND_TYPE_INOUTPORTREG",
425 "Instance=RegD|Word" },
426 { "OPERAND_TYPE_SHIFTCOUNT",
427 "Instance=RegC|Byte" },
428 { "OPERAND_TYPE_CONTROL",
430 { "OPERAND_TYPE_TEST",
432 { "OPERAND_TYPE_DEBUG",
434 { "OPERAND_TYPE_FLOATREG",
436 { "OPERAND_TYPE_FLOATACC",
437 "Instance=Accum|Tbyte" },
438 { "OPERAND_TYPE_SREG",
440 { "OPERAND_TYPE_REGMMX",
442 { "OPERAND_TYPE_REGXMM",
443 "Class=RegSIMD|Xmmword" },
444 { "OPERAND_TYPE_REGYMM",
445 "Class=RegSIMD|Ymmword" },
446 { "OPERAND_TYPE_REGZMM",
447 "Class=RegSIMD|Zmmword" },
448 { "OPERAND_TYPE_REGMASK",
450 { "OPERAND_TYPE_REGBND",
452 { "OPERAND_TYPE_ACC8",
453 "Instance=Accum|Byte" },
454 { "OPERAND_TYPE_ACC16",
455 "Instance=Accum|Word" },
456 { "OPERAND_TYPE_ACC32",
457 "Instance=Accum|Dword" },
458 { "OPERAND_TYPE_ACC64",
459 "Instance=Accum|Qword" },
460 { "OPERAND_TYPE_DISP16_32",
462 { "OPERAND_TYPE_ANYDISP",
463 "Disp8|Disp16|Disp32|Disp32S|Disp64" },
464 { "OPERAND_TYPE_IMM16_32",
466 { "OPERAND_TYPE_IMM16_32S",
468 { "OPERAND_TYPE_IMM16_32_32S",
469 "Imm16|Imm32|Imm32S" },
470 { "OPERAND_TYPE_IMM32_64",
472 { "OPERAND_TYPE_IMM32_32S_DISP32",
473 "Imm32|Imm32S|Disp32" },
474 { "OPERAND_TYPE_IMM64_DISP64",
476 { "OPERAND_TYPE_IMM32_32S_64_DISP32",
477 "Imm32|Imm32S|Imm64|Disp32" },
478 { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
479 "Imm32|Imm32S|Imm64|Disp32|Disp64" },
480 { "OPERAND_TYPE_ANYIMM",
481 "Imm1|Imm8|Imm8S|Imm16|Imm32|Imm32S|Imm64" },
484 typedef struct bitfield
491 #define BITFIELD(n) { n, 0, #n }
493 static bitfield cpu_flags
[] =
503 BITFIELD (CpuClflush
),
505 BITFIELD (CpuSYSCALL
),
510 BITFIELD (CpuFISTTP
),
516 BITFIELD (CpuSSE4_1
),
517 BITFIELD (CpuSSE4_2
),
520 BITFIELD (CpuAVX512F
),
521 BITFIELD (CpuAVX512CD
),
522 BITFIELD (CpuAVX512ER
),
523 BITFIELD (CpuAVX512PF
),
524 BITFIELD (CpuAVX512VL
),
525 BITFIELD (CpuAVX512DQ
),
526 BITFIELD (CpuAVX512BW
),
532 BITFIELD (Cpu3dnowA
),
533 BITFIELD (CpuPadLock
),
539 BITFIELD (CpuXsaveopt
),
541 BITFIELD (CpuPCLMUL
),
552 BITFIELD (CpuRdtscp
),
553 BITFIELD (CpuFSGSBase
),
560 BITFIELD (CpuINVPCID
),
561 BITFIELD (CpuVMFUNC
),
562 BITFIELD (CpuRDSEED
),
564 BITFIELD (CpuPRFCHW
),
567 BITFIELD (CpuClflushOpt
),
568 BITFIELD (CpuXSAVES
),
569 BITFIELD (CpuXSAVEC
),
570 BITFIELD (CpuPREFETCHWT1
),
576 BITFIELD (CpuAVX512IFMA
),
577 BITFIELD (CpuAVX512VBMI
),
578 BITFIELD (CpuAVX512_4FMAPS
),
579 BITFIELD (CpuAVX512_4VNNIW
),
580 BITFIELD (CpuAVX512_VPOPCNTDQ
),
581 BITFIELD (CpuAVX512_VBMI2
),
582 BITFIELD (CpuAVX512_VNNI
),
583 BITFIELD (CpuAVX512_BITALG
),
584 BITFIELD (CpuAVX512_BF16
),
585 BITFIELD (CpuAVX512_VP2INTERSECT
),
586 BITFIELD (CpuMWAITX
),
587 BITFIELD (CpuCLZERO
),
590 BITFIELD (CpuPTWRITE
),
595 BITFIELD (CpuVPCLMULQDQ
),
596 BITFIELD (CpuWBNOINVD
),
597 BITFIELD (CpuPCONFIG
),
598 BITFIELD (CpuWAITPKG
),
599 BITFIELD (CpuCLDEMOTE
),
600 BITFIELD (CpuMOVDIRI
),
601 BITFIELD (CpuMOVDIR64B
),
602 BITFIELD (CpuENQCMD
),
604 BITFIELD (CpuMCOMMIT
),
606 BITFIELD (CpuUnused
),
610 static bitfield opcode_modifiers
[] =
620 BITFIELD (CheckRegSize
),
621 BITFIELD (IgnoreSize
),
622 BITFIELD (DefaultSize
),
633 BITFIELD (BNDPrefixOk
),
634 BITFIELD (NoTrackPrefixOk
),
635 BITFIELD (IsLockable
),
636 BITFIELD (RegKludge
),
637 BITFIELD (Implicit1stXmm0
),
638 BITFIELD (RepPrefixOk
),
639 BITFIELD (HLEPrefixOk
),
642 BITFIELD (AddrPrefixOpReg
),
651 BITFIELD (VexOpcode
),
652 BITFIELD (VexSources
),
658 BITFIELD (Broadcast
),
659 BITFIELD (StaticRounding
),
661 BITFIELD (Disp8MemShift
),
662 BITFIELD (NoDefMask
),
663 BITFIELD (ImplicitQuadGroup
),
665 BITFIELD (ATTMnemonic
),
666 BITFIELD (ATTSyntax
),
667 BITFIELD (IntelSyntax
),
671 #define CLASS(n) #n, n
673 static const struct {
675 enum operand_class value
;
676 } operand_classes
[] = {
690 #define INSTANCE(n) #n, n
692 static const struct {
694 enum operand_instance value
;
695 } operand_instances
[] = {
704 static bitfield operand_types
[] =
713 BITFIELD (BaseIndex
),
728 BITFIELD (Unspecified
),
734 static const char *filename
;
735 static i386_cpu_flags active_cpu_flags
;
736 static int active_isstring
;
739 compare (const void *x
, const void *y
)
741 const bitfield
*xp
= (const bitfield
*) x
;
742 const bitfield
*yp
= (const bitfield
*) y
;
743 return xp
->position
- yp
->position
;
747 fail (const char *message
, ...)
751 va_start (args
, message
);
752 fprintf (stderr
, _("%s: error: "), program_name
);
753 vfprintf (stderr
, message
, args
);
759 process_copyright (FILE *fp
)
761 fprintf (fp
, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
762 /* Copyright (C) 2007-2020 Free Software Foundation, Inc.\n\
764 This file is part of the GNU opcodes library.\n\
766 This library is free software; you can redistribute it and/or modify\n\
767 it under the terms of the GNU General Public License as published by\n\
768 the Free Software Foundation; either version 3, or (at your option)\n\
769 any later version.\n\
771 It is distributed in the hope that it will be useful, but WITHOUT\n\
772 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
773 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
774 License for more details.\n\
776 You should have received a copy of the GNU General Public License\n\
777 along with this program; if not, write to the Free Software\n\
778 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
779 MA 02110-1301, USA. */\n");
782 /* Remove leading white spaces. */
785 remove_leading_whitespaces (char *str
)
787 while (ISSPACE (*str
))
792 /* Remove trailing white spaces. */
795 remove_trailing_whitespaces (char *str
)
797 size_t last
= strlen (str
);
805 if (ISSPACE (str
[last
]))
813 /* Find next field separated by SEP and terminate it. Return a
814 pointer to the one after it. */
817 next_field (char *str
, char sep
, char **next
, char *last
)
821 p
= remove_leading_whitespaces (str
);
822 for (str
= p
; *str
!= sep
&& *str
!= '\0'; str
++);
825 remove_trailing_whitespaces (p
);
835 static void set_bitfield (char *, bitfield
*, int, unsigned int, int);
838 set_bitfield_from_cpu_flag_init (char *f
, bitfield
*array
, unsigned int size
,
841 char *str
, *next
, *last
;
844 for (i
= 0; i
< ARRAY_SIZE (cpu_flag_init
); i
++)
845 if (strcmp (cpu_flag_init
[i
].name
, f
) == 0)
847 /* Turn on selective bits. */
848 char *init
= xstrdup (cpu_flag_init
[i
].init
);
849 last
= init
+ strlen (init
);
850 for (next
= init
; next
&& next
< last
; )
852 str
= next_field (next
, '|', &next
, last
);
854 set_bitfield (str
, array
, 1, size
, lineno
);
864 set_bitfield (char *f
, bitfield
*array
, int value
,
865 unsigned int size
, int lineno
)
869 if (strcmp (f
, "CpuFP") == 0)
871 set_bitfield("Cpu387", array
, value
, size
, lineno
);
872 set_bitfield("Cpu287", array
, value
, size
, lineno
);
875 else if (strcmp (f
, "Mmword") == 0)
877 else if (strcmp (f
, "Oword") == 0)
880 for (i
= 0; i
< size
; i
++)
881 if (strcasecmp (array
[i
].name
, f
) == 0)
883 array
[i
].value
= value
;
889 const char *v
= strchr (f
, '=');
896 for (i
= 0; i
< size
; i
++)
897 if (strncasecmp (array
[i
].name
, f
, n
) == 0)
899 value
= strtol (v
+ 1, &end
, 0);
902 array
[i
].value
= value
;
910 /* Handle CPU_XXX_FLAGS. */
911 if (value
== 1 && !set_bitfield_from_cpu_flag_init (f
, array
, size
, lineno
))
915 fail (_("%s: %d: unknown bitfield: %s\n"), filename
, lineno
, f
);
917 fail (_("unknown bitfield: %s\n"), f
);
921 output_cpu_flags (FILE *table
, bitfield
*flags
, unsigned int size
,
922 int macro
, const char *comma
, const char *indent
)
926 memset (&active_cpu_flags
, 0, sizeof(active_cpu_flags
));
928 fprintf (table
, "%s{ { ", indent
);
930 for (i
= 0; i
< size
- 1; i
++)
932 if (((i
+ 1) % 20) != 0)
933 fprintf (table
, "%d, ", flags
[i
].value
);
935 fprintf (table
, "%d,", flags
[i
].value
);
936 if (((i
+ 1) % 20) == 0)
938 /* We need \\ for macro. */
940 fprintf (table
, " \\\n %s", indent
);
942 fprintf (table
, "\n %s", indent
);
945 active_cpu_flags
.array
[i
/ 32] |= 1U << (i
% 32);
948 fprintf (table
, "%d } }%s\n", flags
[i
].value
, comma
);
952 process_i386_cpu_flag (FILE *table
, char *flag
, int macro
,
953 const char *comma
, const char *indent
,
956 char *str
, *next
, *last
;
958 bitfield flags
[ARRAY_SIZE (cpu_flags
)];
960 /* Copy the default cpu flags. */
961 memcpy (flags
, cpu_flags
, sizeof (cpu_flags
));
963 if (strcasecmp (flag
, "unknown") == 0)
965 /* We turn on everything except for cpu64 in case of
966 CPU_UNKNOWN_FLAGS. */
967 for (i
= 0; i
< ARRAY_SIZE (flags
); i
++)
968 if (flags
[i
].position
!= Cpu64
)
971 else if (flag
[0] == '~')
973 last
= flag
+ strlen (flag
);
980 fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename
,
987 /* First we turn on everything except for cpu64. */
988 for (i
= 0; i
< ARRAY_SIZE (flags
); i
++)
989 if (flags
[i
].position
!= Cpu64
)
992 /* Turn off selective bits. */
993 for (; next
&& next
< last
; )
995 str
= next_field (next
, '|', &next
, last
);
997 set_bitfield (str
, flags
, 0, ARRAY_SIZE (flags
), lineno
);
1000 else if (strcmp (flag
, "0"))
1002 /* Turn on selective bits. */
1003 last
= flag
+ strlen (flag
);
1004 for (next
= flag
; next
&& next
< last
; )
1006 str
= next_field (next
, '|', &next
, last
);
1008 set_bitfield (str
, flags
, 1, ARRAY_SIZE (flags
), lineno
);
1012 output_cpu_flags (table
, flags
, ARRAY_SIZE (flags
), macro
,
1017 output_opcode_modifier (FILE *table
, bitfield
*modifier
, unsigned int size
)
1021 fprintf (table
, " { ");
1023 for (i
= 0; i
< size
- 1; i
++)
1025 if (((i
+ 1) % 20) != 0)
1026 fprintf (table
, "%d, ", modifier
[i
].value
);
1028 fprintf (table
, "%d,", modifier
[i
].value
);
1029 if (((i
+ 1) % 20) == 0)
1030 fprintf (table
, "\n ");
1033 fprintf (table
, "%d },\n", modifier
[i
].value
);
1037 adjust_broadcast_modifier (char **opnd
)
1039 char *str
, *next
, *last
, *op
;
1040 int bcst_type
= INT_MAX
;
1042 /* Skip the immediate operand. */
1044 if (strcasecmp(op
, "Imm8") == 0)
1048 last
= op
+ strlen (op
);
1049 for (next
= op
; next
&& next
< last
; )
1051 str
= next_field (next
, '|', &next
, last
);
1054 if (strcasecmp(str
, "Byte") == 0)
1056 /* The smalest broadcast type, no need to check
1058 bcst_type
= BYTE_BROADCAST
;
1061 else if (strcasecmp(str
, "Word") == 0)
1063 if (bcst_type
> WORD_BROADCAST
)
1064 bcst_type
= WORD_BROADCAST
;
1066 else if (strcasecmp(str
, "Dword") == 0)
1068 if (bcst_type
> DWORD_BROADCAST
)
1069 bcst_type
= DWORD_BROADCAST
;
1071 else if (strcasecmp(str
, "Qword") == 0)
1073 if (bcst_type
> QWORD_BROADCAST
)
1074 bcst_type
= QWORD_BROADCAST
;
1080 if (bcst_type
== INT_MAX
)
1081 fail (_("unknown broadcast operand: %s\n"), op
);
1087 process_i386_opcode_modifier (FILE *table
, char *mod
, char **opnd
, int lineno
)
1089 char *str
, *next
, *last
;
1090 bitfield modifiers
[ARRAY_SIZE (opcode_modifiers
)];
1092 active_isstring
= 0;
1094 /* Copy the default opcode modifier. */
1095 memcpy (modifiers
, opcode_modifiers
, sizeof (modifiers
));
1097 if (strcmp (mod
, "0"))
1099 unsigned int have_w
= 0, bwlq_suf
= 0xf;
1101 last
= mod
+ strlen (mod
);
1102 for (next
= mod
; next
&& next
< last
; )
1104 str
= next_field (next
, '|', &next
, last
);
1108 if (strcasecmp(str
, "Broadcast") == 0)
1109 val
= adjust_broadcast_modifier (opnd
);
1110 set_bitfield (str
, modifiers
, val
, ARRAY_SIZE (modifiers
),
1112 if (strcasecmp(str
, "IsString") == 0)
1113 active_isstring
= 1;
1115 if (strcasecmp(str
, "W") == 0)
1118 if (strcasecmp(str
, "No_bSuf") == 0)
1120 if (strcasecmp(str
, "No_wSuf") == 0)
1122 if (strcasecmp(str
, "No_lSuf") == 0)
1124 if (strcasecmp(str
, "No_qSuf") == 0)
1129 if (have_w
&& !bwlq_suf
)
1130 fail ("%s: %d: stray W modifier\n", filename
, lineno
);
1131 if (have_w
&& !(bwlq_suf
& 1))
1132 fprintf (stderr
, "%s: %d: W modifier without Byte operand(s)\n",
1134 if (have_w
&& !(bwlq_suf
& ~1))
1136 "%s: %d: W modifier without Word/Dword/Qword operand(s)\n",
1139 output_opcode_modifier (table
, modifiers
, ARRAY_SIZE (modifiers
));
1149 output_operand_type (FILE *table
, enum operand_class
class,
1150 enum operand_instance instance
,
1151 const bitfield
*types
, unsigned int size
,
1152 enum stage stage
, const char *indent
)
1156 fprintf (table
, "{ { %d, %d, ", class, instance
);
1158 for (i
= 0; i
< size
- 1; i
++)
1160 if (((i
+ 3) % 20) != 0)
1161 fprintf (table
, "%d, ", types
[i
].value
);
1163 fprintf (table
, "%d,", types
[i
].value
);
1164 if (((i
+ 3) % 20) == 0)
1166 /* We need \\ for macro. */
1167 if (stage
== stage_macros
)
1168 fprintf (table
, " \\\n%s", indent
);
1170 fprintf (table
, "\n%s", indent
);
1174 fprintf (table
, "%d } }", types
[i
].value
);
1178 process_i386_operand_type (FILE *table
, char *op
, enum stage stage
,
1179 const char *indent
, int lineno
)
1181 char *str
, *next
, *last
;
1182 enum operand_class
class = ClassNone
;
1183 enum operand_instance instance
= InstanceNone
;
1184 bitfield types
[ARRAY_SIZE (operand_types
)];
1186 /* Copy the default operand type. */
1187 memcpy (types
, operand_types
, sizeof (types
));
1189 if (strcmp (op
, "0"))
1193 last
= op
+ strlen (op
);
1194 for (next
= op
; next
&& next
< last
; )
1196 str
= next_field (next
, '|', &next
, last
);
1201 if (!strncmp(str
, "Class=", 6))
1203 for (i
= 0; i
< ARRAY_SIZE(operand_classes
); ++i
)
1204 if (!strcmp(str
+ 6, operand_classes
[i
].name
))
1206 class = operand_classes
[i
].value
;
1212 if (str
&& !strncmp(str
, "Instance=", 9))
1214 for (i
= 0; i
< ARRAY_SIZE(operand_instances
); ++i
)
1215 if (!strcmp(str
+ 9, operand_instances
[i
].name
))
1217 instance
= operand_instances
[i
].value
;
1225 set_bitfield (str
, types
, 1, ARRAY_SIZE (types
), lineno
);
1226 if (strcasecmp(str
, "BaseIndex") == 0)
1231 if (stage
== stage_opcodes
&& baseindex
&& !active_isstring
)
1233 set_bitfield("Disp8", types
, 1, ARRAY_SIZE (types
), lineno
);
1234 if (!active_cpu_flags
.bitfield
.cpu64
1235 && !active_cpu_flags
.bitfield
.cpumpx
)
1236 set_bitfield("Disp16", types
, 1, ARRAY_SIZE (types
), lineno
);
1237 if (!active_cpu_flags
.bitfield
.cpu64
)
1238 set_bitfield("Disp32", types
, 1, ARRAY_SIZE (types
), lineno
);
1239 if (!active_cpu_flags
.bitfield
.cpuno64
)
1240 set_bitfield("Disp32S", types
, 1, ARRAY_SIZE (types
), lineno
);
1243 output_operand_type (table
, class, instance
, types
, ARRAY_SIZE (types
),
1248 output_i386_opcode (FILE *table
, const char *name
, char *str
,
1249 char *last
, int lineno
)
1252 char *operands
, *base_opcode
, *extension_opcode
, *opcode_length
;
1253 char *cpu_flags
, *opcode_modifier
, *operand_types
[MAX_OPERANDS
];
1255 /* Find number of operands. */
1256 operands
= next_field (str
, ',', &str
, last
);
1258 /* Find base_opcode. */
1259 base_opcode
= next_field (str
, ',', &str
, last
);
1261 /* Find extension_opcode. */
1262 extension_opcode
= next_field (str
, ',', &str
, last
);
1264 /* Find opcode_length. */
1265 opcode_length
= next_field (str
, ',', &str
, last
);
1267 /* Find cpu_flags. */
1268 cpu_flags
= next_field (str
, ',', &str
, last
);
1270 /* Find opcode_modifier. */
1271 opcode_modifier
= next_field (str
, ',', &str
, last
);
1273 /* Remove the first {. */
1274 str
= remove_leading_whitespaces (str
);
1277 str
= remove_leading_whitespaces (str
+ 1);
1281 /* There are at least "X}". */
1285 /* Remove trailing white spaces and }. */
1289 if (ISSPACE (str
[i
]) || str
[i
] == '}')
1298 /* Find operand_types. */
1299 for (i
= 0; i
< ARRAY_SIZE (operand_types
); i
++)
1303 operand_types
[i
] = NULL
;
1307 operand_types
[i
] = next_field (str
, ',', &str
, last
);
1308 if (*operand_types
[i
] == '0')
1311 operand_types
[i
] = NULL
;
1316 fprintf (table
, " { \"%s\", %s, %s, %s, %s,\n",
1317 name
, base_opcode
, extension_opcode
, opcode_length
, operands
);
1319 process_i386_cpu_flag (table
, cpu_flags
, 0, ",", " ", lineno
);
1321 process_i386_opcode_modifier (table
, opcode_modifier
, operand_types
, lineno
);
1323 fprintf (table
, " { ");
1325 for (i
= 0; i
< ARRAY_SIZE (operand_types
); i
++)
1327 if (operand_types
[i
] == NULL
|| *operand_types
[i
] == '0')
1330 process_i386_operand_type (table
, "0", stage_opcodes
, "\t ",
1336 fprintf (table
, ",\n ");
1338 process_i386_operand_type (table
, operand_types
[i
], stage_opcodes
,
1341 fprintf (table
, " } },\n");
1344 struct opcode_hash_entry
1346 struct opcode_hash_entry
*next
;
1352 /* Calculate the hash value of an opcode hash entry P. */
1355 opcode_hash_hash (const void *p
)
1357 struct opcode_hash_entry
*entry
= (struct opcode_hash_entry
*) p
;
1358 return htab_hash_string (entry
->name
);
1361 /* Compare a string Q against an opcode hash entry P. */
1364 opcode_hash_eq (const void *p
, const void *q
)
1366 struct opcode_hash_entry
*entry
= (struct opcode_hash_entry
*) p
;
1367 const char *name
= (const char *) q
;
1368 return strcmp (name
, entry
->name
) == 0;
1372 process_i386_opcodes (FILE *table
)
1377 char *str
, *p
, *last
, *name
;
1378 struct opcode_hash_entry
**hash_slot
, **entry
, *next
;
1379 htab_t opcode_hash_table
;
1380 struct opcode_hash_entry
**opcode_array
;
1381 unsigned int opcode_array_size
= 1024;
1382 int lineno
= 0, marker
= 0;
1384 filename
= "i386-opc.tbl";
1388 opcode_array
= (struct opcode_hash_entry
**)
1389 xmalloc (sizeof (*opcode_array
) * opcode_array_size
);
1391 opcode_hash_table
= htab_create_alloc (16, opcode_hash_hash
,
1392 opcode_hash_eq
, NULL
,
1395 fprintf (table
, "\n/* i386 opcode table. */\n\n");
1396 fprintf (table
, "const insn_template i386_optab[] =\n{\n");
1398 /* Put everything on opcode array. */
1401 if (fgets (buf
, sizeof (buf
), fp
) == NULL
)
1406 p
= remove_leading_whitespaces (buf
);
1408 /* Skip comments. */
1409 str
= strstr (p
, "//");
1413 /* Remove trailing white spaces. */
1414 remove_trailing_whitespaces (p
);
1419 if (!strcmp("### MARKER ###", buf
))
1423 /* Since we ignore all included files (we only care about their
1424 #define-s here), we don't need to monitor filenames. The final
1425 line number directive is going to refer to the main source file
1430 p
= remove_leading_whitespaces (p
+ 1);
1431 if (!strncmp(p
, "line", 4))
1433 ln
= strtoul (p
, &end
, 10);
1434 if (ln
> 1 && ln
< INT_MAX
1435 && *remove_leading_whitespaces (end
) == '"')
1438 /* Ignore comments. */
1448 last
= p
+ strlen (p
);
1451 name
= next_field (p
, ',', &str
, last
);
1453 /* Get the slot in hash table. */
1454 hash_slot
= (struct opcode_hash_entry
**)
1455 htab_find_slot_with_hash (opcode_hash_table
, name
,
1456 htab_hash_string (name
),
1459 if (*hash_slot
== NULL
)
1461 /* It is the new one. Put it on opcode array. */
1462 if (i
>= opcode_array_size
)
1464 /* Grow the opcode array when needed. */
1465 opcode_array_size
+= 1024;
1466 opcode_array
= (struct opcode_hash_entry
**)
1467 xrealloc (opcode_array
,
1468 sizeof (*opcode_array
) * opcode_array_size
);
1471 opcode_array
[i
] = (struct opcode_hash_entry
*)
1472 xmalloc (sizeof (struct opcode_hash_entry
));
1473 opcode_array
[i
]->next
= NULL
;
1474 opcode_array
[i
]->name
= xstrdup (name
);
1475 opcode_array
[i
]->opcode
= xstrdup (str
);
1476 opcode_array
[i
]->lineno
= lineno
;
1477 *hash_slot
= opcode_array
[i
];
1482 /* Append it to the existing one. */
1484 while ((*entry
) != NULL
)
1485 entry
= &(*entry
)->next
;
1486 *entry
= (struct opcode_hash_entry
*)
1487 xmalloc (sizeof (struct opcode_hash_entry
));
1488 (*entry
)->next
= NULL
;
1489 (*entry
)->name
= (*hash_slot
)->name
;
1490 (*entry
)->opcode
= xstrdup (str
);
1491 (*entry
)->lineno
= lineno
;
1495 /* Process opcode array. */
1496 for (j
= 0; j
< i
; j
++)
1498 for (next
= opcode_array
[j
]; next
; next
= next
->next
)
1502 lineno
= next
->lineno
;
1503 last
= str
+ strlen (str
);
1504 output_i386_opcode (table
, name
, str
, last
, lineno
);
1510 fprintf (table
, " { NULL, 0, 0, 0, 0,\n");
1512 process_i386_cpu_flag (table
, "0", 0, ",", " ", -1);
1514 process_i386_opcode_modifier (table
, "0", NULL
, -1);
1516 fprintf (table
, " { ");
1517 process_i386_operand_type (table
, "0", stage_opcodes
, "\t ", -1);
1518 fprintf (table
, " } }\n");
1520 fprintf (table
, "};\n");
1524 process_i386_registers (FILE *table
)
1528 char *str
, *p
, *last
;
1529 char *reg_name
, *reg_type
, *reg_flags
, *reg_num
;
1530 char *dw2_32_num
, *dw2_64_num
;
1533 filename
= "i386-reg.tbl";
1534 fp
= fopen (filename
, "r");
1536 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1539 fprintf (table
, "\n/* i386 register table. */\n\n");
1540 fprintf (table
, "const reg_entry i386_regtab[] =\n{\n");
1544 if (fgets (buf
, sizeof (buf
), fp
) == NULL
)
1549 p
= remove_leading_whitespaces (buf
);
1551 /* Skip comments. */
1552 str
= strstr (p
, "//");
1556 /* Remove trailing white spaces. */
1557 remove_trailing_whitespaces (p
);
1562 fprintf (table
, "%s\n", p
);
1570 last
= p
+ strlen (p
);
1572 /* Find reg_name. */
1573 reg_name
= next_field (p
, ',', &str
, last
);
1575 /* Find reg_type. */
1576 reg_type
= next_field (str
, ',', &str
, last
);
1578 /* Find reg_flags. */
1579 reg_flags
= next_field (str
, ',', &str
, last
);
1582 reg_num
= next_field (str
, ',', &str
, last
);
1584 fprintf (table
, " { \"%s\",\n ", reg_name
);
1586 process_i386_operand_type (table
, reg_type
, stage_registers
, "\t",
1589 /* Find 32-bit Dwarf2 register number. */
1590 dw2_32_num
= next_field (str
, ',', &str
, last
);
1592 /* Find 64-bit Dwarf2 register number. */
1593 dw2_64_num
= next_field (str
, ',', &str
, last
);
1595 fprintf (table
, ",\n %s, %s, { %s, %s } },\n",
1596 reg_flags
, reg_num
, dw2_32_num
, dw2_64_num
);
1601 fprintf (table
, "};\n");
1603 fprintf (table
, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1607 process_i386_initializers (void)
1610 FILE *fp
= fopen ("i386-init.h", "w");
1614 fail (_("can't create i386-init.h, errno = %s\n"),
1617 process_copyright (fp
);
1619 for (i
= 0; i
< ARRAY_SIZE (cpu_flag_init
); i
++)
1621 fprintf (fp
, "\n#define %s \\\n", cpu_flag_init
[i
].name
);
1622 init
= xstrdup (cpu_flag_init
[i
].init
);
1623 process_i386_cpu_flag (fp
, init
, 1, "", " ", -1);
1627 for (i
= 0; i
< ARRAY_SIZE (operand_type_init
); i
++)
1629 fprintf (fp
, "\n\n#define %s \\\n ", operand_type_init
[i
].name
);
1630 init
= xstrdup (operand_type_init
[i
].init
);
1631 process_i386_operand_type (fp
, init
, stage_macros
, " ", -1);
1639 /* Program options. */
1640 #define OPTION_SRCDIR 200
1642 struct option long_options
[] =
1644 {"srcdir", required_argument
, NULL
, OPTION_SRCDIR
},
1645 {"debug", no_argument
, NULL
, 'd'},
1646 {"version", no_argument
, NULL
, 'V'},
1647 {"help", no_argument
, NULL
, 'h'},
1648 {0, no_argument
, NULL
, 0}
1652 print_version (void)
1654 printf ("%s: version 1.0\n", program_name
);
1659 usage (FILE * stream
, int status
)
1661 fprintf (stream
, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1667 main (int argc
, char **argv
)
1669 extern int chdir (char *);
1670 char *srcdir
= NULL
;
1672 unsigned int i
, cpumax
;
1675 program_name
= *argv
;
1676 xmalloc_set_program_name (program_name
);
1678 while ((c
= getopt_long (argc
, argv
, "vVdh", long_options
, 0)) != EOF
)
1703 if (chdir (srcdir
) != 0)
1704 fail (_("unable to change directory to \"%s\", errno = %s\n"),
1705 srcdir
, xstrerror (errno
));
1707 /* cpu_flags isn't sorted by position. */
1709 for (i
= 0; i
< ARRAY_SIZE (cpu_flags
); i
++)
1710 if (cpu_flags
[i
].position
> cpumax
)
1711 cpumax
= cpu_flags
[i
].position
;
1713 /* Check the unused bitfield in i386_cpu_flags. */
1715 static_assert (ARRAY_SIZE (cpu_flags
) == CpuMax
+ 2);
1717 if ((cpumax
- 1) != CpuMax
)
1718 fail (_("CpuMax != %d!\n"), cpumax
);
1720 static_assert (ARRAY_SIZE (cpu_flags
) == CpuMax
+ 1);
1722 if (cpumax
!= CpuMax
)
1723 fail (_("CpuMax != %d!\n"), cpumax
);
1725 c
= CpuNumOfBits
- CpuMax
- 1;
1727 fail (_("%d unused bits in i386_cpu_flags.\n"), c
);
1730 static_assert (ARRAY_SIZE (opcode_modifiers
) == Opcode_Modifier_Num
);
1732 /* Check the unused bitfield in i386_operand_type. */
1734 static_assert (ARRAY_SIZE (operand_types
) + CLASS_WIDTH
+ INSTANCE_WIDTH
1737 static_assert (ARRAY_SIZE (operand_types
) + CLASS_WIDTH
+ INSTANCE_WIDTH
1740 c
= OTNumOfBits
- OTNum
;
1742 fail (_("%d unused bits in i386_operand_type.\n"), c
);
1745 qsort (cpu_flags
, ARRAY_SIZE (cpu_flags
), sizeof (cpu_flags
[0]),
1748 qsort (opcode_modifiers
, ARRAY_SIZE (opcode_modifiers
),
1749 sizeof (opcode_modifiers
[0]), compare
);
1751 qsort (operand_types
, ARRAY_SIZE (operand_types
),
1752 sizeof (operand_types
[0]), compare
);
1754 table
= fopen ("i386-tbl.h", "w");
1756 fail (_("can't create i386-tbl.h, errno = %s\n"),
1759 process_copyright (table
);
1761 process_i386_opcodes (table
);
1762 process_i386_registers (table
);
1763 process_i386_initializers ();