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