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