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
[] =
616 BITFIELD (ShortForm
),
621 BITFIELD (CheckRegSize
),
622 BITFIELD (IgnoreSize
),
623 BITFIELD (DefaultSize
),
634 BITFIELD (BNDPrefixOk
),
635 BITFIELD (NoTrackPrefixOk
),
636 BITFIELD (IsLockable
),
637 BITFIELD (RegKludge
),
638 BITFIELD (Implicit1stXmm0
),
639 BITFIELD (RepPrefixOk
),
640 BITFIELD (HLEPrefixOk
),
643 BITFIELD (AddrPrefixOpReg
),
652 BITFIELD (VexOpcode
),
653 BITFIELD (VexSources
),
659 BITFIELD (Broadcast
),
660 BITFIELD (StaticRounding
),
662 BITFIELD (Disp8MemShift
),
663 BITFIELD (NoDefMask
),
664 BITFIELD (ImplicitQuadGroup
),
666 BITFIELD (ATTMnemonic
),
667 BITFIELD (ATTSyntax
),
668 BITFIELD (IntelSyntax
),
672 #define CLASS(n) #n, n
674 static const struct {
676 enum operand_class value
;
677 } operand_classes
[] = {
691 #define INSTANCE(n) #n, n
693 static const struct {
695 enum operand_instance value
;
696 } operand_instances
[] = {
705 static bitfield operand_types
[] =
714 BITFIELD (BaseIndex
),
729 BITFIELD (Unspecified
),
735 static const char *filename
;
736 static i386_cpu_flags active_cpu_flags
;
737 static int active_isstring
;
740 compare (const void *x
, const void *y
)
742 const bitfield
*xp
= (const bitfield
*) x
;
743 const bitfield
*yp
= (const bitfield
*) y
;
744 return xp
->position
- yp
->position
;
748 fail (const char *message
, ...)
752 va_start (args
, message
);
753 fprintf (stderr
, _("%s: error: "), program_name
);
754 vfprintf (stderr
, message
, args
);
760 process_copyright (FILE *fp
)
762 fprintf (fp
, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
763 /* Copyright (C) 2007-2020 Free Software Foundation, Inc.\n\
765 This file is part of the GNU opcodes library.\n\
767 This library is free software; you can redistribute it and/or modify\n\
768 it under the terms of the GNU General Public License as published by\n\
769 the Free Software Foundation; either version 3, or (at your option)\n\
770 any later version.\n\
772 It is distributed in the hope that it will be useful, but WITHOUT\n\
773 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
774 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
775 License for more details.\n\
777 You should have received a copy of the GNU General Public License\n\
778 along with this program; if not, write to the Free Software\n\
779 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
780 MA 02110-1301, USA. */\n");
783 /* Remove leading white spaces. */
786 remove_leading_whitespaces (char *str
)
788 while (ISSPACE (*str
))
793 /* Remove trailing white spaces. */
796 remove_trailing_whitespaces (char *str
)
798 size_t last
= strlen (str
);
806 if (ISSPACE (str
[last
]))
814 /* Find next field separated by SEP and terminate it. Return a
815 pointer to the one after it. */
818 next_field (char *str
, char sep
, char **next
, char *last
)
822 p
= remove_leading_whitespaces (str
);
823 for (str
= p
; *str
!= sep
&& *str
!= '\0'; str
++);
826 remove_trailing_whitespaces (p
);
836 static void set_bitfield (char *, bitfield
*, int, unsigned int, int);
839 set_bitfield_from_cpu_flag_init (char *f
, bitfield
*array
, unsigned int size
,
842 char *str
, *next
, *last
;
845 for (i
= 0; i
< ARRAY_SIZE (cpu_flag_init
); i
++)
846 if (strcmp (cpu_flag_init
[i
].name
, f
) == 0)
848 /* Turn on selective bits. */
849 char *init
= xstrdup (cpu_flag_init
[i
].init
);
850 last
= init
+ strlen (init
);
851 for (next
= init
; next
&& next
< last
; )
853 str
= next_field (next
, '|', &next
, last
);
855 set_bitfield (str
, array
, 1, size
, lineno
);
865 set_bitfield (char *f
, bitfield
*array
, int value
,
866 unsigned int size
, int lineno
)
870 if (strcmp (f
, "CpuFP") == 0)
872 set_bitfield("Cpu387", array
, value
, size
, lineno
);
873 set_bitfield("Cpu287", array
, value
, size
, lineno
);
876 else if (strcmp (f
, "Mmword") == 0)
878 else if (strcmp (f
, "Oword") == 0)
881 for (i
= 0; i
< size
; i
++)
882 if (strcasecmp (array
[i
].name
, f
) == 0)
884 array
[i
].value
= value
;
890 const char *v
= strchr (f
, '=');
897 for (i
= 0; i
< size
; i
++)
898 if (strncasecmp (array
[i
].name
, f
, n
) == 0)
900 value
= strtol (v
+ 1, &end
, 0);
903 array
[i
].value
= value
;
911 /* Handle CPU_XXX_FLAGS. */
912 if (value
== 1 && !set_bitfield_from_cpu_flag_init (f
, array
, size
, lineno
))
916 fail (_("%s: %d: unknown bitfield: %s\n"), filename
, lineno
, f
);
918 fail (_("unknown bitfield: %s\n"), f
);
922 output_cpu_flags (FILE *table
, bitfield
*flags
, unsigned int size
,
923 int macro
, const char *comma
, const char *indent
)
927 memset (&active_cpu_flags
, 0, sizeof(active_cpu_flags
));
929 fprintf (table
, "%s{ { ", indent
);
931 for (i
= 0; i
< size
- 1; i
++)
933 if (((i
+ 1) % 20) != 0)
934 fprintf (table
, "%d, ", flags
[i
].value
);
936 fprintf (table
, "%d,", flags
[i
].value
);
937 if (((i
+ 1) % 20) == 0)
939 /* We need \\ for macro. */
941 fprintf (table
, " \\\n %s", indent
);
943 fprintf (table
, "\n %s", indent
);
946 active_cpu_flags
.array
[i
/ 32] |= 1U << (i
% 32);
949 fprintf (table
, "%d } }%s\n", flags
[i
].value
, comma
);
953 process_i386_cpu_flag (FILE *table
, char *flag
, int macro
,
954 const char *comma
, const char *indent
,
957 char *str
, *next
, *last
;
959 bitfield flags
[ARRAY_SIZE (cpu_flags
)];
961 /* Copy the default cpu flags. */
962 memcpy (flags
, cpu_flags
, sizeof (cpu_flags
));
964 if (strcasecmp (flag
, "unknown") == 0)
966 /* We turn on everything except for cpu64 in case of
967 CPU_UNKNOWN_FLAGS. */
968 for (i
= 0; i
< ARRAY_SIZE (flags
); i
++)
969 if (flags
[i
].position
!= Cpu64
)
972 else if (flag
[0] == '~')
974 last
= flag
+ strlen (flag
);
981 fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename
,
988 /* First we turn on everything except for cpu64. */
989 for (i
= 0; i
< ARRAY_SIZE (flags
); i
++)
990 if (flags
[i
].position
!= Cpu64
)
993 /* Turn off selective bits. */
994 for (; next
&& next
< last
; )
996 str
= next_field (next
, '|', &next
, last
);
998 set_bitfield (str
, flags
, 0, ARRAY_SIZE (flags
), lineno
);
1001 else if (strcmp (flag
, "0"))
1003 /* Turn on selective bits. */
1004 last
= flag
+ strlen (flag
);
1005 for (next
= flag
; next
&& next
< last
; )
1007 str
= next_field (next
, '|', &next
, last
);
1009 set_bitfield (str
, flags
, 1, ARRAY_SIZE (flags
), lineno
);
1013 output_cpu_flags (table
, flags
, ARRAY_SIZE (flags
), macro
,
1018 output_opcode_modifier (FILE *table
, bitfield
*modifier
, unsigned int size
)
1022 fprintf (table
, " { ");
1024 for (i
= 0; i
< size
- 1; i
++)
1026 if (((i
+ 1) % 20) != 0)
1027 fprintf (table
, "%d, ", modifier
[i
].value
);
1029 fprintf (table
, "%d,", modifier
[i
].value
);
1030 if (((i
+ 1) % 20) == 0)
1031 fprintf (table
, "\n ");
1034 fprintf (table
, "%d },\n", modifier
[i
].value
);
1038 adjust_broadcast_modifier (char **opnd
)
1040 char *str
, *next
, *last
, *op
;
1041 int bcst_type
= INT_MAX
;
1043 /* Skip the immediate operand. */
1045 if (strcasecmp(op
, "Imm8") == 0)
1049 last
= op
+ strlen (op
);
1050 for (next
= op
; next
&& next
< last
; )
1052 str
= next_field (next
, '|', &next
, last
);
1055 if (strcasecmp(str
, "Byte") == 0)
1057 /* The smalest broadcast type, no need to check
1059 bcst_type
= BYTE_BROADCAST
;
1062 else if (strcasecmp(str
, "Word") == 0)
1064 if (bcst_type
> WORD_BROADCAST
)
1065 bcst_type
= WORD_BROADCAST
;
1067 else if (strcasecmp(str
, "Dword") == 0)
1069 if (bcst_type
> DWORD_BROADCAST
)
1070 bcst_type
= DWORD_BROADCAST
;
1072 else if (strcasecmp(str
, "Qword") == 0)
1074 if (bcst_type
> QWORD_BROADCAST
)
1075 bcst_type
= QWORD_BROADCAST
;
1081 if (bcst_type
== INT_MAX
)
1082 fail (_("unknown broadcast operand: %s\n"), op
);
1088 process_i386_opcode_modifier (FILE *table
, char *mod
, char **opnd
, int lineno
)
1090 char *str
, *next
, *last
;
1091 bitfield modifiers
[ARRAY_SIZE (opcode_modifiers
)];
1093 active_isstring
= 0;
1095 /* Copy the default opcode modifier. */
1096 memcpy (modifiers
, opcode_modifiers
, sizeof (modifiers
));
1098 if (strcmp (mod
, "0"))
1100 unsigned int have_w
= 0, bwlq_suf
= 0xf;
1102 last
= mod
+ strlen (mod
);
1103 for (next
= mod
; next
&& next
< last
; )
1105 str
= next_field (next
, '|', &next
, last
);
1109 if (strcasecmp(str
, "Broadcast") == 0)
1110 val
= adjust_broadcast_modifier (opnd
);
1111 set_bitfield (str
, modifiers
, val
, ARRAY_SIZE (modifiers
),
1113 if (strcasecmp(str
, "IsString") == 0)
1114 active_isstring
= 1;
1116 if (strcasecmp(str
, "W") == 0)
1119 if (strcasecmp(str
, "No_bSuf") == 0)
1121 if (strcasecmp(str
, "No_wSuf") == 0)
1123 if (strcasecmp(str
, "No_lSuf") == 0)
1125 if (strcasecmp(str
, "No_qSuf") == 0)
1130 if (have_w
&& !bwlq_suf
)
1131 fail ("%s: %d: stray W modifier\n", filename
, lineno
);
1132 if (have_w
&& !(bwlq_suf
& 1))
1133 fprintf (stderr
, "%s: %d: W modifier without Byte operand(s)\n",
1135 if (have_w
&& !(bwlq_suf
& ~1))
1137 "%s: %d: W modifier without Word/Dword/Qword operand(s)\n",
1140 output_opcode_modifier (table
, modifiers
, ARRAY_SIZE (modifiers
));
1150 output_operand_type (FILE *table
, enum operand_class
class,
1151 enum operand_instance instance
,
1152 const bitfield
*types
, unsigned int size
,
1153 enum stage stage
, const char *indent
)
1157 fprintf (table
, "{ { %d, %d, ", class, instance
);
1159 for (i
= 0; i
< size
- 1; i
++)
1161 if (((i
+ 3) % 20) != 0)
1162 fprintf (table
, "%d, ", types
[i
].value
);
1164 fprintf (table
, "%d,", types
[i
].value
);
1165 if (((i
+ 3) % 20) == 0)
1167 /* We need \\ for macro. */
1168 if (stage
== stage_macros
)
1169 fprintf (table
, " \\\n%s", indent
);
1171 fprintf (table
, "\n%s", indent
);
1175 fprintf (table
, "%d } }", types
[i
].value
);
1179 process_i386_operand_type (FILE *table
, char *op
, enum stage stage
,
1180 const char *indent
, int lineno
)
1182 char *str
, *next
, *last
;
1183 enum operand_class
class = ClassNone
;
1184 enum operand_instance instance
= InstanceNone
;
1185 bitfield types
[ARRAY_SIZE (operand_types
)];
1187 /* Copy the default operand type. */
1188 memcpy (types
, operand_types
, sizeof (types
));
1190 if (strcmp (op
, "0"))
1194 last
= op
+ strlen (op
);
1195 for (next
= op
; next
&& next
< last
; )
1197 str
= next_field (next
, '|', &next
, last
);
1202 if (!strncmp(str
, "Class=", 6))
1204 for (i
= 0; i
< ARRAY_SIZE(operand_classes
); ++i
)
1205 if (!strcmp(str
+ 6, operand_classes
[i
].name
))
1207 class = operand_classes
[i
].value
;
1213 if (str
&& !strncmp(str
, "Instance=", 9))
1215 for (i
= 0; i
< ARRAY_SIZE(operand_instances
); ++i
)
1216 if (!strcmp(str
+ 9, operand_instances
[i
].name
))
1218 instance
= operand_instances
[i
].value
;
1226 set_bitfield (str
, types
, 1, ARRAY_SIZE (types
), lineno
);
1227 if (strcasecmp(str
, "BaseIndex") == 0)
1232 if (stage
== stage_opcodes
&& baseindex
&& !active_isstring
)
1234 set_bitfield("Disp8", types
, 1, ARRAY_SIZE (types
), lineno
);
1235 if (!active_cpu_flags
.bitfield
.cpu64
1236 && !active_cpu_flags
.bitfield
.cpumpx
)
1237 set_bitfield("Disp16", types
, 1, ARRAY_SIZE (types
), lineno
);
1238 if (!active_cpu_flags
.bitfield
.cpu64
)
1239 set_bitfield("Disp32", types
, 1, ARRAY_SIZE (types
), lineno
);
1240 if (!active_cpu_flags
.bitfield
.cpuno64
)
1241 set_bitfield("Disp32S", types
, 1, ARRAY_SIZE (types
), lineno
);
1244 output_operand_type (table
, class, instance
, types
, ARRAY_SIZE (types
),
1249 output_i386_opcode (FILE *table
, const char *name
, char *str
,
1250 char *last
, int lineno
)
1253 char *operands
, *base_opcode
, *extension_opcode
, *opcode_length
;
1254 char *cpu_flags
, *opcode_modifier
, *operand_types
[MAX_OPERANDS
];
1256 /* Find number of operands. */
1257 operands
= next_field (str
, ',', &str
, last
);
1259 /* Find base_opcode. */
1260 base_opcode
= next_field (str
, ',', &str
, last
);
1262 /* Find extension_opcode. */
1263 extension_opcode
= next_field (str
, ',', &str
, last
);
1265 /* Find opcode_length. */
1266 opcode_length
= next_field (str
, ',', &str
, last
);
1268 /* Find cpu_flags. */
1269 cpu_flags
= next_field (str
, ',', &str
, last
);
1271 /* Find opcode_modifier. */
1272 opcode_modifier
= next_field (str
, ',', &str
, last
);
1274 /* Remove the first {. */
1275 str
= remove_leading_whitespaces (str
);
1278 str
= remove_leading_whitespaces (str
+ 1);
1282 /* There are at least "X}". */
1286 /* Remove trailing white spaces and }. */
1290 if (ISSPACE (str
[i
]) || str
[i
] == '}')
1299 /* Find operand_types. */
1300 for (i
= 0; i
< ARRAY_SIZE (operand_types
); i
++)
1304 operand_types
[i
] = NULL
;
1308 operand_types
[i
] = next_field (str
, ',', &str
, last
);
1309 if (*operand_types
[i
] == '0')
1312 operand_types
[i
] = NULL
;
1317 fprintf (table
, " { \"%s\", %s, %s, %s, %s,\n",
1318 name
, base_opcode
, extension_opcode
, opcode_length
, operands
);
1320 process_i386_cpu_flag (table
, cpu_flags
, 0, ",", " ", lineno
);
1322 process_i386_opcode_modifier (table
, opcode_modifier
, operand_types
, lineno
);
1324 fprintf (table
, " { ");
1326 for (i
= 0; i
< ARRAY_SIZE (operand_types
); i
++)
1328 if (operand_types
[i
] == NULL
|| *operand_types
[i
] == '0')
1331 process_i386_operand_type (table
, "0", stage_opcodes
, "\t ",
1337 fprintf (table
, ",\n ");
1339 process_i386_operand_type (table
, operand_types
[i
], stage_opcodes
,
1342 fprintf (table
, " } },\n");
1345 struct opcode_hash_entry
1347 struct opcode_hash_entry
*next
;
1353 /* Calculate the hash value of an opcode hash entry P. */
1356 opcode_hash_hash (const void *p
)
1358 struct opcode_hash_entry
*entry
= (struct opcode_hash_entry
*) p
;
1359 return htab_hash_string (entry
->name
);
1362 /* Compare a string Q against an opcode hash entry P. */
1365 opcode_hash_eq (const void *p
, const void *q
)
1367 struct opcode_hash_entry
*entry
= (struct opcode_hash_entry
*) p
;
1368 const char *name
= (const char *) q
;
1369 return strcmp (name
, entry
->name
) == 0;
1373 process_i386_opcodes (FILE *table
)
1378 char *str
, *p
, *last
, *name
;
1379 struct opcode_hash_entry
**hash_slot
, **entry
, *next
;
1380 htab_t opcode_hash_table
;
1381 struct opcode_hash_entry
**opcode_array
;
1382 unsigned int opcode_array_size
= 1024;
1383 int lineno
= 0, marker
= 0;
1385 filename
= "i386-opc.tbl";
1389 opcode_array
= (struct opcode_hash_entry
**)
1390 xmalloc (sizeof (*opcode_array
) * opcode_array_size
);
1392 opcode_hash_table
= htab_create_alloc (16, opcode_hash_hash
,
1393 opcode_hash_eq
, NULL
,
1396 fprintf (table
, "\n/* i386 opcode table. */\n\n");
1397 fprintf (table
, "const insn_template i386_optab[] =\n{\n");
1399 /* Put everything on opcode array. */
1402 if (fgets (buf
, sizeof (buf
), fp
) == NULL
)
1407 p
= remove_leading_whitespaces (buf
);
1409 /* Skip comments. */
1410 str
= strstr (p
, "//");
1414 /* Remove trailing white spaces. */
1415 remove_trailing_whitespaces (p
);
1420 if (!strcmp("### MARKER ###", buf
))
1424 /* Since we ignore all included files (we only care about their
1425 #define-s here), we don't need to monitor filenames. The final
1426 line number directive is going to refer to the main source file
1431 p
= remove_leading_whitespaces (p
+ 1);
1432 if (!strncmp(p
, "line", 4))
1434 ln
= strtoul (p
, &end
, 10);
1435 if (ln
> 1 && ln
< INT_MAX
1436 && *remove_leading_whitespaces (end
) == '"')
1439 /* Ignore comments. */
1449 last
= p
+ strlen (p
);
1452 name
= next_field (p
, ',', &str
, last
);
1454 /* Get the slot in hash table. */
1455 hash_slot
= (struct opcode_hash_entry
**)
1456 htab_find_slot_with_hash (opcode_hash_table
, name
,
1457 htab_hash_string (name
),
1460 if (*hash_slot
== NULL
)
1462 /* It is the new one. Put it on opcode array. */
1463 if (i
>= opcode_array_size
)
1465 /* Grow the opcode array when needed. */
1466 opcode_array_size
+= 1024;
1467 opcode_array
= (struct opcode_hash_entry
**)
1468 xrealloc (opcode_array
,
1469 sizeof (*opcode_array
) * opcode_array_size
);
1472 opcode_array
[i
] = (struct opcode_hash_entry
*)
1473 xmalloc (sizeof (struct opcode_hash_entry
));
1474 opcode_array
[i
]->next
= NULL
;
1475 opcode_array
[i
]->name
= xstrdup (name
);
1476 opcode_array
[i
]->opcode
= xstrdup (str
);
1477 opcode_array
[i
]->lineno
= lineno
;
1478 *hash_slot
= opcode_array
[i
];
1483 /* Append it to the existing one. */
1485 while ((*entry
) != NULL
)
1486 entry
= &(*entry
)->next
;
1487 *entry
= (struct opcode_hash_entry
*)
1488 xmalloc (sizeof (struct opcode_hash_entry
));
1489 (*entry
)->next
= NULL
;
1490 (*entry
)->name
= (*hash_slot
)->name
;
1491 (*entry
)->opcode
= xstrdup (str
);
1492 (*entry
)->lineno
= lineno
;
1496 /* Process opcode array. */
1497 for (j
= 0; j
< i
; j
++)
1499 for (next
= opcode_array
[j
]; next
; next
= next
->next
)
1503 lineno
= next
->lineno
;
1504 last
= str
+ strlen (str
);
1505 output_i386_opcode (table
, name
, str
, last
, lineno
);
1511 fprintf (table
, " { NULL, 0, 0, 0, 0,\n");
1513 process_i386_cpu_flag (table
, "0", 0, ",", " ", -1);
1515 process_i386_opcode_modifier (table
, "0", NULL
, -1);
1517 fprintf (table
, " { ");
1518 process_i386_operand_type (table
, "0", stage_opcodes
, "\t ", -1);
1519 fprintf (table
, " } }\n");
1521 fprintf (table
, "};\n");
1525 process_i386_registers (FILE *table
)
1529 char *str
, *p
, *last
;
1530 char *reg_name
, *reg_type
, *reg_flags
, *reg_num
;
1531 char *dw2_32_num
, *dw2_64_num
;
1534 filename
= "i386-reg.tbl";
1535 fp
= fopen (filename
, "r");
1537 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
1540 fprintf (table
, "\n/* i386 register table. */\n\n");
1541 fprintf (table
, "const reg_entry i386_regtab[] =\n{\n");
1545 if (fgets (buf
, sizeof (buf
), fp
) == NULL
)
1550 p
= remove_leading_whitespaces (buf
);
1552 /* Skip comments. */
1553 str
= strstr (p
, "//");
1557 /* Remove trailing white spaces. */
1558 remove_trailing_whitespaces (p
);
1563 fprintf (table
, "%s\n", p
);
1571 last
= p
+ strlen (p
);
1573 /* Find reg_name. */
1574 reg_name
= next_field (p
, ',', &str
, last
);
1576 /* Find reg_type. */
1577 reg_type
= next_field (str
, ',', &str
, last
);
1579 /* Find reg_flags. */
1580 reg_flags
= next_field (str
, ',', &str
, last
);
1583 reg_num
= next_field (str
, ',', &str
, last
);
1585 fprintf (table
, " { \"%s\",\n ", reg_name
);
1587 process_i386_operand_type (table
, reg_type
, stage_registers
, "\t",
1590 /* Find 32-bit Dwarf2 register number. */
1591 dw2_32_num
= next_field (str
, ',', &str
, last
);
1593 /* Find 64-bit Dwarf2 register number. */
1594 dw2_64_num
= next_field (str
, ',', &str
, last
);
1596 fprintf (table
, ",\n %s, %s, { %s, %s } },\n",
1597 reg_flags
, reg_num
, dw2_32_num
, dw2_64_num
);
1602 fprintf (table
, "};\n");
1604 fprintf (table
, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1608 process_i386_initializers (void)
1611 FILE *fp
= fopen ("i386-init.h", "w");
1615 fail (_("can't create i386-init.h, errno = %s\n"),
1618 process_copyright (fp
);
1620 for (i
= 0; i
< ARRAY_SIZE (cpu_flag_init
); i
++)
1622 fprintf (fp
, "\n#define %s \\\n", cpu_flag_init
[i
].name
);
1623 init
= xstrdup (cpu_flag_init
[i
].init
);
1624 process_i386_cpu_flag (fp
, init
, 1, "", " ", -1);
1628 for (i
= 0; i
< ARRAY_SIZE (operand_type_init
); i
++)
1630 fprintf (fp
, "\n\n#define %s \\\n ", operand_type_init
[i
].name
);
1631 init
= xstrdup (operand_type_init
[i
].init
);
1632 process_i386_operand_type (fp
, init
, stage_macros
, " ", -1);
1640 /* Program options. */
1641 #define OPTION_SRCDIR 200
1643 struct option long_options
[] =
1645 {"srcdir", required_argument
, NULL
, OPTION_SRCDIR
},
1646 {"debug", no_argument
, NULL
, 'd'},
1647 {"version", no_argument
, NULL
, 'V'},
1648 {"help", no_argument
, NULL
, 'h'},
1649 {0, no_argument
, NULL
, 0}
1653 print_version (void)
1655 printf ("%s: version 1.0\n", program_name
);
1660 usage (FILE * stream
, int status
)
1662 fprintf (stream
, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1668 main (int argc
, char **argv
)
1670 extern int chdir (char *);
1671 char *srcdir
= NULL
;
1673 unsigned int i
, cpumax
;
1676 program_name
= *argv
;
1677 xmalloc_set_program_name (program_name
);
1679 while ((c
= getopt_long (argc
, argv
, "vVdh", long_options
, 0)) != EOF
)
1704 if (chdir (srcdir
) != 0)
1705 fail (_("unable to change directory to \"%s\", errno = %s\n"),
1706 srcdir
, xstrerror (errno
));
1708 /* cpu_flags isn't sorted by position. */
1710 for (i
= 0; i
< ARRAY_SIZE (cpu_flags
); i
++)
1711 if (cpu_flags
[i
].position
> cpumax
)
1712 cpumax
= cpu_flags
[i
].position
;
1714 /* Check the unused bitfield in i386_cpu_flags. */
1716 static_assert (ARRAY_SIZE (cpu_flags
) == CpuMax
+ 2);
1718 if ((cpumax
- 1) != CpuMax
)
1719 fail (_("CpuMax != %d!\n"), cpumax
);
1721 static_assert (ARRAY_SIZE (cpu_flags
) == CpuMax
+ 1);
1723 if (cpumax
!= CpuMax
)
1724 fail (_("CpuMax != %d!\n"), cpumax
);
1726 c
= CpuNumOfBits
- CpuMax
- 1;
1728 fail (_("%d unused bits in i386_cpu_flags.\n"), c
);
1731 static_assert (ARRAY_SIZE (opcode_modifiers
) == Opcode_Modifier_Num
);
1733 /* Check the unused bitfield in i386_operand_type. */
1735 static_assert (ARRAY_SIZE (operand_types
) + CLASS_WIDTH
+ INSTANCE_WIDTH
1738 static_assert (ARRAY_SIZE (operand_types
) + CLASS_WIDTH
+ INSTANCE_WIDTH
1741 c
= OTNumOfBits
- OTNum
;
1743 fail (_("%d unused bits in i386_operand_type.\n"), c
);
1746 qsort (cpu_flags
, ARRAY_SIZE (cpu_flags
), sizeof (cpu_flags
[0]),
1749 qsort (opcode_modifiers
, ARRAY_SIZE (opcode_modifiers
),
1750 sizeof (opcode_modifiers
[0]), compare
);
1752 qsort (operand_types
, ARRAY_SIZE (operand_types
),
1753 sizeof (operand_types
[0]), compare
);
1755 table
= fopen ("i386-tbl.h", "w");
1757 fail (_("can't create i386-tbl.h, errno = %s\n"),
1760 process_copyright (table
);
1762 process_i386_opcodes (table
);
1763 process_i386_registers (table
);
1764 process_i386_initializers ();