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