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