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