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