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