projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Introduce complete_nested_command_line
[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",
438 "FloatReg" },
439 { "OPERAND_TYPE_FLOATREG",
440 "FloatReg" },
441 { "OPERAND_TYPE_FLOATACC",
442 "FloatAcc" },
443 { "OPERAND_TYPE_SREG2",
444 "SReg2" },
445 { "OPERAND_TYPE_SREG3",
446 "SReg3" },
447 { "OPERAND_TYPE_ACC",
448 "Acc" },
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" },
463 { "OPERAND_TYPE_ACC32",
7d5e4556 464 "Reg32|Acc|Dword" },
40fb9820 465 { "OPERAND_TYPE_ACC64",
7d5e4556 466 "Reg64|Acc|Qword" },
40fb9820
L		 467 { "OPERAND_TYPE_DISP16_32",
468 "Disp16|Disp32" },
469 { "OPERAND_TYPE_ANYDISP",
470 "Disp8|Disp16|Disp32|Disp32S|Disp64" },
471 { "OPERAND_TYPE_IMM16_32",
472 "Imm16|Imm32" },
473 { "OPERAND_TYPE_IMM16_32S",
474 "Imm16|Imm32S" },
475 { "OPERAND_TYPE_IMM16_32_32S",
476 "Imm16|Imm32|Imm32S" },
2f81ff92
L		 477 { "OPERAND_TYPE_IMM32_64",
478 "Imm32|Imm64" },
40fb9820
L		 479 { "OPERAND_TYPE_IMM32_32S_DISP32",
480 "Imm32|Imm32S|Disp32" },
481 { "OPERAND_TYPE_IMM64_DISP64",
482 "Imm64|Disp64" },
483 { "OPERAND_TYPE_IMM32_32S_64_DISP32",
484 "Imm32|Imm32S|Imm64|Disp32" },
485 { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
486 "Imm32|Imm32S|Imm64|Disp32|Disp64" },
a683cc34
SP		 487 { "OPERAND_TYPE_VEC_IMM4",
488 "Vec_Imm4" },
7e8b059b
L		 489 { "OPERAND_TYPE_REGBND",
490 "RegBND" },
40fb9820
L		 491};
492
493typedef struct bitfield
494{
495 int position;
496 int value;
497 const char *name;
498} bitfield;
499
500#define BITFIELD(n) { n, 0, #n }
501
502static bitfield cpu_flags[] =
503{
504 BITFIELD (Cpu186),
505 BITFIELD (Cpu286),
506 BITFIELD (Cpu386),
507 BITFIELD (Cpu486),
508 BITFIELD (Cpu586),
509 BITFIELD (Cpu686),
d871f3f4
L		 510 BITFIELD (CpuCMOV),
511 BITFIELD (CpuFXSR),
bd5295b2 512 BITFIELD (CpuClflush),
22109423 513 BITFIELD (CpuNop),
bd5295b2 514 BITFIELD (CpuSYSCALL),
309d3373
JB		 515 BITFIELD (Cpu8087),
516 BITFIELD (Cpu287),
517 BITFIELD (Cpu387),
518 BITFIELD (Cpu687),
519 BITFIELD (CpuFISTTP),
40fb9820 520 BITFIELD (CpuMMX),
40fb9820
L		 521 BITFIELD (CpuSSE),
522 BITFIELD (CpuSSE2),
523 BITFIELD (CpuSSE3),
524 BITFIELD (CpuSSSE3),
525 BITFIELD (CpuSSE4_1),
526 BITFIELD (CpuSSE4_2),
c0f3af97 527 BITFIELD (CpuAVX),
6c30d220 528 BITFIELD (CpuAVX2),
43234a1e
L		 529 BITFIELD (CpuAVX512F),
530 BITFIELD (CpuAVX512CD),
531 BITFIELD (CpuAVX512ER),
532 BITFIELD (CpuAVX512PF),
b28d1bda 533 BITFIELD (CpuAVX512VL),
90a915bf 534 BITFIELD (CpuAVX512DQ),
1ba585e8 535 BITFIELD (CpuAVX512BW),
8a9036a4 536 BITFIELD (CpuL1OM),
7a9068fe 537 BITFIELD (CpuK1OM),
7b6d09fb 538 BITFIELD (CpuIAMCU),
40fb9820
L		 539 BITFIELD (CpuSSE4a),
540 BITFIELD (Cpu3dnow),
541 BITFIELD (Cpu3dnowA),
542 BITFIELD (CpuPadLock),
543 BITFIELD (CpuSVME),
544 BITFIELD (CpuVMX),
47dd174c 545 BITFIELD (CpuSMX),
40fb9820 546 BITFIELD (CpuABM),
475a2301 547 BITFIELD (CpuXsave),
c7b8aa3a 548 BITFIELD (CpuXsaveopt),
c0f3af97 549 BITFIELD (CpuAES),
594ab6a3 550 BITFIELD (CpuPCLMUL),
c0f3af97 551 BITFIELD (CpuFMA),
f88c9eb0 552 BITFIELD (CpuFMA4),
5dd85c99 553 BITFIELD (CpuXOP),
f88c9eb0 554 BITFIELD (CpuLWP),
f12dc422 555 BITFIELD (CpuBMI),
2a2a0f38 556 BITFIELD (CpuTBM),
c0f3af97 557 BITFIELD (CpuLM),
f1f8f695 558 BITFIELD (CpuMovbe),
60aa667e 559 BITFIELD (CpuCX16),
f1f8f695 560 BITFIELD (CpuEPT),
1b7f3fb0 561 BITFIELD (CpuRdtscp),
c7b8aa3a
L		 562 BITFIELD (CpuFSGSBase),
563 BITFIELD (CpuRdRnd),
564 BITFIELD (CpuF16C),
6c30d220
L		 565 BITFIELD (CpuBMI2),
566 BITFIELD (CpuLZCNT),
42164a71
L		 567 BITFIELD (CpuHLE),
568 BITFIELD (CpuRTM),
6c30d220 569 BITFIELD (CpuINVPCID),
8729a6f6 570 BITFIELD (CpuVMFUNC),
e2e1fcde
L		 571 BITFIELD (CpuRDSEED),
572 BITFIELD (CpuADX),
573 BITFIELD (CpuPRFCHW),
5c111e37 574 BITFIELD (CpuSMAP),
a0046408 575 BITFIELD (CpuSHA),
963f3586
IT		 576 BITFIELD (CpuClflushOpt),
577 BITFIELD (CpuXSAVES),
578 BITFIELD (CpuXSAVEC),
dcf893b5 579 BITFIELD (CpuPREFETCHWT1),
2cf200a4 580 BITFIELD (CpuSE1),
c5e7287a 581 BITFIELD (CpuCLWB),
40fb9820
L		 582 BITFIELD (Cpu64),
583 BITFIELD (CpuNo64),
7e8b059b 584 BITFIELD (CpuMPX),
2cc1b5aa 585 BITFIELD (CpuAVX512IFMA),
14f195c9 586 BITFIELD (CpuAVX512VBMI),
920d2ddc 587 BITFIELD (CpuAVX512_4FMAPS),
47acf0bd 588 BITFIELD (CpuAVX512_4VNNIW),
620214f7 589 BITFIELD (CpuAVX512_VPOPCNTDQ),
53467f57 590 BITFIELD (CpuAVX512_VBMI2),
8cfcb765 591 BITFIELD (CpuAVX512_VNNI),
ee6872be 592 BITFIELD (CpuAVX512_BITALG),
d6aab7a1 593 BITFIELD (CpuAVX512_BF16),
9186c494 594 BITFIELD (CpuAVX512_VP2INTERSECT),
9916071f 595 BITFIELD (CpuMWAITX),
029f3522 596 BITFIELD (CpuCLZERO),
8eab4136 597 BITFIELD (CpuOSPKE),
8bc52696 598 BITFIELD (CpuRDPID),
6b40c462 599 BITFIELD (CpuPTWRITE),
d777820b
IT		 600 BITFIELD (CpuIBT),
601 BITFIELD (CpuSHSTK),
48521003 602 BITFIELD (CpuGFNI),
8dcf1fad 603 BITFIELD (CpuVAES),
ff1982d5 604 BITFIELD (CpuVPCLMULQDQ),
3233d7d0 605 BITFIELD (CpuWBNOINVD),
be3a8dca 606 BITFIELD (CpuPCONFIG),
de89d0a3 607 BITFIELD (CpuWAITPKG),
c48935d7 608 BITFIELD (CpuCLDEMOTE),
c0a30a9f
L		 609 BITFIELD (CpuMOVDIRI),
610 BITFIELD (CpuMOVDIR64B),
5d79adc4 611 BITFIELD (CpuENQCMD),
40fb9820
L		 612#ifdef CpuUnused
613 BITFIELD (CpuUnused),
614#endif
615};
616
617static bitfield opcode_modifiers[] =
618{
619 BITFIELD (D),
620 BITFIELD (W),
86fa6981 621 BITFIELD (Load),
40fb9820
L		 622 BITFIELD (Modrm),
623 BITFIELD (ShortForm),
624 BITFIELD (Jump),
625 BITFIELD (JumpDword),
626 BITFIELD (JumpByte),
627 BITFIELD (JumpInterSegment),
628 BITFIELD (FloatMF),
629 BITFIELD (FloatR),
673fe0f0 630 BITFIELD (Size),
56ffb741 631 BITFIELD (CheckRegSize),
40fb9820
L		 632 BITFIELD (IgnoreSize),
633 BITFIELD (DefaultSize),
634 BITFIELD (No_bSuf),
635 BITFIELD (No_wSuf),
636 BITFIELD (No_lSuf),
637 BITFIELD (No_sSuf),
638 BITFIELD (No_qSuf),
7ce189b3 639 BITFIELD (No_ldSuf),
40fb9820
L		 640 BITFIELD (FWait),
641 BITFIELD (IsString),
7e8b059b 642 BITFIELD (BNDPrefixOk),
04ef582a 643 BITFIELD (NoTrackPrefixOk),
c32fa91d 644 BITFIELD (IsLockable),
40fb9820 645 BITFIELD (RegKludge),
c0f3af97 646 BITFIELD (Implicit1stXmm0),
29c048b6 647 BITFIELD (RepPrefixOk),
42164a71 648 BITFIELD (HLEPrefixOk),
ca61edf2
L		 649 BITFIELD (ToDword),
650 BITFIELD (ToQword),
75c0a438 651 BITFIELD (AddrPrefixOpReg),
40fb9820
L		 652 BITFIELD (IsPrefix),
653 BITFIELD (ImmExt),
654 BITFIELD (NoRex64),
655 BITFIELD (Rex64),
656 BITFIELD (Ugh),
c0f3af97 657 BITFIELD (Vex),
2426c15f 658 BITFIELD (VexVVVV),
1ef99a7b 659 BITFIELD (VexW),
7f399153 660 BITFIELD (VexOpcode),
8cd7925b 661 BITFIELD (VexSources),
6c30d220 662 BITFIELD (VecSIB),
c0f3af97 663 BITFIELD (SSE2AVX),
81f8a913 664 BITFIELD (NoAVX),
43234a1e
L		 665 BITFIELD (EVex),
666 BITFIELD (Masking),
43234a1e
L		 667 BITFIELD (Broadcast),
668 BITFIELD (StaticRounding),
669 BITFIELD (SAE),
670 BITFIELD (Disp8MemShift),
671 BITFIELD (NoDefMask),
920d2ddc 672 BITFIELD (ImplicitQuadGroup),
b6f8c7c4 673 BITFIELD (Optimize),
1efbbeb4 674 BITFIELD (ATTMnemonic),
e1d4d893 675 BITFIELD (ATTSyntax),
5c07affc 676 BITFIELD (IntelSyntax),
e92bae62
L		 677 BITFIELD (AMD64),
678 BITFIELD (Intel64),
40fb9820
L		 679};
680
681static bitfield operand_types[] =
682{
dc821c5f 683 BITFIELD (Reg),
40fb9820 684 BITFIELD (RegMMX),
1b54b8d7 685 BITFIELD (RegSIMD),
43234a1e 686 BITFIELD (RegMask),
94ff3a50 687 BITFIELD (Imm1),
40fb9820
L		 688 BITFIELD (Imm8),
689 BITFIELD (Imm8S),
690 BITFIELD (Imm16),
691 BITFIELD (Imm32),
692 BITFIELD (Imm32S),
693 BITFIELD (Imm64),
40fb9820
L		 694 BITFIELD (BaseIndex),
695 BITFIELD (Disp8),
696 BITFIELD (Disp16),
697 BITFIELD (Disp32),
698 BITFIELD (Disp32S),
699 BITFIELD (Disp64),
700 BITFIELD (InOutPortReg),
701 BITFIELD (ShiftCount),
702 BITFIELD (Control),
703 BITFIELD (Debug),
704 BITFIELD (Test),
705 BITFIELD (SReg2),
706 BITFIELD (SReg3),
707 BITFIELD (Acc),
40fb9820
L		 708 BITFIELD (JumpAbsolute),
709 BITFIELD (EsSeg),
710 BITFIELD (RegMem),
7d5e4556
L		 711 BITFIELD (Byte),
712 BITFIELD (Word),
713 BITFIELD (Dword),
714 BITFIELD (Fword),
715 BITFIELD (Qword),
716 BITFIELD (Tbyte),
717 BITFIELD (Xmmword),
c0f3af97 718 BITFIELD (Ymmword),
43234a1e 719 BITFIELD (Zmmword),
7d5e4556
L		 720 BITFIELD (Unspecified),
721 BITFIELD (Anysize),
a683cc34 722 BITFIELD (Vec_Imm4),
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
e92bae62
L		 1672 if ((cpumax - 1) != CpuMax)
1673 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1674#else
e92bae62
L		 1675 if (cpumax != CpuMax)
1676 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1677
8b40d594
L		 1678 c = CpuNumOfBits - CpuMax - 1;
1679 if (c)
1680 fail (_("%d unused bits in i386_cpu_flags.\n"), c);
40fb9820
L		 1681#endif
1682
1683 /* Check the unused bitfield in i386_operand_type. */
1684#ifndef OTUnused
8b40d594
L		 1685 c = OTNumOfBits - OTMax - 1;
1686 if (c)
1687 fail (_("%d unused bits in i386_operand_type.\n"), c);
40fb9820
L		 1688#endif
1689
1690 qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1691 compare);
1692
1693 qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1694 sizeof (opcode_modifiers [0]), compare);
1695
1696 qsort (operand_types, ARRAY_SIZE (operand_types),
1697 sizeof (operand_types [0]), compare);
40b8e679 1698
34edb9ad
L		 1699 table = fopen ("i386-tbl.h", "w");
1700 if (table == NULL)
40fb9820
L		 1701 fail (_("can't create i386-tbl.h, errno = %s\n"),
1702 xstrerror (errno));
34edb9ad 1703
72ffa0fb 1704 process_copyright (table);
40b8e679 1705
72ffa0fb
L		 1706 process_i386_opcodes (table);
1707 process_i386_registers (table);
40fb9820 1708 process_i386_initializers ();
40b8e679 1709
34edb9ad
L		 1710 fclose (table);
1711
40b8e679
L		 1712 exit (0);
1713}
GDB Binutils - Deliverables
This page took 0.652358 seconds and 4 git commands to generate.