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