projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
HPPA64 .PARISC.unwind entries
[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",
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),
40fb9820
L		 615 BITFIELD (Size16),
616 BITFIELD (Size32),
617 BITFIELD (Size64),
56ffb741 618 BITFIELD (CheckRegSize),
40fb9820
L		 619 BITFIELD (IgnoreSize),
620 BITFIELD (DefaultSize),
621 BITFIELD (No_bSuf),
622 BITFIELD (No_wSuf),
623 BITFIELD (No_lSuf),
624 BITFIELD (No_sSuf),
625 BITFIELD (No_qSuf),
7ce189b3 626 BITFIELD (No_ldSuf),
40fb9820
L		 627 BITFIELD (FWait),
628 BITFIELD (IsString),
7e8b059b 629 BITFIELD (BNDPrefixOk),
04ef582a 630 BITFIELD (NoTrackPrefixOk),
c32fa91d 631 BITFIELD (IsLockable),
40fb9820 632 BITFIELD (RegKludge),
c0f3af97 633 BITFIELD (Implicit1stXmm0),
29c048b6 634 BITFIELD (RepPrefixOk),
42164a71 635 BITFIELD (HLEPrefixOk),
ca61edf2
L		 636 BITFIELD (ToDword),
637 BITFIELD (ToQword),
75c0a438 638 BITFIELD (AddrPrefixOpReg),
40fb9820
L		 639 BITFIELD (IsPrefix),
640 BITFIELD (ImmExt),
641 BITFIELD (NoRex64),
642 BITFIELD (Rex64),
643 BITFIELD (Ugh),
c0f3af97 644 BITFIELD (Vex),
2426c15f 645 BITFIELD (VexVVVV),
1ef99a7b 646 BITFIELD (VexW),
7f399153 647 BITFIELD (VexOpcode),
8cd7925b 648 BITFIELD (VexSources),
6c30d220 649 BITFIELD (VecSIB),
c0f3af97 650 BITFIELD (SSE2AVX),
81f8a913 651 BITFIELD (NoAVX),
43234a1e
L		 652 BITFIELD (EVex),
653 BITFIELD (Masking),
43234a1e
L		 654 BITFIELD (Broadcast),
655 BITFIELD (StaticRounding),
656 BITFIELD (SAE),
657 BITFIELD (Disp8MemShift),
658 BITFIELD (NoDefMask),
920d2ddc 659 BITFIELD (ImplicitQuadGroup),
b6f8c7c4 660 BITFIELD (Optimize),
1efbbeb4 661 BITFIELD (ATTMnemonic),
e1d4d893 662 BITFIELD (ATTSyntax),
5c07affc 663 BITFIELD (IntelSyntax),
e92bae62
L		 664 BITFIELD (AMD64),
665 BITFIELD (Intel64),
40fb9820
L		 666};
667
668static bitfield operand_types[] =
669{
dc821c5f 670 BITFIELD (Reg),
40fb9820 671 BITFIELD (RegMMX),
1b54b8d7 672 BITFIELD (RegSIMD),
43234a1e 673 BITFIELD (RegMask),
94ff3a50 674 BITFIELD (Imm1),
40fb9820
L		 675 BITFIELD (Imm8),
676 BITFIELD (Imm8S),
677 BITFIELD (Imm16),
678 BITFIELD (Imm32),
679 BITFIELD (Imm32S),
680 BITFIELD (Imm64),
40fb9820
L		 681 BITFIELD (BaseIndex),
682 BITFIELD (Disp8),
683 BITFIELD (Disp16),
684 BITFIELD (Disp32),
685 BITFIELD (Disp32S),
686 BITFIELD (Disp64),
687 BITFIELD (InOutPortReg),
688 BITFIELD (ShiftCount),
689 BITFIELD (Control),
690 BITFIELD (Debug),
691 BITFIELD (Test),
692 BITFIELD (SReg2),
693 BITFIELD (SReg3),
694 BITFIELD (Acc),
40fb9820
L		 695 BITFIELD (JumpAbsolute),
696 BITFIELD (EsSeg),
697 BITFIELD (RegMem),
7d5e4556
L		 698 BITFIELD (Byte),
699 BITFIELD (Word),
700 BITFIELD (Dword),
701 BITFIELD (Fword),
702 BITFIELD (Qword),
703 BITFIELD (Tbyte),
704 BITFIELD (Xmmword),
c0f3af97 705 BITFIELD (Ymmword),
43234a1e 706 BITFIELD (Zmmword),
7d5e4556
L		 707 BITFIELD (Unspecified),
708 BITFIELD (Anysize),
a683cc34 709 BITFIELD (Vec_Imm4),
7e8b059b 710 BITFIELD (RegBND),
40fb9820
L		 711#ifdef OTUnused
712 BITFIELD (OTUnused),
713#endif
714};
715
3d4d5afa 716static const char *filename;
7ac20022
JB		 717static i386_cpu_flags active_cpu_flags;
718static int active_isstring;
3d4d5afa 719
40fb9820
L		 720static int
721compare (const void *x, const void *y)
722{
723 const bitfield *xp = (const bitfield *) x;
724 const bitfield *yp = (const bitfield *) y;
725 return xp->position - yp->position;
726}
727
40b8e679
L		 728static void
729fail (const char *message, ...)
730{
731 va_list args;
29c048b6 732
40b8e679 733 va_start (args, message);
a6743a54 734 fprintf (stderr, _("%s: error: "), program_name);
40b8e679
L		 735 vfprintf (stderr, message, args);
736 va_end (args);
737 xexit (1);
738}
739
72ffa0fb
L		 740static void
741process_copyright (FILE *fp)
742{
743 fprintf (fp, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
219d1afa 744/* Copyright (C) 2007-2018 Free Software Foundation, Inc.\n\
72ffa0fb
L		 745\n\
746 This file is part of the GNU opcodes library.\n\
747\n\
748 This library is free software; you can redistribute it and/or modify\n\
749 it under the terms of the GNU General Public License as published by\n\
750 the Free Software Foundation; either version 3, or (at your option)\n\
751 any later version.\n\
752\n\
753 It is distributed in the hope that it will be useful, but WITHOUT\n\
754 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
755 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
756 License for more details.\n\
757\n\
758 You should have received a copy of the GNU General Public License\n\
759 along with this program; if not, write to the Free Software\n\
760 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
761 MA 02110-1301, USA. */\n");
762}
763
40b8e679
L		 764/* Remove leading white spaces. */
765
766static char *
767remove_leading_whitespaces (char *str)
768{
769 while (ISSPACE (*str))
770 str++;
771 return str;
772}
773
774/* Remove trailing white spaces. */
775
776static void
777remove_trailing_whitespaces (char *str)
778{
779 size_t last = strlen (str);
780
781 if (last == 0)
782 return;
783
784 do
785 {
786 last--;
787 if (ISSPACE (str [last]))
788 str[last] = '\0';
789 else
790 break;
791 }
792 while (last != 0);
793}
794
93b1ec2c 795/* Find next field separated by SEP and terminate it. Return a
40b8e679
L		 796 pointer to the one after it. */
797
798static char *
c587b3f9 799next_field (char *str, char sep, char **next, char *last)
40b8e679
L		 800{
801 char *p;
802
803 p = remove_leading_whitespaces (str);
93b1ec2c 804 for (str = p; *str != sep && *str != '\0'; str++);
40b8e679
L		 805
806 *str = '\0';
807 remove_trailing_whitespaces (p);
808
29c048b6 809 *next = str + 1;
40b8e679 810
c587b3f9
L		 811 if (p >= last)
812 abort ();
813
40b8e679
L		 814 return p;
815}
816
1848e567
L		 817static void set_bitfield (char *, bitfield *, int, unsigned int, int);
818
819static int
dc821c5f
JB		 820set_bitfield_from_shorthand (char *f, bitfield *array, unsigned int size,
821 int lineno)
1848e567
L		 822{
823 char *str, *next, *last;
824 unsigned int i;
825
826 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
827 if (strcmp (cpu_flag_init[i].name, f) == 0)
828 {
829 /* Turn on selective bits. */
830 char *init = xstrdup (cpu_flag_init[i].init);
831 last = init + strlen (init);
832 for (next = init; next && next < last; )
833 {
834 str = next_field (next, '|', &next, last);
835 if (str)
836 set_bitfield (str, array, 1, size, lineno);
837 }
838 free (init);
839 return 0;
840 }
841
dc821c5f
JB		 842 for (i = 0; i < ARRAY_SIZE (operand_type_shorthands); i++)
843 if (strcmp (operand_type_shorthands[i].name, f) == 0)
844 {
845 /* Turn on selective bits. */
846 char *init = xstrdup (operand_type_shorthands[i].init);
847 last = init + strlen (init);
848 for (next = init; next && next < last; )
849 {
850 str = next_field (next, '|', &next, last);
851 if (str)
852 set_bitfield (str, array, 1, size, lineno);
853 }
854 free (init);
855 return 0;
856 }
857
1848e567
L		 858 return -1;
859}
860
40fb9820 861static void
1848e567 862set_bitfield (char *f, bitfield *array, int value,
8a9036a4 863 unsigned int size, int lineno)
40fb9820
L		 864{
865 unsigned int i;
866
309d3373
JB		 867 if (strcmp (f, "CpuFP") == 0)
868 {
8a9036a4
L		 869 set_bitfield("Cpu387", array, value, size, lineno);
870 set_bitfield("Cpu287", array, value, size, lineno);
309d3373
JB		 871 f = "Cpu8087";
872 }
873 else if (strcmp (f, "Mmword") == 0)
7d5e4556
L		 874 f= "Qword";
875 else if (strcmp (f, "Oword") == 0)
876 f= "Xmmword";
40fb9820
L		 877
878 for (i = 0; i < size; i++)
879 if (strcasecmp (array[i].name, f) == 0)
880 {
8a9036a4 881 array[i].value = value;
40fb9820
L		 882 return;
883 }
884
2bf05e57
L		 885 if (value)
886 {
887 const char *v = strchr (f, '=');
888
889 if (v)
890 {
891 size_t n = v - f;
892 char *end;
893
894 for (i = 0; i < size; i++)
895 if (strncasecmp (array[i].name, f, n) == 0)
896 {
897 value = strtol (v + 1, &end, 0);
898 if (*end == '\0')
899 {
900 array[i].value = value;
901 return;
902 }
903 break;
904 }
905 }
906 }
907
dc821c5f
JB		 908 /* Handle shorthands. */
909 if (value == 1 && !set_bitfield_from_shorthand (f, array, size, lineno))
1848e567
L		 910 return;
911
bd5295b2 912 if (lineno != -1)
a6743a54 913 fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
bd5295b2 914 else
a6743a54 915 fail (_("unknown bitfield: %s\n"), f);
40fb9820
L		 916}
917
918static void
919output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
920 int macro, const char *comma, const char *indent)
921{
922 unsigned int i;
923
7ac20022
JB		 924 memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
925
40fb9820
L		 926 fprintf (table, "%s{ { ", indent);
927
928 for (i = 0; i < size - 1; i++)
929 {
10632b79
L		 930 if (((i + 1) % 20) != 0)
931 fprintf (table, "%d, ", flags[i].value);
932 else
933 fprintf (table, "%d,", flags[i].value);
40fb9820
L		 934 if (((i + 1) % 20) == 0)
935 {
936 /* We need \\ for macro. */
937 if (macro)
938 fprintf (table, " \\\n %s", indent);
939 else
940 fprintf (table, "\n %s", indent);
941 }
7ac20022
JB		 942 if (flags[i].value)
943 active_cpu_flags.array[i / 32] |= 1U << (i % 32);
40fb9820
L		 944 }
945
946 fprintf (table, "%d } }%s\n", flags[i].value, comma);
947}
948
949static void
950process_i386_cpu_flag (FILE *table, char *flag, int macro,
bd5295b2
L		 951 const char *comma, const char *indent,
952 int lineno)
40fb9820
L		 953{
954 char *str, *next, *last;
8a9036a4 955 unsigned int i;
40fb9820
L		 956 bitfield flags [ARRAY_SIZE (cpu_flags)];
957
958 /* Copy the default cpu flags. */
959 memcpy (flags, cpu_flags, sizeof (cpu_flags));
960
961 if (strcasecmp (flag, "unknown") == 0)
962 {
40fb9820 963 /* We turn on everything except for cpu64 in case of
8a9036a4
L		 964 CPU_UNKNOWN_FLAGS. */
965 for (i = 0; i < ARRAY_SIZE (flags); i++)
966 if (flags[i].position != Cpu64)
967 flags[i].value = 1;
968 }
969 else if (flag[0] == '~')
970 {
971 last = flag + strlen (flag);
972
973 if (flag[1] == '(')
974 {
975 last -= 1;
976 next = flag + 2;
977 if (*last != ')')
a6743a54 978 fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
8a9036a4
L		 979 lineno, flag);
980 *last = '\0';
981 }
982 else
983 next = flag + 1;
984
985 /* First we turn on everything except for cpu64. */
40fb9820
L		 986 for (i = 0; i < ARRAY_SIZE (flags); i++)
987 if (flags[i].position != Cpu64)
988 flags[i].value = 1;
8a9036a4
L		 989
990 /* Turn off selective bits. */
991 for (; next && next < last; )
992 {
993 str = next_field (next, '|', &next, last);
994 if (str)
995 set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
996 }
40fb9820
L		 997 }
998 else if (strcmp (flag, "0"))
999 {
8a9036a4 1000 /* Turn on selective bits. */
40fb9820
L		 1001 last = flag + strlen (flag);
1002 for (next = flag; next && next < last; )
1003 {
c587b3f9 1004 str = next_field (next, '|', &next, last);
40fb9820 1005 if (str)
8a9036a4 1006 set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
40fb9820
L		 1007 }
1008 }
1009
1010 output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
1011 comma, indent);
1012}
1013
1014static void
1015output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1016{
1017 unsigned int i;
1018
1019 fprintf (table, " { ");
1020
1021 for (i = 0; i < size - 1; i++)
1022 {
10632b79
L		 1023 if (((i + 1) % 20) != 0)
1024 fprintf (table, "%d, ", modifier[i].value);
1025 else
1026 fprintf (table, "%d,", modifier[i].value);
40fb9820
L		 1027 if (((i + 1) % 20) == 0)
1028 fprintf (table, "\n ");
1029 }
1030
1031 fprintf (table, "%d },\n", modifier[i].value);
1032}
1033
4a1b91ea
L		 1034static int
1035adjust_broadcast_modifier (char **opnd)
1036{
1037 char *str, *next, *last, *op;
1038 int bcst_type = INT_MAX;
1039
1040 /* Skip the immediate operand. */
1041 op = opnd[0];
1042 if (strcasecmp(op, "Imm8") == 0)
1043 op = opnd[1];
1044
1045 op = xstrdup (op);
1046 last = op + strlen (op);
1047 for (next = op; next && next < last; )
1048 {
1049 str = next_field (next, '|', &next, last);
1050 if (str)
1051 {
1052 if (strcasecmp(str, "Byte") == 0)
1053 {
1054 /* The smalest broadcast type, no need to check
1055 further. */
1056 bcst_type = BYTE_BROADCAST;
1057 break;
1058 }
1059 else if (strcasecmp(str, "Word") == 0)
1060 {
1061 if (bcst_type > WORD_BROADCAST)
1062 bcst_type = WORD_BROADCAST;
1063 }
1064 else if (strcasecmp(str, "Dword") == 0)
1065 {
1066 if (bcst_type > DWORD_BROADCAST)
1067 bcst_type = DWORD_BROADCAST;
1068 }
1069 else if (strcasecmp(str, "Qword") == 0)
1070 {
1071 if (bcst_type > QWORD_BROADCAST)
1072 bcst_type = QWORD_BROADCAST;
1073 }
1074 }
1075 }
1076 free (op);
1077
1078 if (bcst_type == INT_MAX)
1079 fail (_("unknown broadcast operand: %s\n"), op);
1080
1081 return bcst_type;
1082}
1083
40fb9820 1084static void
4a1b91ea 1085process_i386_opcode_modifier (FILE *table, char *mod, char **opnd, int lineno)
40fb9820
L		 1086{
1087 char *str, *next, *last;
1088 bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1089
7ac20022
JB		 1090 active_isstring = 0;
1091
40fb9820
L		 1092 /* Copy the default opcode modifier. */
1093 memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1094
1095 if (strcmp (mod, "0"))
1096 {
1097 last = mod + strlen (mod);
1098 for (next = mod; next && next < last; )
1099 {
c587b3f9 1100 str = next_field (next, '|', &next, last);
40fb9820 1101 if (str)
7ac20022 1102 {
4a1b91ea
L		 1103 int val = 1;
1104 if (strcasecmp(str, "Broadcast") == 0)
1105 val = adjust_broadcast_modifier (opnd);
1106 set_bitfield (str, modifiers, val, ARRAY_SIZE (modifiers),
8a9036a4 1107 lineno);
7ac20022
JB		 1108 if (strcasecmp(str, "IsString") == 0)
1109 active_isstring = 1;
1110 }
40fb9820
L		 1111 }
1112 }
1113 output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1114}
1115
7ac20022
JB		 1116enum stage {
1117 stage_macros,
1118 stage_opcodes,
1119 stage_registers,
1120};
1121
40fb9820
L		 1122static void
1123output_operand_type (FILE *table, bitfield *types, unsigned int size,
7ac20022 1124 enum stage stage, const char *indent)
40fb9820
L		 1125{
1126 unsigned int i;
1127
1128 fprintf (table, "{ { ");
1129
1130 for (i = 0; i < size - 1; i++)
1131 {
10632b79
L		 1132 if (((i + 1) % 20) != 0)
1133 fprintf (table, "%d, ", types[i].value);
1134 else
1135 fprintf (table, "%d,", types[i].value);
40fb9820
L		 1136 if (((i + 1) % 20) == 0)
1137 {
1138 /* We need \\ for macro. */
7ac20022 1139 if (stage == stage_macros)
10632b79 1140 fprintf (table, " \\\n%s", indent);
40fb9820
L		 1141 else
1142 fprintf (table, "\n%s", indent);
1143 }
1144 }
1145
1146 fprintf (table, "%d } }", types[i].value);
1147}
1148
1149static void
7ac20022 1150process_i386_operand_type (FILE *table, char *op, enum stage stage,
bd5295b2 1151 const char *indent, int lineno)
40fb9820
L		 1152{
1153 char *str, *next, *last;
1154 bitfield types [ARRAY_SIZE (operand_types)];
1155
1156 /* Copy the default operand type. */
1157 memcpy (types, operand_types, sizeof (types));
1158
1159 if (strcmp (op, "0"))
1160 {
7ac20022
JB		 1161 int baseindex = 0;
1162
40fb9820
L		 1163 last = op + strlen (op);
1164 for (next = op; next && next < last; )
1165 {
c587b3f9 1166 str = next_field (next, '|', &next, last);
40fb9820 1167 if (str)
7ac20022
JB		 1168 {
1169 set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1170 if (strcasecmp(str, "BaseIndex") == 0)
1171 baseindex = 1;
1172 }
1173 }
1174
1175 if (stage == stage_opcodes && baseindex && !active_isstring)
1176 {
1177 set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1178 if (!active_cpu_flags.bitfield.cpu64
1179 && !active_cpu_flags.bitfield.cpumpx)
1180 set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1181 set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1182 if (!active_cpu_flags.bitfield.cpuno64)
1183 set_bitfield("Disp32S", types, 1, ARRAY_SIZE (types), lineno);
40fb9820
L		 1184 }
1185 }
7ac20022 1186 output_operand_type (table, types, ARRAY_SIZE (types), stage,
40fb9820
L		 1187 indent);
1188}
1189
c587b3f9
L		 1190static void
1191output_i386_opcode (FILE *table, const char *name, char *str,
bd5295b2 1192 char *last, int lineno)
c587b3f9
L		 1193{
1194 unsigned int i;
1195 char *operands, *base_opcode, *extension_opcode, *opcode_length;
1196 char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1197
1198 /* Find number of operands. */
1199 operands = next_field (str, ',', &str, last);
1200
1201 /* Find base_opcode. */
1202 base_opcode = next_field (str, ',', &str, last);
1203
1204 /* Find extension_opcode. */
1205 extension_opcode = next_field (str, ',', &str, last);
1206
1207 /* Find opcode_length. */
1208 opcode_length = next_field (str, ',', &str, last);
1209
1210 /* Find cpu_flags. */
1211 cpu_flags = next_field (str, ',', &str, last);
1212
1213 /* Find opcode_modifier. */
1214 opcode_modifier = next_field (str, ',', &str, last);
1215
1216 /* Remove the first {. */
1217 str = remove_leading_whitespaces (str);
1218 if (*str != '{')
1219 abort ();
1220 str = remove_leading_whitespaces (str + 1);
1221
1222 i = strlen (str);
1223
1224 /* There are at least "X}". */
1225 if (i < 2)
1226 abort ();
1227
1228 /* Remove trailing white spaces and }. */
1229 do
1230 {
1231 i--;
1232 if (ISSPACE (str[i]) || str[i] == '}')
1233 str[i] = '\0';
1234 else
1235 break;
1236 }
1237 while (i != 0);
1238
1239 last = str + i;
1240
1241 /* Find operand_types. */
1242 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1243 {
1244 if (str >= last)
1245 {
1246 operand_types [i] = NULL;
1247 break;
1248 }
1249
1250 operand_types [i] = next_field (str, ',', &str, last);
1251 if (*operand_types[i] == '0')
1252 {
1253 if (i != 0)
1254 operand_types[i] = NULL;
1255 break;
1256 }
1257 }
1258
1259 fprintf (table, " { \"%s\", %s, %s, %s, %s,\n",
1260 name, operands, base_opcode, extension_opcode,
1261 opcode_length);
1262
bd5295b2 1263 process_i386_cpu_flag (table, cpu_flags, 0, ",", " ", lineno);
c587b3f9 1264
4a1b91ea 1265 process_i386_opcode_modifier (table, opcode_modifier, operand_types, lineno);
c587b3f9
L		 1266
1267 fprintf (table, " { ");
1268
1269 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1270 {
1271 if (operand_types[i] == NULL || *operand_types[i] == '0')
1272 {
1273 if (i == 0)
7ac20022
JB		 1274 process_i386_operand_type (table, "0", stage_opcodes, "\t ",
1275 lineno);
c587b3f9
L		 1276 break;
1277 }
1278
1279 if (i != 0)
1280 fprintf (table, ",\n ");
1281
7ac20022 1282 process_i386_operand_type (table, operand_types[i], stage_opcodes,
bd5295b2 1283 "\t ", lineno);
c587b3f9
L		 1284 }
1285 fprintf (table, " } },\n");
1286}
1287
1288struct opcode_hash_entry
1289{
1290 struct opcode_hash_entry *next;
1291 char *name;
1292 char *opcode;
bd5295b2 1293 int lineno;
c587b3f9
L		 1294};
1295
1296/* Calculate the hash value of an opcode hash entry P. */
1297
1298static hashval_t
1299opcode_hash_hash (const void *p)
1300{
1301 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1302 return htab_hash_string (entry->name);
1303}
1304
1305/* Compare a string Q against an opcode hash entry P. */
1306
1307static int
1308opcode_hash_eq (const void *p, const void *q)
1309{
1310 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1311 const char *name = (const char *) q;
1312 return strcmp (name, entry->name) == 0;
1313}
1314
40b8e679 1315static void
72ffa0fb 1316process_i386_opcodes (FILE *table)
40b8e679 1317{
3d4d5afa 1318 FILE *fp;
40b8e679 1319 char buf[2048];
c587b3f9
L		 1320 unsigned int i, j;
1321 char *str, *p, *last, *name;
1322 struct opcode_hash_entry **hash_slot, **entry, *next;
1323 htab_t opcode_hash_table;
1324 struct opcode_hash_entry **opcode_array;
1325 unsigned int opcode_array_size = 1024;
c30be56e 1326 int lineno = 0, marker = 0;
40b8e679 1327
3d4d5afa 1328 filename = "i386-opc.tbl";
c30be56e 1329 fp = stdin;
40b8e679 1330
c587b3f9
L		 1331 i = 0;
1332 opcode_array = (struct opcode_hash_entry **)
1333 xmalloc (sizeof (*opcode_array) * opcode_array_size);
1334
1335 opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1336 opcode_hash_eq, NULL,
1337 xcalloc, free);
1338
34edb9ad 1339 fprintf (table, "\n/* i386 opcode table. */\n\n");
d3ce72d0 1340 fprintf (table, "const insn_template i386_optab[] =\n{\n");
40b8e679 1341
c587b3f9 1342 /* Put everything on opcode array. */
40b8e679
L		 1343 while (!feof (fp))
1344 {
1345 if (fgets (buf, sizeof (buf), fp) == NULL)
1346 break;
1347
3d4d5afa
L		 1348 lineno++;
1349
40b8e679
L		 1350 p = remove_leading_whitespaces (buf);
1351
1352 /* Skip comments. */
1353 str = strstr (p, "//");
1354 if (str != NULL)
1355 str[0] = '\0';
1356
1357 /* Remove trailing white spaces. */
1358 remove_trailing_whitespaces (p);
1359
1360 switch (p[0])
1361 {
1362 case '#':
c30be56e
JB		 1363 if (!strcmp("### MARKER ###", buf))
1364 marker = 1;
1365 else
1366 {
1367 /* Since we ignore all included files (we only care about their
1368 #define-s here), we don't need to monitor filenames. The final
1369 line number directive is going to refer to the main source file
1370 again. */
1371 char *end;
1372 unsigned long ln;
1373
1374 p = remove_leading_whitespaces (p + 1);
1375 if (!strncmp(p, "line", 4))
1376 p += 4;
1377 ln = strtoul (p, &end, 10);
1378 if (ln > 1 && ln < INT_MAX
1379 && *remove_leading_whitespaces (end) == '"')
1380 lineno = ln - 1;
1381 }
c587b3f9 1382 /* Ignore comments. */
40b8e679
L		 1383 case '\0':
1384 continue;
1385 break;
1386 default:
c30be56e
JB		 1387 if (!marker)
1388 continue;
40b8e679
L		 1389 break;
1390 }
1391
1392 last = p + strlen (p);
1393
1394 /* Find name. */
c587b3f9 1395 name = next_field (p, ',', &str, last);
40b8e679 1396
c587b3f9
L		 1397 /* Get the slot in hash table. */
1398 hash_slot = (struct opcode_hash_entry **)
1399 htab_find_slot_with_hash (opcode_hash_table, name,
1400 htab_hash_string (name),
1401 INSERT);
40b8e679 1402
c587b3f9 1403 if (*hash_slot == NULL)
40b8e679 1404 {
c587b3f9
L		 1405 /* It is the new one. Put it on opcode array. */
1406 if (i >= opcode_array_size)
40b8e679 1407 {
c587b3f9
L		 1408 /* Grow the opcode array when needed. */
1409 opcode_array_size += 1024;
1410 opcode_array = (struct opcode_hash_entry **)
1411 xrealloc (opcode_array,
1412 sizeof (*opcode_array) * opcode_array_size);
40b8e679
L		 1413 }
1414
c587b3f9
L		 1415 opcode_array[i] = (struct opcode_hash_entry *)
1416 xmalloc (sizeof (struct opcode_hash_entry));
1417 opcode_array[i]->next = NULL;
1418 opcode_array[i]->name = xstrdup (name);
1419 opcode_array[i]->opcode = xstrdup (str);
bd5295b2 1420 opcode_array[i]->lineno = lineno;
c587b3f9
L		 1421 *hash_slot = opcode_array[i];
1422 i++;
40b8e679 1423 }
c587b3f9 1424 else
40b8e679 1425 {
c587b3f9
L		 1426 /* Append it to the existing one. */
1427 entry = hash_slot;
1428 while ((*entry) != NULL)
1429 entry = &(*entry)->next;
1430 *entry = (struct opcode_hash_entry *)
1431 xmalloc (sizeof (struct opcode_hash_entry));
1432 (*entry)->next = NULL;
1433 (*entry)->name = (*hash_slot)->name;
1434 (*entry)->opcode = xstrdup (str);
bd5295b2 1435 (*entry)->lineno = lineno;
c587b3f9
L		 1436 }
1437 }
40b8e679 1438
c587b3f9
L		 1439 /* Process opcode array. */
1440 for (j = 0; j < i; j++)
1441 {
1442 for (next = opcode_array[j]; next; next = next->next)
1443 {
1444 name = next->name;
1445 str = next->opcode;
bd5295b2 1446 lineno = next->lineno;
c587b3f9 1447 last = str + strlen (str);
bd5295b2 1448 output_i386_opcode (table, name, str, last, lineno);
40b8e679 1449 }
40b8e679
L		 1450 }
1451
34edb9ad
L		 1452 fclose (fp);
1453
4dffcebc 1454 fprintf (table, " { NULL, 0, 0, 0, 0,\n");
40fb9820 1455
bd5295b2 1456 process_i386_cpu_flag (table, "0", 0, ",", " ", -1);
40fb9820 1457
4a1b91ea 1458 process_i386_opcode_modifier (table, "0", NULL, -1);
29c048b6 1459
40fb9820 1460 fprintf (table, " { ");
7ac20022 1461 process_i386_operand_type (table, "0", stage_opcodes, "\t ", -1);
40fb9820
L		 1462 fprintf (table, " } }\n");
1463
34edb9ad 1464 fprintf (table, "};\n");
40b8e679
L		 1465}
1466
1467static void
72ffa0fb 1468process_i386_registers (FILE *table)
40b8e679 1469{
3d4d5afa 1470 FILE *fp;
40b8e679
L		 1471 char buf[2048];
1472 char *str, *p, *last;
1473 char *reg_name, *reg_type, *reg_flags, *reg_num;
a60de03c 1474 char *dw2_32_num, *dw2_64_num;
bd5295b2 1475 int lineno = 0;
40b8e679 1476
3d4d5afa
L		 1477 filename = "i386-reg.tbl";
1478 fp = fopen (filename, "r");
40b8e679 1479 if (fp == NULL)
34edb9ad 1480 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
40fb9820 1481 xstrerror (errno));
40b8e679 1482
34edb9ad
L		 1483 fprintf (table, "\n/* i386 register table. */\n\n");
1484 fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
40b8e679
L		 1485
1486 while (!feof (fp))
1487 {
1488 if (fgets (buf, sizeof (buf), fp) == NULL)
1489 break;
1490
3d4d5afa
L		 1491 lineno++;
1492
40b8e679
L		 1493 p = remove_leading_whitespaces (buf);
1494
1495 /* Skip comments. */
1496 str = strstr (p, "//");
1497 if (str != NULL)
1498 str[0] = '\0';
1499
1500 /* Remove trailing white spaces. */
1501 remove_trailing_whitespaces (p);
1502
1503 switch (p[0])
1504 {
1505 case '#':
34edb9ad 1506 fprintf (table, "%s\n", p);
40b8e679
L		 1507 case '\0':
1508 continue;
1509 break;
1510 default:
1511 break;
1512 }
1513
1514 last = p + strlen (p);
1515
1516 /* Find reg_name. */
c587b3f9 1517 reg_name = next_field (p, ',', &str, last);
40b8e679
L		 1518
1519 /* Find reg_type. */
c587b3f9 1520 reg_type = next_field (str, ',', &str, last);
40b8e679
L		 1521
1522 /* Find reg_flags. */
c587b3f9 1523 reg_flags = next_field (str, ',', &str, last);
40b8e679
L		 1524
1525 /* Find reg_num. */
c587b3f9 1526 reg_num = next_field (str, ',', &str, last);
a60de03c 1527
40fb9820
L		 1528 fprintf (table, " { \"%s\",\n ", reg_name);
1529
7ac20022
JB		 1530 process_i386_operand_type (table, reg_type, stage_registers, "\t",
1531 lineno);
40fb9820 1532
a60de03c 1533 /* Find 32-bit Dwarf2 register number. */
c587b3f9 1534 dw2_32_num = next_field (str, ',', &str, last);
a60de03c
JB		 1535
1536 /* Find 64-bit Dwarf2 register number. */
c587b3f9 1537 dw2_64_num = next_field (str, ',', &str, last);
a60de03c
JB		 1538
1539 fprintf (table, ",\n %s, %s, { %s, %s } },\n",
1540 reg_flags, reg_num, dw2_32_num, dw2_64_num);
40b8e679
L		 1541 }
1542
34edb9ad
L		 1543 fclose (fp);
1544
1545 fprintf (table, "};\n");
40b8e679 1546
34edb9ad 1547 fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
40b8e679
L		 1548}
1549
40fb9820
L		 1550static void
1551process_i386_initializers (void)
1552{
1553 unsigned int i;
1554 FILE *fp = fopen ("i386-init.h", "w");
1555 char *init;
1556
1557 if (fp == NULL)
1558 fail (_("can't create i386-init.h, errno = %s\n"),
1559 xstrerror (errno));
1560
1561 process_copyright (fp);
1562
1563 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1564 {
1565 fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1566 init = xstrdup (cpu_flag_init[i].init);
bd5295b2 1567 process_i386_cpu_flag (fp, init, 1, "", " ", -1);
40fb9820
L		 1568 free (init);
1569 }
1570
1571 for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1572 {
1573 fprintf (fp, "\n\n#define %s \\\n ", operand_type_init[i].name);
1574 init = xstrdup (operand_type_init[i].init);
7ac20022 1575 process_i386_operand_type (fp, init, stage_macros, " ", -1);
40fb9820
L		 1576 free (init);
1577 }
1578 fprintf (fp, "\n");
1579
1580 fclose (fp);
1581}
1582
40b8e679
L		 1583/* Program options. */
1584#define OPTION_SRCDIR 200
1585
29c048b6 1586struct option long_options[] =
40b8e679
L		 1587{
1588 {"srcdir", required_argument, NULL, OPTION_SRCDIR},
1589 {"debug", no_argument, NULL, 'd'},
1590 {"version", no_argument, NULL, 'V'},
1591 {"help", no_argument, NULL, 'h'},
1592 {0, no_argument, NULL, 0}
1593};
1594
1595static void
1596print_version (void)
1597{
1598 printf ("%s: version 1.0\n", program_name);
1599 xexit (0);
1600}
1601
1602static void
1603usage (FILE * stream, int status)
1604{
1605 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1606 program_name);
1607 xexit (status);
1608}
1609
1610int
1611main (int argc, char **argv)
1612{
1613 extern int chdir (char *);
1614 char *srcdir = NULL;
8b40d594 1615 int c;
e92bae62 1616 unsigned int i, cpumax;
72ffa0fb 1617 FILE *table;
29c048b6 1618
40b8e679
L		 1619 program_name = *argv;
1620 xmalloc_set_program_name (program_name);
1621
1622 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1623 switch (c)
1624 {
1625 case OPTION_SRCDIR:
1626 srcdir = optarg;
1627 break;
1628 case 'V':
1629 case 'v':
1630 print_version ();
1631 break;
1632 case 'd':
1633 debug = 1;
1634 break;
1635 case 'h':
1636 case '?':
1637 usage (stderr, 0);
1638 default:
1639 case 0:
1640 break;
1641 }
1642
1643 if (optind != argc)
1644 usage (stdout, 1);
1645
29c048b6 1646 if (srcdir != NULL)
40b8e679
L		 1647 if (chdir (srcdir) != 0)
1648 fail (_("unable to change directory to \"%s\", errno = %s\n"),
40fb9820
L		 1649 srcdir, xstrerror (errno));
1650
e92bae62
L		 1651 /* cpu_flags isn't sorted by position. */
1652 cpumax = 0;
1653 for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
1654 if (cpu_flags[i].position > cpumax)
1655 cpumax = cpu_flags[i].position;
1656
40fb9820 1657 /* Check the unused bitfield in i386_cpu_flags. */
e89c5eaa 1658#ifdef CpuUnused
e92bae62
L		 1659 if ((cpumax - 1) != CpuMax)
1660 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1661#else
e92bae62
L		 1662 if (cpumax != CpuMax)
1663 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1664
8b40d594
L		 1665 c = CpuNumOfBits - CpuMax - 1;
1666 if (c)
1667 fail (_("%d unused bits in i386_cpu_flags.\n"), c);
40fb9820
L		 1668#endif
1669
1670 /* Check the unused bitfield in i386_operand_type. */
1671#ifndef OTUnused
8b40d594
L		 1672 c = OTNumOfBits - OTMax - 1;
1673 if (c)
1674 fail (_("%d unused bits in i386_operand_type.\n"), c);
40fb9820
L		 1675#endif
1676
1677 qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1678 compare);
1679
1680 qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1681 sizeof (opcode_modifiers [0]), compare);
1682
1683 qsort (operand_types, ARRAY_SIZE (operand_types),
1684 sizeof (operand_types [0]), compare);
40b8e679 1685
34edb9ad
L		 1686 table = fopen ("i386-tbl.h", "w");
1687 if (table == NULL)
40fb9820
L		 1688 fail (_("can't create i386-tbl.h, errno = %s\n"),
1689 xstrerror (errno));
34edb9ad 1690
72ffa0fb 1691 process_copyright (table);
40b8e679 1692
72ffa0fb
L		 1693 process_i386_opcodes (table);
1694 process_i386_registers (table);
40fb9820 1695 process_i386_initializers ();
40b8e679 1696
34edb9ad
L		 1697 fclose (table);
1698
40b8e679
L		 1699 exit (0);
1700}
GDB Binutils - Deliverables
This page took 0.929203 seconds and 4 git commands to generate.