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