projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
x86: drop a few dead macros
[deliverable/binutils-gdb.git] / opcodes / i386-gen.c
CommitLineData
82704155 1/* Copyright (C) 2007-2019 Free Software Foundation, Inc.
40b8e679 2
9b201bb5 3 This file is part of the GNU opcodes library.
40b8e679 4
9b201bb5 5 This library is free software; you can redistribute it and/or modify
40b8e679 6 it under the terms of the GNU General Public License as published by
9b201bb5
NC		 7 the Free Software Foundation; either version 3, or (at your option)
8 any later version.
40b8e679 9
9b201bb5
NC		 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.
40b8e679
L		 14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
9b201bb5
NC		 17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
18 MA 02110-1301, USA. */
40b8e679 19
40fb9820 20#include "sysdep.h"
40b8e679 21#include <stdio.h>
40b8e679
L		 22#include <errno.h>
23#include "getopt.h"
24#include "libiberty.h"
c587b3f9 25#include "hashtab.h"
40b8e679
L		 26#include "safe-ctype.h"
27
28#include "i386-opc.h"
29
30#include <libintl.h>
31#define _(String) gettext (String)
32
33static const char *program_name = NULL;
34static int debug = 0;
35
40fb9820
L		 36typedef struct initializer
37{
38 const char *name;
39 const char *init;
40} initializer;
41
8acd5377 42static initializer cpu_flag_init[] =
40fb9820
L		 43{
44 { "CPU_UNKNOWN_FLAGS",
7a9068fe 45 "~(CpuL1OM|CpuK1OM)" },
40fb9820
L		 46 { "CPU_GENERIC32_FLAGS",
47 "Cpu186|Cpu286|Cpu386" },
29c048b6 48 { "CPU_GENERIC64_FLAGS",
1848e567 49 "CPU_PENTIUMPRO_FLAGS|CpuClflush|CpuSYSCALL|CPU_MMX_FLAGS|CPU_SSE2_FLAGS|CpuLM" },
40fb9820
L		 50 { "CPU_NONE_FLAGS",
51 "0" },
52 { "CPU_I186_FLAGS",
53 "Cpu186" },
54 { "CPU_I286_FLAGS",
1848e567 55 "CPU_I186_FLAGS|Cpu286" },
40fb9820 56 { "CPU_I386_FLAGS",
1848e567 57 "CPU_I286_FLAGS|Cpu386" },
40fb9820 58 { "CPU_I486_FLAGS",
1848e567 59 "CPU_I386_FLAGS|Cpu486" },
40fb9820 60 { "CPU_I586_FLAGS",
0e0eea78 61 "CPU_I486_FLAGS|Cpu387|Cpu586" },
40fb9820 62 { "CPU_I686_FLAGS",
d871f3f4 63 "CPU_I586_FLAGS|Cpu686|Cpu687|CpuCMOV|CpuFXSR" },
22109423 64 { "CPU_PENTIUMPRO_FLAGS",
1848e567 65 "CPU_I686_FLAGS|CpuNop" },
40fb9820 66 { "CPU_P2_FLAGS",
1848e567 67 "CPU_PENTIUMPRO_FLAGS|CPU_MMX_FLAGS" },
40fb9820 68 { "CPU_P3_FLAGS",
1848e567 69 "CPU_P2_FLAGS|CPU_SSE_FLAGS" },
40fb9820 70 { "CPU_P4_FLAGS",
1848e567 71 "CPU_P3_FLAGS|CpuClflush|CPU_SSE2_FLAGS" },
40fb9820 72 { "CPU_NOCONA_FLAGS",
1848e567 73 "CPU_GENERIC64_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
40fb9820 74 { "CPU_CORE_FLAGS",
1848e567 75 "CPU_P4_FLAGS|CpuFISTTP|CPU_SSE3_FLAGS|CpuCX16" },
40fb9820 76 { "CPU_CORE2_FLAGS",
1848e567 77 "CPU_NOCONA_FLAGS|CPU_SSSE3_FLAGS" },
bd5295b2 78 { "CPU_COREI7_FLAGS",
1848e567 79 "CPU_CORE2_FLAGS|CPU_SSE4_2_FLAGS|CpuRdtscp" },
40fb9820 80 { "CPU_K6_FLAGS",
1848e567 81 "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CPU_MMX_FLAGS" },
40fb9820 82 { "CPU_K6_2_FLAGS",
1848e567 83 "CPU_K6_FLAGS|Cpu3dnow" },
40fb9820 84 { "CPU_ATHLON_FLAGS",
1848e567 85 "CPU_K6_2_FLAGS|Cpu686|Cpu687|CpuNop|Cpu3dnowA" },
40fb9820 86 { "CPU_K8_FLAGS",
1848e567 87 "CPU_ATHLON_FLAGS|CpuRdtscp|CPU_SSE2_FLAGS|CpuLM" },
40fb9820 88 { "CPU_AMDFAM10_FLAGS",
1848e567 89 "CPU_K8_FLAGS|CpuFISTTP|CPU_SSE4A_FLAGS|CpuABM" },
68339fdf 90 { "CPU_BDVER1_FLAGS",
59ef5df4 91 "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuRdtscp|CpuCX16|CPU_XOP_FLAGS|CpuABM|CpuLWP|CpuSVME|CpuAES|CpuPCLMUL|CpuLZCNT|CpuPRFCHW" },
4cab4add 92 { "CPU_BDVER2_FLAGS",
1848e567 93 "CPU_BDVER1_FLAGS|CpuFMA|CpuBMI|CpuTBM|CpuF16C" },
5e5c50d3 94 { "CPU_BDVER3_FLAGS",
1848e567 95 "CPU_BDVER2_FLAGS|CpuXsaveopt|CpuFSGSBase" },
c7b0bd56 96 { "CPU_BDVER4_FLAGS",
1848e567 97 "CPU_BDVER3_FLAGS|CpuAVX2|CpuMovbe|CpuBMI2|CpuRdRnd|CpuMWAITX" },
029f3522 98 { "CPU_ZNVER1_FLAGS",
59ef5df4 99 "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" },
a9660a6f
AP		 100 { "CPU_ZNVER2_FLAGS",
101 "CPU_ZNVER1_FLAGS|CpuRDPID|CpuWBNOINVD|CpuCLWB" },
7b458c12 102 { "CPU_BTVER1_FLAGS",
1848e567 103 "CPU_GENERIC64_FLAGS|CpuFISTTP|CpuCX16|CpuRdtscp|CPU_SSSE3_FLAGS|CpuSSE4A|CpuABM|CpuPRFCHW|CpuCX16|CpuClflush|CpuFISTTP|CpuSVME|CpuLZCNT" },
7b458c12 104 { "CPU_BTVER2_FLAGS",
59ef5df4 105 "CPU_BTVER1_FLAGS|CPU_AVX_FLAGS|CpuBMI|CpuF16C|CpuAES|CpuPCLMUL|CpuMovbe|CpuXsaveopt|CpuPRFCHW" },
309d3373
JB		 106 { "CPU_8087_FLAGS",
107 "Cpu8087" },
108 { "CPU_287_FLAGS",
0e0eea78 109 "Cpu287" },
309d3373 110 { "CPU_387_FLAGS",
0e0eea78 111 "Cpu387" },
1848e567
L		 112 { "CPU_687_FLAGS",
113 "CPU_387_FLAGS|Cpu687" },
d871f3f4
L		 114 { "CPU_CMOV_FLAGS",
115 "CpuCMOV" },
116 { "CPU_FXSR_FLAGS",
117 "CpuFXSR" },
bd5295b2
L		 118 { "CPU_CLFLUSH_FLAGS",
119 "CpuClflush" },
22109423
L		 120 { "CPU_NOP_FLAGS",
121 "CpuNop" },
bd5295b2
L		 122 { "CPU_SYSCALL_FLAGS",
123 "CpuSYSCALL" },
40fb9820 124 { "CPU_MMX_FLAGS",
6e041cf4 125 "CpuMMX" },
40fb9820 126 { "CPU_SSE_FLAGS",
6e041cf4 127 "CpuSSE" },
40fb9820 128 { "CPU_SSE2_FLAGS",
1848e567 129 "CPU_SSE_FLAGS|CpuSSE2" },
40fb9820 130 { "CPU_SSE3_FLAGS",
1848e567 131 "CPU_SSE2_FLAGS|CpuSSE3" },
40fb9820 132 { "CPU_SSSE3_FLAGS",
1848e567 133 "CPU_SSE3_FLAGS|CpuSSSE3" },
40fb9820 134 { "CPU_SSE4_1_FLAGS",
1848e567 135 "CPU_SSSE3_FLAGS|CpuSSE4_1" },
40fb9820 136 { "CPU_SSE4_2_FLAGS",
1848e567 137 "CPU_SSE4_1_FLAGS|CpuSSE4_2" },
6305a203
L		 138 { "CPU_VMX_FLAGS",
139 "CpuVMX" },
140 { "CPU_SMX_FLAGS",
141 "CpuSMX" },
f03fe4c1
L		 142 { "CPU_XSAVE_FLAGS",
143 "CpuXsave" },
c7b8aa3a 144 { "CPU_XSAVEOPT_FLAGS",
1848e567 145 "CPU_XSAVE_FLAGS|CpuXsaveopt" },
c0f3af97 146 { "CPU_AES_FLAGS",
1848e567 147 "CPU_SSE2_FLAGS|CpuAES" },
594ab6a3 148 { "CPU_PCLMUL_FLAGS",
1848e567 149 "CPU_SSE2_FLAGS|CpuPCLMUL" },
c0f3af97 150 { "CPU_FMA_FLAGS",
1848e567 151 "CPU_AVX_FLAGS|CpuFMA" },
922d8de8 152 { "CPU_FMA4_FLAGS",
1848e567 153 "CPU_AVX_FLAGS|CpuFMA4" },
5dd85c99 154 { "CPU_XOP_FLAGS",
1848e567 155 "CPU_SSE4A_FLAGS|CPU_FMA4_FLAGS|CpuXOP" },
f88c9eb0 156 { "CPU_LWP_FLAGS",
59ef5df4 157 "CPU_XSAVE_FLAGS|CpuLWP" },
f12dc422
L		 158 { "CPU_BMI_FLAGS",
159 "CpuBMI" },
2a2a0f38
QN		 160 { "CPU_TBM_FLAGS",
161 "CpuTBM" },
f1f8f695
L		 162 { "CPU_MOVBE_FLAGS",
163 "CpuMovbe" },
60aa667e
L		 164 { "CPU_CX16_FLAGS",
165 "CpuCX16" },
1b7f3fb0
L		 166 { "CPU_RDTSCP_FLAGS",
167 "CpuRdtscp" },
f1f8f695
L		 168 { "CPU_EPT_FLAGS",
169 "CpuEPT" },
c7b8aa3a
L		 170 { "CPU_FSGSBASE_FLAGS",
171 "CpuFSGSBase" },
172 { "CPU_RDRND_FLAGS",
173 "CpuRdRnd" },
174 { "CPU_F16C_FLAGS",
1848e567 175 "CPU_AVX_FLAGS|CpuF16C" },
6c30d220
L		 176 { "CPU_BMI2_FLAGS",
177 "CpuBMI2" },
178 { "CPU_LZCNT_FLAGS",
179 "CpuLZCNT" },
42164a71
L		 180 { "CPU_HLE_FLAGS",
181 "CpuHLE" },
182 { "CPU_RTM_FLAGS",
183 "CpuRTM" },
6c30d220
L		 184 { "CPU_INVPCID_FLAGS",
185 "CpuINVPCID" },
8729a6f6
L		 186 { "CPU_VMFUNC_FLAGS",
187 "CpuVMFUNC" },
40fb9820 188 { "CPU_3DNOW_FLAGS",
1848e567 189 "CPU_MMX_FLAGS|Cpu3dnow" },
40fb9820 190 { "CPU_3DNOWA_FLAGS",
1848e567 191 "CPU_3DNOW_FLAGS|Cpu3dnowA" },
40fb9820
L		 192 { "CPU_PADLOCK_FLAGS",
193 "CpuPadLock" },
194 { "CPU_SVME_FLAGS",
195 "CpuSVME" },
196 { "CPU_SSE4A_FLAGS",
1848e567 197 "CPU_SSE3_FLAGS|CpuSSE4a" },
40fb9820 198 { "CPU_ABM_FLAGS",
3629bb00 199 "CpuABM" },
c0f3af97 200 { "CPU_AVX_FLAGS",
59ef5df4 201 "CPU_SSE4_2_FLAGS|CPU_XSAVE_FLAGS|CpuAVX" },
6c30d220 202 { "CPU_AVX2_FLAGS",
1848e567 203 "CPU_AVX_FLAGS|CpuAVX2" },
43234a1e 204 { "CPU_AVX512F_FLAGS",
e951d5ca 205 "CPU_AVX2_FLAGS|CpuAVX512F" },
43234a1e 206 { "CPU_AVX512CD_FLAGS",
1848e567 207 "CPU_AVX512F_FLAGS|CpuAVX512CD" },
43234a1e 208 { "CPU_AVX512ER_FLAGS",
1848e567 209 "CPU_AVX512F_FLAGS|CpuAVX512ER" },
43234a1e 210 { "CPU_AVX512PF_FLAGS",
1848e567 211 "CPU_AVX512F_FLAGS|CpuAVX512PF" },
f3ad7637 212 { "CPU_AVX512DQ_FLAGS",
1848e567 213 "CPU_AVX512F_FLAGS|CpuAVX512DQ" },
f3ad7637 214 { "CPU_AVX512BW_FLAGS",
1848e567 215 "CPU_AVX512F_FLAGS|CpuAVX512BW" },
f3ad7637 216 { "CPU_AVX512VL_FLAGS",
6e041cf4 217 "CPU_AVX512F_FLAGS|CpuAVX512VL" },
f3ad7637 218 { "CPU_AVX512IFMA_FLAGS",
1848e567 219 "CPU_AVX512F_FLAGS|CpuAVX512IFMA" },
f3ad7637 220 { "CPU_AVX512VBMI_FLAGS",
1848e567 221 "CPU_AVX512F_FLAGS|CpuAVX512VBMI" },
920d2ddc
IT		 222 { "CPU_AVX512_4FMAPS_FLAGS",
223 "CPU_AVX512F_FLAGS|CpuAVX512_4FMAPS" },
47acf0bd
IT		 224 { "CPU_AVX512_4VNNIW_FLAGS",
225 "CPU_AVX512F_FLAGS|CpuAVX512_4VNNIW" },
620214f7
IT		 226 { "CPU_AVX512_VPOPCNTDQ_FLAGS",
227 "CPU_AVX512F_FLAGS|CpuAVX512_VPOPCNTDQ" },
53467f57
IT		 228 { "CPU_AVX512_VBMI2_FLAGS",
229 "CPU_AVX512F_FLAGS|CpuAVX512_VBMI2" },
8cfcb765
IT		 230 { "CPU_AVX512_VNNI_FLAGS",
231 "CPU_AVX512F_FLAGS|CpuAVX512_VNNI" },
ee6872be
IT		 232 { "CPU_AVX512_BITALG_FLAGS",
233 "CPU_AVX512F_FLAGS|CpuAVX512_BITALG" },
d6aab7a1
XG		 234 { "CPU_AVX512_BF16_FLAGS",
235 "CPU_AVX512F_FLAGS|CpuAVX512_BF16" },
8a9036a4
L		 236 { "CPU_L1OM_FLAGS",
237 "unknown" },
7a9068fe
L		 238 { "CPU_K1OM_FLAGS",
239 "unknown" },
7b6d09fb
L		 240 { "CPU_IAMCU_FLAGS",
241 "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586" },
e2e1fcde
L		 242 { "CPU_ADX_FLAGS",
243 "CpuADX" },
244 { "CPU_RDSEED_FLAGS",
245 "CpuRdSeed" },
246 { "CPU_PRFCHW_FLAGS",
247 "CpuPRFCHW" },
5c111e37
L		 248 { "CPU_SMAP_FLAGS",
249 "CpuSMAP" },
7e8b059b 250 { "CPU_MPX_FLAGS",
59ef5df4 251 "CPU_XSAVE_FLAGS|CpuMPX" },
a0046408 252 { "CPU_SHA_FLAGS",
1848e567 253 "CPU_SSE2_FLAGS|CpuSHA" },
963f3586
IT		 254 { "CPU_CLFLUSHOPT_FLAGS",
255 "CpuClflushOpt" },
256 { "CPU_XSAVES_FLAGS",
1848e567 257 "CPU_XSAVE_FLAGS|CpuXSAVES" },
963f3586 258 { "CPU_XSAVEC_FLAGS",
1848e567 259 "CPU_XSAVE_FLAGS|CpuXSAVEC" },
dcf893b5
IT		 260 { "CPU_PREFETCHWT1_FLAGS",
261 "CpuPREFETCHWT1" },
2cf200a4
IT		 262 { "CPU_SE1_FLAGS",
263 "CpuSE1" },
c5e7287a
IT		 264 { "CPU_CLWB_FLAGS",
265 "CpuCLWB" },
029f3522
GG		 266 { "CPU_CLZERO_FLAGS",
267 "CpuCLZERO" },
9916071f
AP		 268 { "CPU_MWAITX_FLAGS",
269 "CpuMWAITX" },
8eab4136 270 { "CPU_OSPKE_FLAGS",
59ef5df4 271 "CPU_XSAVE_FLAGS|CpuOSPKE" },
8bc52696 272 { "CPU_RDPID_FLAGS",
1848e567 273 "CpuRDPID" },
6b40c462
L		 274 { "CPU_PTWRITE_FLAGS",
275 "CpuPTWRITE" },
d777820b
IT		 276 { "CPU_IBT_FLAGS",
277 "CpuIBT" },
278 { "CPU_SHSTK_FLAGS",
279 "CpuSHSTK" },
48521003
IT		 280 { "CPU_GFNI_FLAGS",
281 "CpuGFNI" },
8dcf1fad
IT		 282 { "CPU_VAES_FLAGS",
283 "CpuVAES" },
ff1982d5
IT		 284 { "CPU_VPCLMULQDQ_FLAGS",
285 "CpuVPCLMULQDQ" },
3233d7d0
IT		 286 { "CPU_WBNOINVD_FLAGS",
287 "CpuWBNOINVD" },
be3a8dca
IT		 288 { "CPU_PCONFIG_FLAGS",
289 "CpuPCONFIG" },
de89d0a3
IT		 290 { "CPU_WAITPKG_FLAGS",
291 "CpuWAITPKG" },
c48935d7
IT		 292 { "CPU_CLDEMOTE_FLAGS",
293 "CpuCLDEMOTE" },
c0a30a9f
L		 294 { "CPU_MOVDIRI_FLAGS",
295 "CpuMOVDIRI" },
296 { "CPU_MOVDIR64B_FLAGS",
297 "CpuMOVDIR64B" },
5d79adc4
L		 298 { "CPU_ENQCMD_FLAGS",
299 "CpuENQCMD" },
9186c494
L		 300 { "CPU_AVX512_VP2INTERSECT_FLAGS",
301 "CpuAVX512_VP2INTERSECT" },
1848e567
L		 302 { "CPU_ANY_X87_FLAGS",
303 "CPU_ANY_287_FLAGS|Cpu8087" },
304 { "CPU_ANY_287_FLAGS",
305 "CPU_ANY_387_FLAGS|Cpu287" },
306 { "CPU_ANY_387_FLAGS",
307 "CPU_ANY_687_FLAGS|Cpu387" },
308 { "CPU_ANY_687_FLAGS",
309 "Cpu687|CpuFISTTP" },
d871f3f4
L		 310 { "CPU_ANY_CMOV_FLAGS",
311 "CpuCMOV" },
312 { "CPU_ANY_FXSR_FLAGS",
313 "CpuFXSR" },
1848e567
L		 314 { "CPU_ANY_MMX_FLAGS",
315 "CPU_3DNOWA_FLAGS" },
316 { "CPU_ANY_SSE_FLAGS",
317 "CPU_ANY_SSE2_FLAGS|CpuSSE|CpuSSE4a" },
318 { "CPU_ANY_SSE2_FLAGS",
319 "CPU_ANY_SSE3_FLAGS|CpuSSE2" },
320 { "CPU_ANY_SSE3_FLAGS",
321 "CPU_ANY_SSSE3_FLAGS|CpuSSE3" },
322 { "CPU_ANY_SSSE3_FLAGS",
323 "CPU_ANY_SSE4_1_FLAGS|CpuSSSE3" },
324 { "CPU_ANY_SSE4_1_FLAGS",
325 "CPU_ANY_SSE4_2_FLAGS|CpuSSE4_1" },
326 { "CPU_ANY_SSE4_2_FLAGS",
327 "CpuSSE4_2" },
328 { "CPU_ANY_AVX_FLAGS",
329 "CPU_ANY_AVX2_FLAGS|CpuF16C|CpuFMA|CpuFMA4|CpuXOP|CpuAVX" },
330 { "CPU_ANY_AVX2_FLAGS",
89199bb5 331 "CPU_ANY_AVX512F_FLAGS|CpuAVX2" },
144b71e2 332 { "CPU_ANY_AVX512F_FLAGS",
9186c494 333 "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" },
144b71e2
L		 334 { "CPU_ANY_AVX512CD_FLAGS",
335 "CpuAVX512CD" },
336 { "CPU_ANY_AVX512ER_FLAGS",
337 "CpuAVX512ER" },
338 { "CPU_ANY_AVX512PF_FLAGS",
339 "CpuAVX512PF" },
340 { "CPU_ANY_AVX512DQ_FLAGS",
341 "CpuAVX512DQ" },
342 { "CPU_ANY_AVX512BW_FLAGS",
343 "CpuAVX512BW" },
344 { "CPU_ANY_AVX512VL_FLAGS",
345 "CpuAVX512VL" },
346 { "CPU_ANY_AVX512IFMA_FLAGS",
347 "CpuAVX512IFMA" },
348 { "CPU_ANY_AVX512VBMI_FLAGS",
349 "CpuAVX512VBMI" },
920d2ddc
IT		 350 { "CPU_ANY_AVX512_4FMAPS_FLAGS",
351 "CpuAVX512_4FMAPS" },
47acf0bd
IT		 352 { "CPU_ANY_AVX512_4VNNIW_FLAGS",
353 "CpuAVX512_4VNNIW" },
620214f7
IT		 354 { "CPU_ANY_AVX512_VPOPCNTDQ_FLAGS",
355 "CpuAVX512_VPOPCNTDQ" },
d777820b
IT		 356 { "CPU_ANY_IBT_FLAGS",
357 "CpuIBT" },
358 { "CPU_ANY_SHSTK_FLAGS",
359 "CpuSHSTK" },
53467f57
IT		 360 { "CPU_ANY_AVX512_VBMI2_FLAGS",
361 "CpuAVX512_VBMI2" },
8cfcb765
IT		 362 { "CPU_ANY_AVX512_VNNI_FLAGS",
363 "CpuAVX512_VNNI" },
ee6872be
IT		 364 { "CPU_ANY_AVX512_BITALG_FLAGS",
365 "CpuAVX512_BITALG" },
d6aab7a1
XG		 366 { "CPU_ANY_AVX512_BF16_FLAGS",
367 "CpuAVX512_BF16" },
c0a30a9f
L		 368 { "CPU_ANY_MOVDIRI_FLAGS",
369 "CpuMOVDIRI" },
370 { "CPU_ANY_MOVDIR64B_FLAGS",
371 "CpuMOVDIR64B" },
5d79adc4
L		 372 { "CPU_ANY_ENQCMD_FLAGS",
373 "CpuENQCMD" },
9186c494
L		 374 { "CPU_ANY_AVX512_VP2INTERSECT_FLAGS",
375 "CpuAVX512_VP2INTERSECT" },
40fb9820
L		 376};
377
dc821c5f
JB		 378static const initializer operand_type_shorthands[] =
379{
380 { "Reg8", "Reg|Byte" },
381 { "Reg16", "Reg|Word" },
382 { "Reg32", "Reg|Dword" },
383 { "Reg64", "Reg|Qword" },
ca0d63fe
JB		 384 { "FloatAcc", "Acc|Tbyte" },
385 { "FloatReg", "Reg|Tbyte" },
1b54b8d7
JB		 386 { "RegXMM", "RegSIMD|Xmmword" },
387 { "RegYMM", "RegSIMD|Ymmword" },
388 { "RegZMM", "RegSIMD|Zmmword" },
dc821c5f
JB		 389};
390
8acd5377 391static initializer operand_type_init[] =
40fb9820
L		 392{
393 { "OPERAND_TYPE_NONE",
394 "0" },
395 { "OPERAND_TYPE_REG8",
396 "Reg8" },
397 { "OPERAND_TYPE_REG16",
398 "Reg16" },
399 { "OPERAND_TYPE_REG32",
400 "Reg32" },
401 { "OPERAND_TYPE_REG64",
402 "Reg64" },
403 { "OPERAND_TYPE_IMM1",
404 "Imm1" },
405 { "OPERAND_TYPE_IMM8",
406 "Imm8" },
407 { "OPERAND_TYPE_IMM8S",
408 "Imm8S" },
409 { "OPERAND_TYPE_IMM16",
410 "Imm16" },
411 { "OPERAND_TYPE_IMM32",
412 "Imm32" },
413 { "OPERAND_TYPE_IMM32S",
414 "Imm32S" },
415 { "OPERAND_TYPE_IMM64",
416 "Imm64" },
417 { "OPERAND_TYPE_BASEINDEX",
418 "BaseIndex" },
419 { "OPERAND_TYPE_DISP8",
420 "Disp8" },
421 { "OPERAND_TYPE_DISP16",
422 "Disp16" },
423 { "OPERAND_TYPE_DISP32",
424 "Disp32" },
425 { "OPERAND_TYPE_DISP32S",
426 "Disp32S" },
427 { "OPERAND_TYPE_DISP64",
428 "Disp64" },
429 { "OPERAND_TYPE_INOUTPORTREG",
430 "InOutPortReg" },
431 { "OPERAND_TYPE_SHIFTCOUNT",
432 "ShiftCount" },
433 { "OPERAND_TYPE_CONTROL",
434 "Control" },
435 { "OPERAND_TYPE_TEST",
436 "Test" },
437 { "OPERAND_TYPE_DEBUG",
2c703856 438 "Debug" },
40fb9820
L		 439 { "OPERAND_TYPE_FLOATREG",
440 "FloatReg" },
441 { "OPERAND_TYPE_FLOATACC",
442 "FloatAcc" },
443 { "OPERAND_TYPE_SREG2",
444 "SReg2" },
445 { "OPERAND_TYPE_SREG3",
446 "SReg3" },
40fb9820
L		 447 { "OPERAND_TYPE_JUMPABSOLUTE",
448 "JumpAbsolute" },
449 { "OPERAND_TYPE_REGMMX",
450 "RegMMX" },
451 { "OPERAND_TYPE_REGXMM",
452 "RegXMM" },
1508bbf5
JB		 453 { "OPERAND_TYPE_REGYMM",
454 "RegYMM" },
455 { "OPERAND_TYPE_REGZMM",
456 "RegZMM" },
43234a1e
L		 457 { "OPERAND_TYPE_REGMASK",
458 "RegMask" },
40fb9820
L		 459 { "OPERAND_TYPE_ESSEG",
460 "EsSeg" },
2c703856
JB		 461 { "OPERAND_TYPE_ACC8",
462 "Acc|Byte" },
463 { "OPERAND_TYPE_ACC16",
464 "Acc|Word" },
40fb9820 465 { "OPERAND_TYPE_ACC32",
2c703856 466 "Acc|Dword" },
40fb9820 467 { "OPERAND_TYPE_ACC64",
2c703856 468 "Acc|Qword" },
40fb9820
L		 469 { "OPERAND_TYPE_DISP16_32",
470 "Disp16|Disp32" },
471 { "OPERAND_TYPE_ANYDISP",
472 "Disp8|Disp16|Disp32|Disp32S|Disp64" },
473 { "OPERAND_TYPE_IMM16_32",
474 "Imm16|Imm32" },
475 { "OPERAND_TYPE_IMM16_32S",
476 "Imm16|Imm32S" },
477 { "OPERAND_TYPE_IMM16_32_32S",
478 "Imm16|Imm32|Imm32S" },
2f81ff92
L		 479 { "OPERAND_TYPE_IMM32_64",
480 "Imm32|Imm64" },
40fb9820
L		 481 { "OPERAND_TYPE_IMM32_32S_DISP32",
482 "Imm32|Imm32S|Disp32" },
483 { "OPERAND_TYPE_IMM64_DISP64",
484 "Imm64|Disp64" },
485 { "OPERAND_TYPE_IMM32_32S_64_DISP32",
486 "Imm32|Imm32S|Imm64|Disp32" },
487 { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
488 "Imm32|Imm32S|Imm64|Disp32|Disp64" },
a683cc34
SP		 489 { "OPERAND_TYPE_VEC_IMM4",
490 "Vec_Imm4" },
7e8b059b
L		 491 { "OPERAND_TYPE_REGBND",
492 "RegBND" },
40fb9820
L		 493};
494
495typedef struct bitfield
496{
497 int position;
498 int value;
499 const char *name;
500} bitfield;
501
502#define BITFIELD(n) { n, 0, #n }
503
504static bitfield cpu_flags[] =
505{
506 BITFIELD (Cpu186),
507 BITFIELD (Cpu286),
508 BITFIELD (Cpu386),
509 BITFIELD (Cpu486),
510 BITFIELD (Cpu586),
511 BITFIELD (Cpu686),
d871f3f4
L		 512 BITFIELD (CpuCMOV),
513 BITFIELD (CpuFXSR),
bd5295b2 514 BITFIELD (CpuClflush),
22109423 515 BITFIELD (CpuNop),
bd5295b2 516 BITFIELD (CpuSYSCALL),
309d3373
JB		 517 BITFIELD (Cpu8087),
518 BITFIELD (Cpu287),
519 BITFIELD (Cpu387),
520 BITFIELD (Cpu687),
521 BITFIELD (CpuFISTTP),
40fb9820 522 BITFIELD (CpuMMX),
40fb9820
L		 523 BITFIELD (CpuSSE),
524 BITFIELD (CpuSSE2),
525 BITFIELD (CpuSSE3),
526 BITFIELD (CpuSSSE3),
527 BITFIELD (CpuSSE4_1),
528 BITFIELD (CpuSSE4_2),
c0f3af97 529 BITFIELD (CpuAVX),
6c30d220 530 BITFIELD (CpuAVX2),
43234a1e
L		 531 BITFIELD (CpuAVX512F),
532 BITFIELD (CpuAVX512CD),
533 BITFIELD (CpuAVX512ER),
534 BITFIELD (CpuAVX512PF),
b28d1bda 535 BITFIELD (CpuAVX512VL),
90a915bf 536 BITFIELD (CpuAVX512DQ),
1ba585e8 537 BITFIELD (CpuAVX512BW),
8a9036a4 538 BITFIELD (CpuL1OM),
7a9068fe 539 BITFIELD (CpuK1OM),
7b6d09fb 540 BITFIELD (CpuIAMCU),
40fb9820
L		 541 BITFIELD (CpuSSE4a),
542 BITFIELD (Cpu3dnow),
543 BITFIELD (Cpu3dnowA),
544 BITFIELD (CpuPadLock),
545 BITFIELD (CpuSVME),
546 BITFIELD (CpuVMX),
47dd174c 547 BITFIELD (CpuSMX),
40fb9820 548 BITFIELD (CpuABM),
475a2301 549 BITFIELD (CpuXsave),
c7b8aa3a 550 BITFIELD (CpuXsaveopt),
c0f3af97 551 BITFIELD (CpuAES),
594ab6a3 552 BITFIELD (CpuPCLMUL),
c0f3af97 553 BITFIELD (CpuFMA),
f88c9eb0 554 BITFIELD (CpuFMA4),
5dd85c99 555 BITFIELD (CpuXOP),
f88c9eb0 556 BITFIELD (CpuLWP),
f12dc422 557 BITFIELD (CpuBMI),
2a2a0f38 558 BITFIELD (CpuTBM),
c0f3af97 559 BITFIELD (CpuLM),
f1f8f695 560 BITFIELD (CpuMovbe),
60aa667e 561 BITFIELD (CpuCX16),
f1f8f695 562 BITFIELD (CpuEPT),
1b7f3fb0 563 BITFIELD (CpuRdtscp),
c7b8aa3a
L		 564 BITFIELD (CpuFSGSBase),
565 BITFIELD (CpuRdRnd),
566 BITFIELD (CpuF16C),
6c30d220
L		 567 BITFIELD (CpuBMI2),
568 BITFIELD (CpuLZCNT),
42164a71
L		 569 BITFIELD (CpuHLE),
570 BITFIELD (CpuRTM),
6c30d220 571 BITFIELD (CpuINVPCID),
8729a6f6 572 BITFIELD (CpuVMFUNC),
e2e1fcde
L		 573 BITFIELD (CpuRDSEED),
574 BITFIELD (CpuADX),
575 BITFIELD (CpuPRFCHW),
5c111e37 576 BITFIELD (CpuSMAP),
a0046408 577 BITFIELD (CpuSHA),
963f3586
IT		 578 BITFIELD (CpuClflushOpt),
579 BITFIELD (CpuXSAVES),
580 BITFIELD (CpuXSAVEC),
dcf893b5 581 BITFIELD (CpuPREFETCHWT1),
2cf200a4 582 BITFIELD (CpuSE1),
c5e7287a 583 BITFIELD (CpuCLWB),
40fb9820
L		 584 BITFIELD (Cpu64),
585 BITFIELD (CpuNo64),
7e8b059b 586 BITFIELD (CpuMPX),
2cc1b5aa 587 BITFIELD (CpuAVX512IFMA),
14f195c9 588 BITFIELD (CpuAVX512VBMI),
920d2ddc 589 BITFIELD (CpuAVX512_4FMAPS),
47acf0bd 590 BITFIELD (CpuAVX512_4VNNIW),
620214f7 591 BITFIELD (CpuAVX512_VPOPCNTDQ),
53467f57 592 BITFIELD (CpuAVX512_VBMI2),
8cfcb765 593 BITFIELD (CpuAVX512_VNNI),
ee6872be 594 BITFIELD (CpuAVX512_BITALG),
d6aab7a1 595 BITFIELD (CpuAVX512_BF16),
9186c494 596 BITFIELD (CpuAVX512_VP2INTERSECT),
9916071f 597 BITFIELD (CpuMWAITX),
029f3522 598 BITFIELD (CpuCLZERO),
8eab4136 599 BITFIELD (CpuOSPKE),
8bc52696 600 BITFIELD (CpuRDPID),
6b40c462 601 BITFIELD (CpuPTWRITE),
d777820b
IT		 602 BITFIELD (CpuIBT),
603 BITFIELD (CpuSHSTK),
48521003 604 BITFIELD (CpuGFNI),
8dcf1fad 605 BITFIELD (CpuVAES),
ff1982d5 606 BITFIELD (CpuVPCLMULQDQ),
3233d7d0 607 BITFIELD (CpuWBNOINVD),
be3a8dca 608 BITFIELD (CpuPCONFIG),
de89d0a3 609 BITFIELD (CpuWAITPKG),
c48935d7 610 BITFIELD (CpuCLDEMOTE),
c0a30a9f
L		 611 BITFIELD (CpuMOVDIRI),
612 BITFIELD (CpuMOVDIR64B),
5d79adc4 613 BITFIELD (CpuENQCMD),
40fb9820
L		 614#ifdef CpuUnused
615 BITFIELD (CpuUnused),
616#endif
617};
618
619static bitfield opcode_modifiers[] =
620{
621 BITFIELD (D),
622 BITFIELD (W),
86fa6981 623 BITFIELD (Load),
40fb9820
L		 624 BITFIELD (Modrm),
625 BITFIELD (ShortForm),
626 BITFIELD (Jump),
627 BITFIELD (JumpDword),
628 BITFIELD (JumpByte),
629 BITFIELD (JumpInterSegment),
630 BITFIELD (FloatMF),
631 BITFIELD (FloatR),
673fe0f0 632 BITFIELD (Size),
56ffb741 633 BITFIELD (CheckRegSize),
40fb9820
L		 634 BITFIELD (IgnoreSize),
635 BITFIELD (DefaultSize),
636 BITFIELD (No_bSuf),
637 BITFIELD (No_wSuf),
638 BITFIELD (No_lSuf),
639 BITFIELD (No_sSuf),
640 BITFIELD (No_qSuf),
7ce189b3 641 BITFIELD (No_ldSuf),
40fb9820
L		 642 BITFIELD (FWait),
643 BITFIELD (IsString),
7e8b059b 644 BITFIELD (BNDPrefixOk),
04ef582a 645 BITFIELD (NoTrackPrefixOk),
c32fa91d 646 BITFIELD (IsLockable),
40fb9820 647 BITFIELD (RegKludge),
c0f3af97 648 BITFIELD (Implicit1stXmm0),
29c048b6 649 BITFIELD (RepPrefixOk),
42164a71 650 BITFIELD (HLEPrefixOk),
ca61edf2
L		 651 BITFIELD (ToDword),
652 BITFIELD (ToQword),
75c0a438 653 BITFIELD (AddrPrefixOpReg),
40fb9820
L		 654 BITFIELD (IsPrefix),
655 BITFIELD (ImmExt),
656 BITFIELD (NoRex64),
657 BITFIELD (Rex64),
658 BITFIELD (Ugh),
c0f3af97 659 BITFIELD (Vex),
2426c15f 660 BITFIELD (VexVVVV),
1ef99a7b 661 BITFIELD (VexW),
7f399153 662 BITFIELD (VexOpcode),
8cd7925b 663 BITFIELD (VexSources),
6c30d220 664 BITFIELD (VecSIB),
c0f3af97 665 BITFIELD (SSE2AVX),
81f8a913 666 BITFIELD (NoAVX),
43234a1e
L		 667 BITFIELD (EVex),
668 BITFIELD (Masking),
43234a1e
L		 669 BITFIELD (Broadcast),
670 BITFIELD (StaticRounding),
671 BITFIELD (SAE),
672 BITFIELD (Disp8MemShift),
673 BITFIELD (NoDefMask),
920d2ddc 674 BITFIELD (ImplicitQuadGroup),
b6f8c7c4 675 BITFIELD (Optimize),
1efbbeb4 676 BITFIELD (ATTMnemonic),
e1d4d893 677 BITFIELD (ATTSyntax),
5c07affc 678 BITFIELD (IntelSyntax),
e92bae62
L		 679 BITFIELD (AMD64),
680 BITFIELD (Intel64),
40fb9820
L		 681};
682
683static bitfield operand_types[] =
684{
dc821c5f 685 BITFIELD (Reg),
40fb9820 686 BITFIELD (RegMMX),
1b54b8d7 687 BITFIELD (RegSIMD),
43234a1e 688 BITFIELD (RegMask),
94ff3a50 689 BITFIELD (Imm1),
40fb9820
L		 690 BITFIELD (Imm8),
691 BITFIELD (Imm8S),
692 BITFIELD (Imm16),
693 BITFIELD (Imm32),
694 BITFIELD (Imm32S),
695 BITFIELD (Imm64),
40fb9820
L		 696 BITFIELD (BaseIndex),
697 BITFIELD (Disp8),
698 BITFIELD (Disp16),
699 BITFIELD (Disp32),
700 BITFIELD (Disp32S),
701 BITFIELD (Disp64),
702 BITFIELD (InOutPortReg),
703 BITFIELD (ShiftCount),
704 BITFIELD (Control),
705 BITFIELD (Debug),
706 BITFIELD (Test),
707 BITFIELD (SReg2),
708 BITFIELD (SReg3),
709 BITFIELD (Acc),
40fb9820
L		 710 BITFIELD (JumpAbsolute),
711 BITFIELD (EsSeg),
712 BITFIELD (RegMem),
7d5e4556
L		 713 BITFIELD (Byte),
714 BITFIELD (Word),
715 BITFIELD (Dword),
716 BITFIELD (Fword),
717 BITFIELD (Qword),
718 BITFIELD (Tbyte),
719 BITFIELD (Xmmword),
c0f3af97 720 BITFIELD (Ymmword),
43234a1e 721 BITFIELD (Zmmword),
7d5e4556
L		 722 BITFIELD (Unspecified),
723 BITFIELD (Anysize),
a683cc34 724 BITFIELD (Vec_Imm4),
7e8b059b 725 BITFIELD (RegBND),
40fb9820
L		 726#ifdef OTUnused
727 BITFIELD (OTUnused),
728#endif
729};
730
3d4d5afa 731static const char *filename;
7ac20022
JB		 732static i386_cpu_flags active_cpu_flags;
733static int active_isstring;
3d4d5afa 734
40fb9820
L		 735static int
736compare (const void *x, const void *y)
737{
738 const bitfield *xp = (const bitfield *) x;
739 const bitfield *yp = (const bitfield *) y;
740 return xp->position - yp->position;
741}
742
40b8e679
L		 743static void
744fail (const char *message, ...)
745{
746 va_list args;
29c048b6 747
40b8e679 748 va_start (args, message);
a6743a54 749 fprintf (stderr, _("%s: error: "), program_name);
40b8e679
L		 750 vfprintf (stderr, message, args);
751 va_end (args);
752 xexit (1);
753}
754
72ffa0fb
L		 755static void
756process_copyright (FILE *fp)
757{
758 fprintf (fp, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
82704155 759/* Copyright (C) 2007-2019 Free Software Foundation, Inc.\n\
72ffa0fb
L		 760\n\
761 This file is part of the GNU opcodes library.\n\
762\n\
763 This library is free software; you can redistribute it and/or modify\n\
764 it under the terms of the GNU General Public License as published by\n\
765 the Free Software Foundation; either version 3, or (at your option)\n\
766 any later version.\n\
767\n\
768 It is distributed in the hope that it will be useful, but WITHOUT\n\
769 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
770 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
771 License for more details.\n\
772\n\
773 You should have received a copy of the GNU General Public License\n\
774 along with this program; if not, write to the Free Software\n\
775 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
776 MA 02110-1301, USA. */\n");
777}
778
40b8e679
L		 779/* Remove leading white spaces. */
780
781static char *
782remove_leading_whitespaces (char *str)
783{
784 while (ISSPACE (*str))
785 str++;
786 return str;
787}
788
789/* Remove trailing white spaces. */
790
791static void
792remove_trailing_whitespaces (char *str)
793{
794 size_t last = strlen (str);
795
796 if (last == 0)
797 return;
798
799 do
800 {
801 last--;
802 if (ISSPACE (str [last]))
803 str[last] = '\0';
804 else
805 break;
806 }
807 while (last != 0);
808}
809
93b1ec2c 810/* Find next field separated by SEP and terminate it. Return a
40b8e679
L		 811 pointer to the one after it. */
812
813static char *
c587b3f9 814next_field (char *str, char sep, char **next, char *last)
40b8e679
L		 815{
816 char *p;
817
818 p = remove_leading_whitespaces (str);
93b1ec2c 819 for (str = p; *str != sep && *str != '\0'; str++);
40b8e679
L		 820
821 *str = '\0';
822 remove_trailing_whitespaces (p);
823
29c048b6 824 *next = str + 1;
40b8e679 825
c587b3f9
L		 826 if (p >= last)
827 abort ();
828
40b8e679
L		 829 return p;
830}
831
1848e567
L		 832static void set_bitfield (char *, bitfield *, int, unsigned int, int);
833
834static int
dc821c5f
JB		 835set_bitfield_from_shorthand (char *f, bitfield *array, unsigned int size,
836 int lineno)
1848e567
L		 837{
838 char *str, *next, *last;
839 unsigned int i;
840
841 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
842 if (strcmp (cpu_flag_init[i].name, f) == 0)
843 {
844 /* Turn on selective bits. */
845 char *init = xstrdup (cpu_flag_init[i].init);
846 last = init + strlen (init);
847 for (next = init; next && next < last; )
848 {
849 str = next_field (next, '|', &next, last);
850 if (str)
851 set_bitfield (str, array, 1, size, lineno);
852 }
853 free (init);
854 return 0;
855 }
856
dc821c5f
JB		 857 for (i = 0; i < ARRAY_SIZE (operand_type_shorthands); i++)
858 if (strcmp (operand_type_shorthands[i].name, f) == 0)
859 {
860 /* Turn on selective bits. */
861 char *init = xstrdup (operand_type_shorthands[i].init);
862 last = init + strlen (init);
863 for (next = init; next && next < last; )
864 {
865 str = next_field (next, '|', &next, last);
866 if (str)
867 set_bitfield (str, array, 1, size, lineno);
868 }
869 free (init);
870 return 0;
871 }
872
1848e567
L		 873 return -1;
874}
875
40fb9820 876static void
1848e567 877set_bitfield (char *f, bitfield *array, int value,
8a9036a4 878 unsigned int size, int lineno)
40fb9820
L		 879{
880 unsigned int i;
881
309d3373
JB		 882 if (strcmp (f, "CpuFP") == 0)
883 {
8a9036a4
L		 884 set_bitfield("Cpu387", array, value, size, lineno);
885 set_bitfield("Cpu287", array, value, size, lineno);
309d3373
JB		 886 f = "Cpu8087";
887 }
888 else if (strcmp (f, "Mmword") == 0)
7d5e4556
L		 889 f= "Qword";
890 else if (strcmp (f, "Oword") == 0)
891 f= "Xmmword";
40fb9820
L		 892
893 for (i = 0; i < size; i++)
894 if (strcasecmp (array[i].name, f) == 0)
895 {
8a9036a4 896 array[i].value = value;
40fb9820
L		 897 return;
898 }
899
2bf05e57
L		 900 if (value)
901 {
902 const char *v = strchr (f, '=');
903
904 if (v)
905 {
906 size_t n = v - f;
907 char *end;
908
909 for (i = 0; i < size; i++)
910 if (strncasecmp (array[i].name, f, n) == 0)
911 {
912 value = strtol (v + 1, &end, 0);
913 if (*end == '\0')
914 {
915 array[i].value = value;
916 return;
917 }
918 break;
919 }
920 }
921 }
922
dc821c5f
JB		 923 /* Handle shorthands. */
924 if (value == 1 && !set_bitfield_from_shorthand (f, array, size, lineno))
1848e567
L		 925 return;
926
bd5295b2 927 if (lineno != -1)
a6743a54 928 fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
bd5295b2 929 else
a6743a54 930 fail (_("unknown bitfield: %s\n"), f);
40fb9820
L		 931}
932
933static void
934output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
935 int macro, const char *comma, const char *indent)
936{
937 unsigned int i;
938
7ac20022
JB		 939 memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
940
40fb9820
L		 941 fprintf (table, "%s{ { ", indent);
942
943 for (i = 0; i < size - 1; i++)
944 {
10632b79
L		 945 if (((i + 1) % 20) != 0)
946 fprintf (table, "%d, ", flags[i].value);
947 else
948 fprintf (table, "%d,", flags[i].value);
40fb9820
L		 949 if (((i + 1) % 20) == 0)
950 {
951 /* We need \\ for macro. */
952 if (macro)
953 fprintf (table, " \\\n %s", indent);
954 else
955 fprintf (table, "\n %s", indent);
956 }
7ac20022
JB		 957 if (flags[i].value)
958 active_cpu_flags.array[i / 32] |= 1U << (i % 32);
40fb9820
L		 959 }
960
961 fprintf (table, "%d } }%s\n", flags[i].value, comma);
962}
963
964static void
965process_i386_cpu_flag (FILE *table, char *flag, int macro,
bd5295b2
L		 966 const char *comma, const char *indent,
967 int lineno)
40fb9820
L		 968{
969 char *str, *next, *last;
8a9036a4 970 unsigned int i;
40fb9820
L		 971 bitfield flags [ARRAY_SIZE (cpu_flags)];
972
973 /* Copy the default cpu flags. */
974 memcpy (flags, cpu_flags, sizeof (cpu_flags));
975
976 if (strcasecmp (flag, "unknown") == 0)
977 {
40fb9820 978 /* We turn on everything except for cpu64 in case of
8a9036a4
L		 979 CPU_UNKNOWN_FLAGS. */
980 for (i = 0; i < ARRAY_SIZE (flags); i++)
981 if (flags[i].position != Cpu64)
982 flags[i].value = 1;
983 }
984 else if (flag[0] == '~')
985 {
986 last = flag + strlen (flag);
987
988 if (flag[1] == '(')
989 {
990 last -= 1;
991 next = flag + 2;
992 if (*last != ')')
a6743a54 993 fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
8a9036a4
L		 994 lineno, flag);
995 *last = '\0';
996 }
997 else
998 next = flag + 1;
999
1000 /* First we turn on everything except for cpu64. */
40fb9820
L		 1001 for (i = 0; i < ARRAY_SIZE (flags); i++)
1002 if (flags[i].position != Cpu64)
1003 flags[i].value = 1;
8a9036a4
L		 1004
1005 /* Turn off selective bits. */
1006 for (; next && next < last; )
1007 {
1008 str = next_field (next, '|', &next, last);
1009 if (str)
1010 set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
1011 }
40fb9820
L		 1012 }
1013 else if (strcmp (flag, "0"))
1014 {
8a9036a4 1015 /* Turn on selective bits. */
40fb9820
L		 1016 last = flag + strlen (flag);
1017 for (next = flag; next && next < last; )
1018 {
c587b3f9 1019 str = next_field (next, '|', &next, last);
40fb9820 1020 if (str)
8a9036a4 1021 set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
40fb9820
L		 1022 }
1023 }
1024
1025 output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
1026 comma, indent);
1027}
1028
1029static void
1030output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1031{
1032 unsigned int i;
1033
1034 fprintf (table, " { ");
1035
1036 for (i = 0; i < size - 1; i++)
1037 {
10632b79
L		 1038 if (((i + 1) % 20) != 0)
1039 fprintf (table, "%d, ", modifier[i].value);
1040 else
1041 fprintf (table, "%d,", modifier[i].value);
40fb9820
L		 1042 if (((i + 1) % 20) == 0)
1043 fprintf (table, "\n ");
1044 }
1045
1046 fprintf (table, "%d },\n", modifier[i].value);
1047}
1048
4a1b91ea
L		 1049static int
1050adjust_broadcast_modifier (char **opnd)
1051{
1052 char *str, *next, *last, *op;
1053 int bcst_type = INT_MAX;
1054
1055 /* Skip the immediate operand. */
1056 op = opnd[0];
1057 if (strcasecmp(op, "Imm8") == 0)
1058 op = opnd[1];
1059
1060 op = xstrdup (op);
1061 last = op + strlen (op);
1062 for (next = op; next && next < last; )
1063 {
1064 str = next_field (next, '|', &next, last);
1065 if (str)
1066 {
1067 if (strcasecmp(str, "Byte") == 0)
1068 {
1069 /* The smalest broadcast type, no need to check
1070 further. */
1071 bcst_type = BYTE_BROADCAST;
1072 break;
1073 }
1074 else if (strcasecmp(str, "Word") == 0)
1075 {
1076 if (bcst_type > WORD_BROADCAST)
1077 bcst_type = WORD_BROADCAST;
1078 }
1079 else if (strcasecmp(str, "Dword") == 0)
1080 {
1081 if (bcst_type > DWORD_BROADCAST)
1082 bcst_type = DWORD_BROADCAST;
1083 }
1084 else if (strcasecmp(str, "Qword") == 0)
1085 {
1086 if (bcst_type > QWORD_BROADCAST)
1087 bcst_type = QWORD_BROADCAST;
1088 }
1089 }
1090 }
1091 free (op);
1092
1093 if (bcst_type == INT_MAX)
1094 fail (_("unknown broadcast operand: %s\n"), op);
1095
1096 return bcst_type;
1097}
1098
40fb9820 1099static void
4a1b91ea 1100process_i386_opcode_modifier (FILE *table, char *mod, char **opnd, int lineno)
40fb9820
L		 1101{
1102 char *str, *next, *last;
1103 bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1104
7ac20022
JB		 1105 active_isstring = 0;
1106
40fb9820
L		 1107 /* Copy the default opcode modifier. */
1108 memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1109
1110 if (strcmp (mod, "0"))
1111 {
1112 last = mod + strlen (mod);
1113 for (next = mod; next && next < last; )
1114 {
c587b3f9 1115 str = next_field (next, '|', &next, last);
40fb9820 1116 if (str)
7ac20022 1117 {
4a1b91ea
L		 1118 int val = 1;
1119 if (strcasecmp(str, "Broadcast") == 0)
1120 val = adjust_broadcast_modifier (opnd);
1121 set_bitfield (str, modifiers, val, ARRAY_SIZE (modifiers),
8a9036a4 1122 lineno);
7ac20022
JB		 1123 if (strcasecmp(str, "IsString") == 0)
1124 active_isstring = 1;
1125 }
40fb9820
L		 1126 }
1127 }
1128 output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1129}
1130
7ac20022
JB		 1131enum stage {
1132 stage_macros,
1133 stage_opcodes,
1134 stage_registers,
1135};
1136
40fb9820
L		 1137static void
1138output_operand_type (FILE *table, bitfield *types, unsigned int size,
7ac20022 1139 enum stage stage, const char *indent)
40fb9820
L		 1140{
1141 unsigned int i;
1142
1143 fprintf (table, "{ { ");
1144
1145 for (i = 0; i < size - 1; i++)
1146 {
10632b79
L		 1147 if (((i + 1) % 20) != 0)
1148 fprintf (table, "%d, ", types[i].value);
1149 else
1150 fprintf (table, "%d,", types[i].value);
40fb9820
L		 1151 if (((i + 1) % 20) == 0)
1152 {
1153 /* We need \\ for macro. */
7ac20022 1154 if (stage == stage_macros)
10632b79 1155 fprintf (table, " \\\n%s", indent);
40fb9820
L		 1156 else
1157 fprintf (table, "\n%s", indent);
1158 }
1159 }
1160
1161 fprintf (table, "%d } }", types[i].value);
1162}
1163
1164static void
7ac20022 1165process_i386_operand_type (FILE *table, char *op, enum stage stage,
bd5295b2 1166 const char *indent, int lineno)
40fb9820
L		 1167{
1168 char *str, *next, *last;
1169 bitfield types [ARRAY_SIZE (operand_types)];
1170
1171 /* Copy the default operand type. */
1172 memcpy (types, operand_types, sizeof (types));
1173
1174 if (strcmp (op, "0"))
1175 {
7ac20022
JB		 1176 int baseindex = 0;
1177
40fb9820
L		 1178 last = op + strlen (op);
1179 for (next = op; next && next < last; )
1180 {
c587b3f9 1181 str = next_field (next, '|', &next, last);
40fb9820 1182 if (str)
7ac20022
JB		 1183 {
1184 set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1185 if (strcasecmp(str, "BaseIndex") == 0)
1186 baseindex = 1;
1187 }
1188 }
1189
1190 if (stage == stage_opcodes && baseindex && !active_isstring)
1191 {
1192 set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1193 if (!active_cpu_flags.bitfield.cpu64
1194 && !active_cpu_flags.bitfield.cpumpx)
1195 set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1196 set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1197 if (!active_cpu_flags.bitfield.cpuno64)
1198 set_bitfield("Disp32S", types, 1, ARRAY_SIZE (types), lineno);
40fb9820
L		 1199 }
1200 }
7ac20022 1201 output_operand_type (table, types, ARRAY_SIZE (types), stage,
40fb9820
L		 1202 indent);
1203}
1204
c587b3f9
L		 1205static void
1206output_i386_opcode (FILE *table, const char *name, char *str,
bd5295b2 1207 char *last, int lineno)
c587b3f9
L		 1208{
1209 unsigned int i;
1210 char *operands, *base_opcode, *extension_opcode, *opcode_length;
1211 char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1212
1213 /* Find number of operands. */
1214 operands = next_field (str, ',', &str, last);
1215
1216 /* Find base_opcode. */
1217 base_opcode = next_field (str, ',', &str, last);
1218
1219 /* Find extension_opcode. */
1220 extension_opcode = next_field (str, ',', &str, last);
1221
1222 /* Find opcode_length. */
1223 opcode_length = next_field (str, ',', &str, last);
1224
1225 /* Find cpu_flags. */
1226 cpu_flags = next_field (str, ',', &str, last);
1227
1228 /* Find opcode_modifier. */
1229 opcode_modifier = next_field (str, ',', &str, last);
1230
1231 /* Remove the first {. */
1232 str = remove_leading_whitespaces (str);
1233 if (*str != '{')
1234 abort ();
1235 str = remove_leading_whitespaces (str + 1);
1236
1237 i = strlen (str);
1238
1239 /* There are at least "X}". */
1240 if (i < 2)
1241 abort ();
1242
1243 /* Remove trailing white spaces and }. */
1244 do
1245 {
1246 i--;
1247 if (ISSPACE (str[i]) || str[i] == '}')
1248 str[i] = '\0';
1249 else
1250 break;
1251 }
1252 while (i != 0);
1253
1254 last = str + i;
1255
1256 /* Find operand_types. */
1257 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1258 {
1259 if (str >= last)
1260 {
1261 operand_types [i] = NULL;
1262 break;
1263 }
1264
1265 operand_types [i] = next_field (str, ',', &str, last);
1266 if (*operand_types[i] == '0')
1267 {
1268 if (i != 0)
1269 operand_types[i] = NULL;
1270 break;
1271 }
1272 }
1273
1274 fprintf (table, " { \"%s\", %s, %s, %s, %s,\n",
1275 name, operands, base_opcode, extension_opcode,
1276 opcode_length);
1277
bd5295b2 1278 process_i386_cpu_flag (table, cpu_flags, 0, ",", " ", lineno);
c587b3f9 1279
4a1b91ea 1280 process_i386_opcode_modifier (table, opcode_modifier, operand_types, lineno);
c587b3f9
L		 1281
1282 fprintf (table, " { ");
1283
1284 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1285 {
1286 if (operand_types[i] == NULL || *operand_types[i] == '0')
1287 {
1288 if (i == 0)
7ac20022
JB		 1289 process_i386_operand_type (table, "0", stage_opcodes, "\t ",
1290 lineno);
c587b3f9
L		 1291 break;
1292 }
1293
1294 if (i != 0)
1295 fprintf (table, ",\n ");
1296
7ac20022 1297 process_i386_operand_type (table, operand_types[i], stage_opcodes,
bd5295b2 1298 "\t ", lineno);
c587b3f9
L		 1299 }
1300 fprintf (table, " } },\n");
1301}
1302
1303struct opcode_hash_entry
1304{
1305 struct opcode_hash_entry *next;
1306 char *name;
1307 char *opcode;
bd5295b2 1308 int lineno;
c587b3f9
L		 1309};
1310
1311/* Calculate the hash value of an opcode hash entry P. */
1312
1313static hashval_t
1314opcode_hash_hash (const void *p)
1315{
1316 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1317 return htab_hash_string (entry->name);
1318}
1319
1320/* Compare a string Q against an opcode hash entry P. */
1321
1322static int
1323opcode_hash_eq (const void *p, const void *q)
1324{
1325 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1326 const char *name = (const char *) q;
1327 return strcmp (name, entry->name) == 0;
1328}
1329
40b8e679 1330static void
72ffa0fb 1331process_i386_opcodes (FILE *table)
40b8e679 1332{
3d4d5afa 1333 FILE *fp;
40b8e679 1334 char buf[2048];
c587b3f9
L		 1335 unsigned int i, j;
1336 char *str, *p, *last, *name;
1337 struct opcode_hash_entry **hash_slot, **entry, *next;
1338 htab_t opcode_hash_table;
1339 struct opcode_hash_entry **opcode_array;
1340 unsigned int opcode_array_size = 1024;
c30be56e 1341 int lineno = 0, marker = 0;
40b8e679 1342
3d4d5afa 1343 filename = "i386-opc.tbl";
c30be56e 1344 fp = stdin;
40b8e679 1345
c587b3f9
L		 1346 i = 0;
1347 opcode_array = (struct opcode_hash_entry **)
1348 xmalloc (sizeof (*opcode_array) * opcode_array_size);
1349
1350 opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1351 opcode_hash_eq, NULL,
1352 xcalloc, free);
1353
34edb9ad 1354 fprintf (table, "\n/* i386 opcode table. */\n\n");
d3ce72d0 1355 fprintf (table, "const insn_template i386_optab[] =\n{\n");
40b8e679 1356
c587b3f9 1357 /* Put everything on opcode array. */
40b8e679
L		 1358 while (!feof (fp))
1359 {
1360 if (fgets (buf, sizeof (buf), fp) == NULL)
1361 break;
1362
3d4d5afa
L		 1363 lineno++;
1364
40b8e679
L		 1365 p = remove_leading_whitespaces (buf);
1366
1367 /* Skip comments. */
1368 str = strstr (p, "//");
1369 if (str != NULL)
1370 str[0] = '\0';
1371
1372 /* Remove trailing white spaces. */
1373 remove_trailing_whitespaces (p);
1374
1375 switch (p[0])
1376 {
1377 case '#':
c30be56e
JB		 1378 if (!strcmp("### MARKER ###", buf))
1379 marker = 1;
1380 else
1381 {
1382 /* Since we ignore all included files (we only care about their
1383 #define-s here), we don't need to monitor filenames. The final
1384 line number directive is going to refer to the main source file
1385 again. */
1386 char *end;
1387 unsigned long ln;
1388
1389 p = remove_leading_whitespaces (p + 1);
1390 if (!strncmp(p, "line", 4))
1391 p += 4;
1392 ln = strtoul (p, &end, 10);
1393 if (ln > 1 && ln < INT_MAX
1394 && *remove_leading_whitespaces (end) == '"')
1395 lineno = ln - 1;
1396 }
c587b3f9 1397 /* Ignore comments. */
40b8e679
L		 1398 case '\0':
1399 continue;
1400 break;
1401 default:
c30be56e
JB		 1402 if (!marker)
1403 continue;
40b8e679
L		 1404 break;
1405 }
1406
1407 last = p + strlen (p);
1408
1409 /* Find name. */
c587b3f9 1410 name = next_field (p, ',', &str, last);
40b8e679 1411
c587b3f9
L		 1412 /* Get the slot in hash table. */
1413 hash_slot = (struct opcode_hash_entry **)
1414 htab_find_slot_with_hash (opcode_hash_table, name,
1415 htab_hash_string (name),
1416 INSERT);
40b8e679 1417
c587b3f9 1418 if (*hash_slot == NULL)
40b8e679 1419 {
c587b3f9
L		 1420 /* It is the new one. Put it on opcode array. */
1421 if (i >= opcode_array_size)
40b8e679 1422 {
c587b3f9
L		 1423 /* Grow the opcode array when needed. */
1424 opcode_array_size += 1024;
1425 opcode_array = (struct opcode_hash_entry **)
1426 xrealloc (opcode_array,
1427 sizeof (*opcode_array) * opcode_array_size);
40b8e679
L		 1428 }
1429
c587b3f9
L		 1430 opcode_array[i] = (struct opcode_hash_entry *)
1431 xmalloc (sizeof (struct opcode_hash_entry));
1432 opcode_array[i]->next = NULL;
1433 opcode_array[i]->name = xstrdup (name);
1434 opcode_array[i]->opcode = xstrdup (str);
bd5295b2 1435 opcode_array[i]->lineno = lineno;
c587b3f9
L		 1436 *hash_slot = opcode_array[i];
1437 i++;
40b8e679 1438 }
c587b3f9 1439 else
40b8e679 1440 {
c587b3f9
L		 1441 /* Append it to the existing one. */
1442 entry = hash_slot;
1443 while ((*entry) != NULL)
1444 entry = &(*entry)->next;
1445 *entry = (struct opcode_hash_entry *)
1446 xmalloc (sizeof (struct opcode_hash_entry));
1447 (*entry)->next = NULL;
1448 (*entry)->name = (*hash_slot)->name;
1449 (*entry)->opcode = xstrdup (str);
bd5295b2 1450 (*entry)->lineno = lineno;
c587b3f9
L		 1451 }
1452 }
40b8e679 1453
c587b3f9
L		 1454 /* Process opcode array. */
1455 for (j = 0; j < i; j++)
1456 {
1457 for (next = opcode_array[j]; next; next = next->next)
1458 {
1459 name = next->name;
1460 str = next->opcode;
bd5295b2 1461 lineno = next->lineno;
c587b3f9 1462 last = str + strlen (str);
bd5295b2 1463 output_i386_opcode (table, name, str, last, lineno);
40b8e679 1464 }
40b8e679
L		 1465 }
1466
34edb9ad
L		 1467 fclose (fp);
1468
4dffcebc 1469 fprintf (table, " { NULL, 0, 0, 0, 0,\n");
40fb9820 1470
bd5295b2 1471 process_i386_cpu_flag (table, "0", 0, ",", " ", -1);
40fb9820 1472
4a1b91ea 1473 process_i386_opcode_modifier (table, "0", NULL, -1);
29c048b6 1474
40fb9820 1475 fprintf (table, " { ");
7ac20022 1476 process_i386_operand_type (table, "0", stage_opcodes, "\t ", -1);
40fb9820
L		 1477 fprintf (table, " } }\n");
1478
34edb9ad 1479 fprintf (table, "};\n");
40b8e679
L		 1480}
1481
1482static void
72ffa0fb 1483process_i386_registers (FILE *table)
40b8e679 1484{
3d4d5afa 1485 FILE *fp;
40b8e679
L		 1486 char buf[2048];
1487 char *str, *p, *last;
1488 char *reg_name, *reg_type, *reg_flags, *reg_num;
a60de03c 1489 char *dw2_32_num, *dw2_64_num;
bd5295b2 1490 int lineno = 0;
40b8e679 1491
3d4d5afa
L		 1492 filename = "i386-reg.tbl";
1493 fp = fopen (filename, "r");
40b8e679 1494 if (fp == NULL)
34edb9ad 1495 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
40fb9820 1496 xstrerror (errno));
40b8e679 1497
34edb9ad
L		 1498 fprintf (table, "\n/* i386 register table. */\n\n");
1499 fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
40b8e679
L		 1500
1501 while (!feof (fp))
1502 {
1503 if (fgets (buf, sizeof (buf), fp) == NULL)
1504 break;
1505
3d4d5afa
L		 1506 lineno++;
1507
40b8e679
L		 1508 p = remove_leading_whitespaces (buf);
1509
1510 /* Skip comments. */
1511 str = strstr (p, "//");
1512 if (str != NULL)
1513 str[0] = '\0';
1514
1515 /* Remove trailing white spaces. */
1516 remove_trailing_whitespaces (p);
1517
1518 switch (p[0])
1519 {
1520 case '#':
34edb9ad 1521 fprintf (table, "%s\n", p);
40b8e679
L		 1522 case '\0':
1523 continue;
1524 break;
1525 default:
1526 break;
1527 }
1528
1529 last = p + strlen (p);
1530
1531 /* Find reg_name. */
c587b3f9 1532 reg_name = next_field (p, ',', &str, last);
40b8e679
L		 1533
1534 /* Find reg_type. */
c587b3f9 1535 reg_type = next_field (str, ',', &str, last);
40b8e679
L		 1536
1537 /* Find reg_flags. */
c587b3f9 1538 reg_flags = next_field (str, ',', &str, last);
40b8e679
L		 1539
1540 /* Find reg_num. */
c587b3f9 1541 reg_num = next_field (str, ',', &str, last);
a60de03c 1542
40fb9820
L		 1543 fprintf (table, " { \"%s\",\n ", reg_name);
1544
7ac20022
JB		 1545 process_i386_operand_type (table, reg_type, stage_registers, "\t",
1546 lineno);
40fb9820 1547
a60de03c 1548 /* Find 32-bit Dwarf2 register number. */
c587b3f9 1549 dw2_32_num = next_field (str, ',', &str, last);
a60de03c
JB		 1550
1551 /* Find 64-bit Dwarf2 register number. */
c587b3f9 1552 dw2_64_num = next_field (str, ',', &str, last);
a60de03c
JB		 1553
1554 fprintf (table, ",\n %s, %s, { %s, %s } },\n",
1555 reg_flags, reg_num, dw2_32_num, dw2_64_num);
40b8e679
L		 1556 }
1557
34edb9ad
L		 1558 fclose (fp);
1559
1560 fprintf (table, "};\n");
40b8e679 1561
34edb9ad 1562 fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
40b8e679
L		 1563}
1564
40fb9820
L		 1565static void
1566process_i386_initializers (void)
1567{
1568 unsigned int i;
1569 FILE *fp = fopen ("i386-init.h", "w");
1570 char *init;
1571
1572 if (fp == NULL)
1573 fail (_("can't create i386-init.h, errno = %s\n"),
1574 xstrerror (errno));
1575
1576 process_copyright (fp);
1577
1578 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1579 {
1580 fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1581 init = xstrdup (cpu_flag_init[i].init);
bd5295b2 1582 process_i386_cpu_flag (fp, init, 1, "", " ", -1);
40fb9820
L		 1583 free (init);
1584 }
1585
1586 for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1587 {
1588 fprintf (fp, "\n\n#define %s \\\n ", operand_type_init[i].name);
1589 init = xstrdup (operand_type_init[i].init);
7ac20022 1590 process_i386_operand_type (fp, init, stage_macros, " ", -1);
40fb9820
L		 1591 free (init);
1592 }
1593 fprintf (fp, "\n");
1594
1595 fclose (fp);
1596}
1597
40b8e679
L		 1598/* Program options. */
1599#define OPTION_SRCDIR 200
1600
29c048b6 1601struct option long_options[] =
40b8e679
L		 1602{
1603 {"srcdir", required_argument, NULL, OPTION_SRCDIR},
1604 {"debug", no_argument, NULL, 'd'},
1605 {"version", no_argument, NULL, 'V'},
1606 {"help", no_argument, NULL, 'h'},
1607 {0, no_argument, NULL, 0}
1608};
1609
1610static void
1611print_version (void)
1612{
1613 printf ("%s: version 1.0\n", program_name);
1614 xexit (0);
1615}
1616
1617static void
1618usage (FILE * stream, int status)
1619{
1620 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1621 program_name);
1622 xexit (status);
1623}
1624
1625int
1626main (int argc, char **argv)
1627{
1628 extern int chdir (char *);
1629 char *srcdir = NULL;
8b40d594 1630 int c;
e92bae62 1631 unsigned int i, cpumax;
72ffa0fb 1632 FILE *table;
29c048b6 1633
40b8e679
L		 1634 program_name = *argv;
1635 xmalloc_set_program_name (program_name);
1636
1637 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1638 switch (c)
1639 {
1640 case OPTION_SRCDIR:
1641 srcdir = optarg;
1642 break;
1643 case 'V':
1644 case 'v':
1645 print_version ();
1646 break;
1647 case 'd':
1648 debug = 1;
1649 break;
1650 case 'h':
1651 case '?':
1652 usage (stderr, 0);
1653 default:
1654 case 0:
1655 break;
1656 }
1657
1658 if (optind != argc)
1659 usage (stdout, 1);
1660
29c048b6 1661 if (srcdir != NULL)
40b8e679
L		 1662 if (chdir (srcdir) != 0)
1663 fail (_("unable to change directory to \"%s\", errno = %s\n"),
40fb9820
L		 1664 srcdir, xstrerror (errno));
1665
e92bae62
L		 1666 /* cpu_flags isn't sorted by position. */
1667 cpumax = 0;
1668 for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
1669 if (cpu_flags[i].position > cpumax)
1670 cpumax = cpu_flags[i].position;
1671
40fb9820 1672 /* Check the unused bitfield in i386_cpu_flags. */
e89c5eaa 1673#ifdef CpuUnused
e92bae62
L		 1674 if ((cpumax - 1) != CpuMax)
1675 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1676#else
e92bae62
L		 1677 if (cpumax != CpuMax)
1678 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1679
8b40d594
L		 1680 c = CpuNumOfBits - CpuMax - 1;
1681 if (c)
1682 fail (_("%d unused bits in i386_cpu_flags.\n"), c);
40fb9820
L		 1683#endif
1684
1685 /* Check the unused bitfield in i386_operand_type. */
1686#ifndef OTUnused
8b40d594
L		 1687 c = OTNumOfBits - OTMax - 1;
1688 if (c)
1689 fail (_("%d unused bits in i386_operand_type.\n"), c);
40fb9820
L		 1690#endif
1691
1692 qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1693 compare);
1694
1695 qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1696 sizeof (opcode_modifiers [0]), compare);
1697
1698 qsort (operand_types, ARRAY_SIZE (operand_types),
1699 sizeof (operand_types [0]), compare);
40b8e679 1700
34edb9ad
L		 1701 table = fopen ("i386-tbl.h", "w");
1702 if (table == NULL)
40fb9820
L		 1703 fail (_("can't create i386-tbl.h, errno = %s\n"),
1704 xstrerror (errno));
34edb9ad 1705
72ffa0fb 1706 process_copyright (table);
40b8e679 1707
72ffa0fb
L		 1708 process_i386_opcodes (table);
1709 process_i386_registers (table);
40fb9820 1710 process_i386_initializers ();
40b8e679 1711
34edb9ad
L		 1712 fclose (table);
1713
40b8e679
L		 1714 exit (0);
1715}
GDB Binutils - Deliverables
This page took 0.656736 seconds and 4 git commands to generate.