projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix AArch64 unintialized variable which can cause diagnostic failures.
[deliverable/binutils-gdb.git] / opcodes / i386-gen.c
CommitLineData
219d1afa 1/* Copyright (C) 2007-2018 Free Software Foundation, Inc.
40b8e679 2
9b201bb5 3 This file is part of the GNU opcodes library.
40b8e679 4
9b201bb5 5 This library is free software; you can redistribute it and/or modify
40b8e679 6 it under the terms of the GNU General Public License as published by
9b201bb5
NC		 7 the Free Software Foundation; either version 3, or (at your option)
8 any later version.
40b8e679 9
9b201bb5
NC		 10 It is distributed in the hope that it will be useful, but WITHOUT
11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
13 License for more details.
40b8e679
L		 14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
9b201bb5
NC		 17 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
18 MA 02110-1301, USA. */
40b8e679 19
40fb9820 20#include "sysdep.h"
40b8e679 21#include <stdio.h>
40b8e679
L		 22#include <errno.h>
23#include "getopt.h"
24#include "libiberty.h"
c587b3f9 25#include "hashtab.h"
40b8e679
L		 26#include "safe-ctype.h"
27
28#include "i386-opc.h"
29
30#include <libintl.h>
31#define _(String) gettext (String)
32
33static const char *program_name = NULL;
34static int debug = 0;
35
40fb9820
L		 36typedef struct initializer
37{
38 const char *name;
39 const char *init;
40} initializer;
41
8acd5377 42static initializer cpu_flag_init[] =
40fb9820
L		 43{
44 { "CPU_UNKNOWN_FLAGS",
7a9068fe 45 "~(CpuL1OM|CpuK1OM)" },
40fb9820
L		 46 { "CPU_GENERIC32_FLAGS",
47 "Cpu186|Cpu286|Cpu386" },
29c048b6 48 { "CPU_GENERIC64_FLAGS",
1848e567 49 "CPU_PENTIUMPRO_FLAGS|CpuClflush|CpuSYSCALL|CPU_MMX_FLAGS|CPU_SSE2_FLAGS|CpuLM" },
40fb9820
L		 50 { "CPU_NONE_FLAGS",
51 "0" },
52 { "CPU_I186_FLAGS",
53 "Cpu186" },
54 { "CPU_I286_FLAGS",
1848e567 55 "CPU_I186_FLAGS|Cpu286" },
40fb9820 56 { "CPU_I386_FLAGS",
1848e567 57 "CPU_I286_FLAGS|Cpu386" },
40fb9820 58 { "CPU_I486_FLAGS",
1848e567 59 "CPU_I386_FLAGS|Cpu486" },
40fb9820 60 { "CPU_I586_FLAGS",
0e0eea78 61 "CPU_I486_FLAGS|Cpu387|Cpu586" },
40fb9820 62 { "CPU_I686_FLAGS",
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",
6e041cf4 201 "CPU_AVX2_FLAGS|CpuVREX|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",
6e041cf4 319 "CpuVREX|CpuAVX512CD|CpuAVX512ER|CpuAVX512PF|CpuAVX512DQ|CpuAVX512BW|CpuAVX512VL|CpuAVX512IFMA|CpuAVX512VBMI|CpuAVX512_4FMAPS|CpuAVX512_4VNNIW|CpuAVX512_VPOPCNTDQ|CpuAVX512_VBMI2|CpuAVX512_VNNI|CpuAVX512_BITALG|CpuAVX512F" },
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" },
65da13b5
L		 447 { "OPERAND_TYPE_INOUTPORTREG",
448 "InOutPortReg" },
40fb9820
L		 449 { "OPERAND_TYPE_REG16_INOUTPORTREG",
450 "Reg16|InOutPortReg" },
451 { "OPERAND_TYPE_DISP16_32",
452 "Disp16|Disp32" },
453 { "OPERAND_TYPE_ANYDISP",
454 "Disp8|Disp16|Disp32|Disp32S|Disp64" },
455 { "OPERAND_TYPE_IMM16_32",
456 "Imm16|Imm32" },
457 { "OPERAND_TYPE_IMM16_32S",
458 "Imm16|Imm32S" },
459 { "OPERAND_TYPE_IMM16_32_32S",
460 "Imm16|Imm32|Imm32S" },
2f81ff92
L		 461 { "OPERAND_TYPE_IMM32_64",
462 "Imm32|Imm64" },
40fb9820
L		 463 { "OPERAND_TYPE_IMM32_32S_DISP32",
464 "Imm32|Imm32S|Disp32" },
465 { "OPERAND_TYPE_IMM64_DISP64",
466 "Imm64|Disp64" },
467 { "OPERAND_TYPE_IMM32_32S_64_DISP32",
468 "Imm32|Imm32S|Imm64|Disp32" },
469 { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
470 "Imm32|Imm32S|Imm64|Disp32|Disp64" },
a683cc34
SP		 471 { "OPERAND_TYPE_VEC_IMM4",
472 "Vec_Imm4" },
7e8b059b
L		 473 { "OPERAND_TYPE_REGBND",
474 "RegBND" },
40fb9820
L		 475};
476
477typedef struct bitfield
478{
479 int position;
480 int value;
481 const char *name;
482} bitfield;
483
484#define BITFIELD(n) { n, 0, #n }
485
486static bitfield cpu_flags[] =
487{
488 BITFIELD (Cpu186),
489 BITFIELD (Cpu286),
490 BITFIELD (Cpu386),
491 BITFIELD (Cpu486),
492 BITFIELD (Cpu586),
493 BITFIELD (Cpu686),
bd5295b2 494 BITFIELD (CpuClflush),
22109423 495 BITFIELD (CpuNop),
bd5295b2 496 BITFIELD (CpuSYSCALL),
309d3373
JB		 497 BITFIELD (Cpu8087),
498 BITFIELD (Cpu287),
499 BITFIELD (Cpu387),
500 BITFIELD (Cpu687),
501 BITFIELD (CpuFISTTP),
40fb9820 502 BITFIELD (CpuMMX),
40fb9820
L		 503 BITFIELD (CpuSSE),
504 BITFIELD (CpuSSE2),
505 BITFIELD (CpuSSE3),
506 BITFIELD (CpuSSSE3),
507 BITFIELD (CpuSSE4_1),
508 BITFIELD (CpuSSE4_2),
c0f3af97 509 BITFIELD (CpuAVX),
6c30d220 510 BITFIELD (CpuAVX2),
43234a1e
L		 511 BITFIELD (CpuAVX512F),
512 BITFIELD (CpuAVX512CD),
513 BITFIELD (CpuAVX512ER),
514 BITFIELD (CpuAVX512PF),
b28d1bda 515 BITFIELD (CpuAVX512VL),
90a915bf 516 BITFIELD (CpuAVX512DQ),
1ba585e8 517 BITFIELD (CpuAVX512BW),
8a9036a4 518 BITFIELD (CpuL1OM),
7a9068fe 519 BITFIELD (CpuK1OM),
7b6d09fb 520 BITFIELD (CpuIAMCU),
40fb9820
L		 521 BITFIELD (CpuSSE4a),
522 BITFIELD (Cpu3dnow),
523 BITFIELD (Cpu3dnowA),
524 BITFIELD (CpuPadLock),
525 BITFIELD (CpuSVME),
526 BITFIELD (CpuVMX),
47dd174c 527 BITFIELD (CpuSMX),
40fb9820 528 BITFIELD (CpuABM),
475a2301 529 BITFIELD (CpuXsave),
c7b8aa3a 530 BITFIELD (CpuXsaveopt),
c0f3af97 531 BITFIELD (CpuAES),
594ab6a3 532 BITFIELD (CpuPCLMUL),
c0f3af97 533 BITFIELD (CpuFMA),
f88c9eb0 534 BITFIELD (CpuFMA4),
5dd85c99 535 BITFIELD (CpuXOP),
f88c9eb0 536 BITFIELD (CpuLWP),
f12dc422 537 BITFIELD (CpuBMI),
2a2a0f38 538 BITFIELD (CpuTBM),
c0f3af97 539 BITFIELD (CpuLM),
f1f8f695 540 BITFIELD (CpuMovbe),
60aa667e 541 BITFIELD (CpuCX16),
f1f8f695 542 BITFIELD (CpuEPT),
1b7f3fb0 543 BITFIELD (CpuRdtscp),
c7b8aa3a
L		 544 BITFIELD (CpuFSGSBase),
545 BITFIELD (CpuRdRnd),
546 BITFIELD (CpuF16C),
6c30d220
L		 547 BITFIELD (CpuBMI2),
548 BITFIELD (CpuLZCNT),
42164a71
L		 549 BITFIELD (CpuHLE),
550 BITFIELD (CpuRTM),
6c30d220 551 BITFIELD (CpuINVPCID),
8729a6f6 552 BITFIELD (CpuVMFUNC),
e2e1fcde
L		 553 BITFIELD (CpuRDSEED),
554 BITFIELD (CpuADX),
555 BITFIELD (CpuPRFCHW),
5c111e37 556 BITFIELD (CpuSMAP),
a0046408 557 BITFIELD (CpuSHA),
43234a1e 558 BITFIELD (CpuVREX),
963f3586
IT		 559 BITFIELD (CpuClflushOpt),
560 BITFIELD (CpuXSAVES),
561 BITFIELD (CpuXSAVEC),
dcf893b5 562 BITFIELD (CpuPREFETCHWT1),
2cf200a4 563 BITFIELD (CpuSE1),
c5e7287a 564 BITFIELD (CpuCLWB),
40fb9820
L		 565 BITFIELD (Cpu64),
566 BITFIELD (CpuNo64),
7e8b059b 567 BITFIELD (CpuMPX),
2cc1b5aa 568 BITFIELD (CpuAVX512IFMA),
14f195c9 569 BITFIELD (CpuAVX512VBMI),
920d2ddc 570 BITFIELD (CpuAVX512_4FMAPS),
47acf0bd 571 BITFIELD (CpuAVX512_4VNNIW),
620214f7 572 BITFIELD (CpuAVX512_VPOPCNTDQ),
53467f57 573 BITFIELD (CpuAVX512_VBMI2),
8cfcb765 574 BITFIELD (CpuAVX512_VNNI),
ee6872be 575 BITFIELD (CpuAVX512_BITALG),
9916071f 576 BITFIELD (CpuMWAITX),
029f3522 577 BITFIELD (CpuCLZERO),
8eab4136 578 BITFIELD (CpuOSPKE),
8bc52696 579 BITFIELD (CpuRDPID),
6b40c462 580 BITFIELD (CpuPTWRITE),
d777820b
IT		 581 BITFIELD (CpuIBT),
582 BITFIELD (CpuSHSTK),
48521003 583 BITFIELD (CpuGFNI),
8dcf1fad 584 BITFIELD (CpuVAES),
ff1982d5 585 BITFIELD (CpuVPCLMULQDQ),
3233d7d0 586 BITFIELD (CpuWBNOINVD),
be3a8dca 587 BITFIELD (CpuPCONFIG),
de89d0a3 588 BITFIELD (CpuWAITPKG),
c48935d7 589 BITFIELD (CpuCLDEMOTE),
c0a30a9f
L		 590 BITFIELD (CpuMOVDIRI),
591 BITFIELD (CpuMOVDIR64B),
40fb9820
L		 592#ifdef CpuUnused
593 BITFIELD (CpuUnused),
594#endif
595};
596
597static bitfield opcode_modifiers[] =
598{
599 BITFIELD (D),
600 BITFIELD (W),
86fa6981 601 BITFIELD (Load),
40fb9820
L		 602 BITFIELD (Modrm),
603 BITFIELD (ShortForm),
604 BITFIELD (Jump),
605 BITFIELD (JumpDword),
606 BITFIELD (JumpByte),
607 BITFIELD (JumpInterSegment),
608 BITFIELD (FloatMF),
609 BITFIELD (FloatR),
40fb9820
L		 610 BITFIELD (Size16),
611 BITFIELD (Size32),
612 BITFIELD (Size64),
56ffb741 613 BITFIELD (CheckRegSize),
40fb9820
L		 614 BITFIELD (IgnoreSize),
615 BITFIELD (DefaultSize),
616 BITFIELD (No_bSuf),
617 BITFIELD (No_wSuf),
618 BITFIELD (No_lSuf),
619 BITFIELD (No_sSuf),
620 BITFIELD (No_qSuf),
7ce189b3 621 BITFIELD (No_ldSuf),
40fb9820
L		 622 BITFIELD (FWait),
623 BITFIELD (IsString),
7e8b059b 624 BITFIELD (BNDPrefixOk),
04ef582a 625 BITFIELD (NoTrackPrefixOk),
c32fa91d 626 BITFIELD (IsLockable),
40fb9820 627 BITFIELD (RegKludge),
c0f3af97 628 BITFIELD (Implicit1stXmm0),
29c048b6 629 BITFIELD (RepPrefixOk),
42164a71 630 BITFIELD (HLEPrefixOk),
ca61edf2
L		 631 BITFIELD (ToDword),
632 BITFIELD (ToQword),
75c0a438 633 BITFIELD (AddrPrefixOpReg),
40fb9820
L		 634 BITFIELD (IsPrefix),
635 BITFIELD (ImmExt),
636 BITFIELD (NoRex64),
637 BITFIELD (Rex64),
638 BITFIELD (Ugh),
c0f3af97 639 BITFIELD (Vex),
2426c15f 640 BITFIELD (VexVVVV),
1ef99a7b 641 BITFIELD (VexW),
7f399153 642 BITFIELD (VexOpcode),
8cd7925b 643 BITFIELD (VexSources),
6c30d220 644 BITFIELD (VecSIB),
c0f3af97 645 BITFIELD (SSE2AVX),
81f8a913 646 BITFIELD (NoAVX),
43234a1e
L		 647 BITFIELD (EVex),
648 BITFIELD (Masking),
43234a1e
L		 649 BITFIELD (Broadcast),
650 BITFIELD (StaticRounding),
651 BITFIELD (SAE),
652 BITFIELD (Disp8MemShift),
653 BITFIELD (NoDefMask),
920d2ddc 654 BITFIELD (ImplicitQuadGroup),
b6f8c7c4 655 BITFIELD (Optimize),
1efbbeb4 656 BITFIELD (ATTMnemonic),
e1d4d893 657 BITFIELD (ATTSyntax),
5c07affc 658 BITFIELD (IntelSyntax),
e92bae62
L		 659 BITFIELD (AMD64),
660 BITFIELD (Intel64),
40fb9820
L		 661};
662
663static bitfield operand_types[] =
664{
dc821c5f 665 BITFIELD (Reg),
40fb9820 666 BITFIELD (RegMMX),
1b54b8d7 667 BITFIELD (RegSIMD),
43234a1e 668 BITFIELD (RegMask),
94ff3a50 669 BITFIELD (Imm1),
40fb9820
L		 670 BITFIELD (Imm8),
671 BITFIELD (Imm8S),
672 BITFIELD (Imm16),
673 BITFIELD (Imm32),
674 BITFIELD (Imm32S),
675 BITFIELD (Imm64),
40fb9820
L		 676 BITFIELD (BaseIndex),
677 BITFIELD (Disp8),
678 BITFIELD (Disp16),
679 BITFIELD (Disp32),
680 BITFIELD (Disp32S),
681 BITFIELD (Disp64),
682 BITFIELD (InOutPortReg),
683 BITFIELD (ShiftCount),
684 BITFIELD (Control),
685 BITFIELD (Debug),
686 BITFIELD (Test),
687 BITFIELD (SReg2),
688 BITFIELD (SReg3),
689 BITFIELD (Acc),
40fb9820
L		 690 BITFIELD (JumpAbsolute),
691 BITFIELD (EsSeg),
692 BITFIELD (RegMem),
5c07affc 693 BITFIELD (Mem),
7d5e4556
L		 694 BITFIELD (Byte),
695 BITFIELD (Word),
696 BITFIELD (Dword),
697 BITFIELD (Fword),
698 BITFIELD (Qword),
699 BITFIELD (Tbyte),
700 BITFIELD (Xmmword),
c0f3af97 701 BITFIELD (Ymmword),
43234a1e 702 BITFIELD (Zmmword),
7d5e4556
L		 703 BITFIELD (Unspecified),
704 BITFIELD (Anysize),
a683cc34 705 BITFIELD (Vec_Imm4),
7e8b059b 706 BITFIELD (RegBND),
40fb9820
L		 707#ifdef OTUnused
708 BITFIELD (OTUnused),
709#endif
710};
711
3d4d5afa 712static const char *filename;
7ac20022
JB		 713static i386_cpu_flags active_cpu_flags;
714static int active_isstring;
3d4d5afa 715
40fb9820
L		 716static int
717compare (const void *x, const void *y)
718{
719 const bitfield *xp = (const bitfield *) x;
720 const bitfield *yp = (const bitfield *) y;
721 return xp->position - yp->position;
722}
723
40b8e679
L		 724static void
725fail (const char *message, ...)
726{
727 va_list args;
29c048b6 728
40b8e679 729 va_start (args, message);
a6743a54 730 fprintf (stderr, _("%s: error: "), program_name);
40b8e679
L		 731 vfprintf (stderr, message, args);
732 va_end (args);
733 xexit (1);
734}
735
72ffa0fb
L		 736static void
737process_copyright (FILE *fp)
738{
739 fprintf (fp, "/* This file is automatically generated by i386-gen. Do not edit! */\n\
219d1afa 740/* Copyright (C) 2007-2018 Free Software Foundation, Inc.\n\
72ffa0fb
L		 741\n\
742 This file is part of the GNU opcodes library.\n\
743\n\
744 This library is free software; you can redistribute it and/or modify\n\
745 it under the terms of the GNU General Public License as published by\n\
746 the Free Software Foundation; either version 3, or (at your option)\n\
747 any later version.\n\
748\n\
749 It is distributed in the hope that it will be useful, but WITHOUT\n\
750 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
751 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public\n\
752 License for more details.\n\
753\n\
754 You should have received a copy of the GNU General Public License\n\
755 along with this program; if not, write to the Free Software\n\
756 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
757 MA 02110-1301, USA. */\n");
758}
759
40b8e679
L		 760/* Remove leading white spaces. */
761
762static char *
763remove_leading_whitespaces (char *str)
764{
765 while (ISSPACE (*str))
766 str++;
767 return str;
768}
769
770/* Remove trailing white spaces. */
771
772static void
773remove_trailing_whitespaces (char *str)
774{
775 size_t last = strlen (str);
776
777 if (last == 0)
778 return;
779
780 do
781 {
782 last--;
783 if (ISSPACE (str [last]))
784 str[last] = '\0';
785 else
786 break;
787 }
788 while (last != 0);
789}
790
93b1ec2c 791/* Find next field separated by SEP and terminate it. Return a
40b8e679
L		 792 pointer to the one after it. */
793
794static char *
c587b3f9 795next_field (char *str, char sep, char **next, char *last)
40b8e679
L		 796{
797 char *p;
798
799 p = remove_leading_whitespaces (str);
93b1ec2c 800 for (str = p; *str != sep && *str != '\0'; str++);
40b8e679
L		 801
802 *str = '\0';
803 remove_trailing_whitespaces (p);
804
29c048b6 805 *next = str + 1;
40b8e679 806
c587b3f9
L		 807 if (p >= last)
808 abort ();
809
40b8e679
L		 810 return p;
811}
812
1848e567
L		 813static void set_bitfield (char *, bitfield *, int, unsigned int, int);
814
815static int
dc821c5f
JB		 816set_bitfield_from_shorthand (char *f, bitfield *array, unsigned int size,
817 int lineno)
1848e567
L		 818{
819 char *str, *next, *last;
820 unsigned int i;
821
822 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
823 if (strcmp (cpu_flag_init[i].name, f) == 0)
824 {
825 /* Turn on selective bits. */
826 char *init = xstrdup (cpu_flag_init[i].init);
827 last = init + strlen (init);
828 for (next = init; next && next < last; )
829 {
830 str = next_field (next, '|', &next, last);
831 if (str)
832 set_bitfield (str, array, 1, size, lineno);
833 }
834 free (init);
835 return 0;
836 }
837
dc821c5f
JB		 838 for (i = 0; i < ARRAY_SIZE (operand_type_shorthands); i++)
839 if (strcmp (operand_type_shorthands[i].name, f) == 0)
840 {
841 /* Turn on selective bits. */
842 char *init = xstrdup (operand_type_shorthands[i].init);
843 last = init + strlen (init);
844 for (next = init; next && next < last; )
845 {
846 str = next_field (next, '|', &next, last);
847 if (str)
848 set_bitfield (str, array, 1, size, lineno);
849 }
850 free (init);
851 return 0;
852 }
853
1848e567
L		 854 return -1;
855}
856
40fb9820 857static void
1848e567 858set_bitfield (char *f, bitfield *array, int value,
8a9036a4 859 unsigned int size, int lineno)
40fb9820
L		 860{
861 unsigned int i;
862
309d3373
JB		 863 if (strcmp (f, "CpuFP") == 0)
864 {
8a9036a4
L		 865 set_bitfield("Cpu387", array, value, size, lineno);
866 set_bitfield("Cpu287", array, value, size, lineno);
309d3373
JB		 867 f = "Cpu8087";
868 }
869 else if (strcmp (f, "Mmword") == 0)
7d5e4556
L		 870 f= "Qword";
871 else if (strcmp (f, "Oword") == 0)
872 f= "Xmmword";
40fb9820
L		 873
874 for (i = 0; i < size; i++)
875 if (strcasecmp (array[i].name, f) == 0)
876 {
8a9036a4 877 array[i].value = value;
40fb9820
L		 878 return;
879 }
880
2bf05e57
L		 881 if (value)
882 {
883 const char *v = strchr (f, '=');
884
885 if (v)
886 {
887 size_t n = v - f;
888 char *end;
889
890 for (i = 0; i < size; i++)
891 if (strncasecmp (array[i].name, f, n) == 0)
892 {
893 value = strtol (v + 1, &end, 0);
894 if (*end == '\0')
895 {
896 array[i].value = value;
897 return;
898 }
899 break;
900 }
901 }
902 }
903
dc821c5f
JB		 904 /* Handle shorthands. */
905 if (value == 1 && !set_bitfield_from_shorthand (f, array, size, lineno))
1848e567
L		 906 return;
907
bd5295b2 908 if (lineno != -1)
a6743a54 909 fail (_("%s: %d: unknown bitfield: %s\n"), filename, lineno, f);
bd5295b2 910 else
a6743a54 911 fail (_("unknown bitfield: %s\n"), f);
40fb9820
L		 912}
913
914static void
915output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
916 int macro, const char *comma, const char *indent)
917{
918 unsigned int i;
919
7ac20022
JB		 920 memset (&active_cpu_flags, 0, sizeof(active_cpu_flags));
921
40fb9820
L		 922 fprintf (table, "%s{ { ", indent);
923
924 for (i = 0; i < size - 1; i++)
925 {
10632b79
L		 926 if (((i + 1) % 20) != 0)
927 fprintf (table, "%d, ", flags[i].value);
928 else
929 fprintf (table, "%d,", flags[i].value);
40fb9820
L		 930 if (((i + 1) % 20) == 0)
931 {
932 /* We need \\ for macro. */
933 if (macro)
934 fprintf (table, " \\\n %s", indent);
935 else
936 fprintf (table, "\n %s", indent);
937 }
7ac20022
JB		 938 if (flags[i].value)
939 active_cpu_flags.array[i / 32] |= 1U << (i % 32);
40fb9820
L		 940 }
941
942 fprintf (table, "%d } }%s\n", flags[i].value, comma);
943}
944
945static void
946process_i386_cpu_flag (FILE *table, char *flag, int macro,
bd5295b2
L		 947 const char *comma, const char *indent,
948 int lineno)
40fb9820
L		 949{
950 char *str, *next, *last;
8a9036a4 951 unsigned int i;
40fb9820
L		 952 bitfield flags [ARRAY_SIZE (cpu_flags)];
953
954 /* Copy the default cpu flags. */
955 memcpy (flags, cpu_flags, sizeof (cpu_flags));
956
957 if (strcasecmp (flag, "unknown") == 0)
958 {
40fb9820 959 /* We turn on everything except for cpu64 in case of
8a9036a4
L		 960 CPU_UNKNOWN_FLAGS. */
961 for (i = 0; i < ARRAY_SIZE (flags); i++)
962 if (flags[i].position != Cpu64)
963 flags[i].value = 1;
964 }
965 else if (flag[0] == '~')
966 {
967 last = flag + strlen (flag);
968
969 if (flag[1] == '(')
970 {
971 last -= 1;
972 next = flag + 2;
973 if (*last != ')')
a6743a54 974 fail (_("%s: %d: missing `)' in bitfield: %s\n"), filename,
8a9036a4
L		 975 lineno, flag);
976 *last = '\0';
977 }
978 else
979 next = flag + 1;
980
981 /* First we turn on everything except for cpu64. */
40fb9820
L		 982 for (i = 0; i < ARRAY_SIZE (flags); i++)
983 if (flags[i].position != Cpu64)
984 flags[i].value = 1;
8a9036a4
L		 985
986 /* Turn off selective bits. */
987 for (; next && next < last; )
988 {
989 str = next_field (next, '|', &next, last);
990 if (str)
991 set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
992 }
40fb9820
L		 993 }
994 else if (strcmp (flag, "0"))
995 {
8a9036a4 996 /* Turn on selective bits. */
40fb9820
L		 997 last = flag + strlen (flag);
998 for (next = flag; next && next < last; )
999 {
c587b3f9 1000 str = next_field (next, '|', &next, last);
40fb9820 1001 if (str)
8a9036a4 1002 set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
40fb9820
L		 1003 }
1004 }
1005
1006 output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
1007 comma, indent);
1008}
1009
1010static void
1011output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
1012{
1013 unsigned int i;
1014
1015 fprintf (table, " { ");
1016
1017 for (i = 0; i < size - 1; i++)
1018 {
10632b79
L		 1019 if (((i + 1) % 20) != 0)
1020 fprintf (table, "%d, ", modifier[i].value);
1021 else
1022 fprintf (table, "%d,", modifier[i].value);
40fb9820
L		 1023 if (((i + 1) % 20) == 0)
1024 fprintf (table, "\n ");
1025 }
1026
1027 fprintf (table, "%d },\n", modifier[i].value);
1028}
1029
1030static void
bd5295b2 1031process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
40fb9820
L		 1032{
1033 char *str, *next, *last;
1034 bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
1035
7ac20022
JB		 1036 active_isstring = 0;
1037
40fb9820
L		 1038 /* Copy the default opcode modifier. */
1039 memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
1040
1041 if (strcmp (mod, "0"))
1042 {
1043 last = mod + strlen (mod);
1044 for (next = mod; next && next < last; )
1045 {
c587b3f9 1046 str = next_field (next, '|', &next, last);
40fb9820 1047 if (str)
7ac20022
JB		 1048 {
1049 set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
8a9036a4 1050 lineno);
7ac20022
JB		 1051 if (strcasecmp(str, "IsString") == 0)
1052 active_isstring = 1;
1053 }
40fb9820
L		 1054 }
1055 }
1056 output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
1057}
1058
7ac20022
JB		 1059enum stage {
1060 stage_macros,
1061 stage_opcodes,
1062 stage_registers,
1063};
1064
40fb9820
L		 1065static void
1066output_operand_type (FILE *table, bitfield *types, unsigned int size,
7ac20022 1067 enum stage stage, const char *indent)
40fb9820
L		 1068{
1069 unsigned int i;
1070
1071 fprintf (table, "{ { ");
1072
1073 for (i = 0; i < size - 1; i++)
1074 {
10632b79
L		 1075 if (((i + 1) % 20) != 0)
1076 fprintf (table, "%d, ", types[i].value);
1077 else
1078 fprintf (table, "%d,", types[i].value);
40fb9820
L		 1079 if (((i + 1) % 20) == 0)
1080 {
1081 /* We need \\ for macro. */
7ac20022 1082 if (stage == stage_macros)
10632b79 1083 fprintf (table, " \\\n%s", indent);
40fb9820
L		 1084 else
1085 fprintf (table, "\n%s", indent);
1086 }
1087 }
1088
1089 fprintf (table, "%d } }", types[i].value);
1090}
1091
1092static void
7ac20022 1093process_i386_operand_type (FILE *table, char *op, enum stage stage,
bd5295b2 1094 const char *indent, int lineno)
40fb9820
L		 1095{
1096 char *str, *next, *last;
1097 bitfield types [ARRAY_SIZE (operand_types)];
1098
1099 /* Copy the default operand type. */
1100 memcpy (types, operand_types, sizeof (types));
1101
1102 if (strcmp (op, "0"))
1103 {
7ac20022
JB		 1104 int baseindex = 0;
1105
40fb9820
L		 1106 last = op + strlen (op);
1107 for (next = op; next && next < last; )
1108 {
c587b3f9 1109 str = next_field (next, '|', &next, last);
40fb9820 1110 if (str)
7ac20022
JB		 1111 {
1112 set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
1113 if (strcasecmp(str, "BaseIndex") == 0)
1114 baseindex = 1;
1115 }
1116 }
1117
1118 if (stage == stage_opcodes && baseindex && !active_isstring)
1119 {
1120 set_bitfield("Disp8", types, 1, ARRAY_SIZE (types), lineno);
1121 if (!active_cpu_flags.bitfield.cpu64
1122 && !active_cpu_flags.bitfield.cpumpx)
1123 set_bitfield("Disp16", types, 1, ARRAY_SIZE (types), lineno);
1124 set_bitfield("Disp32", types, 1, ARRAY_SIZE (types), lineno);
1125 if (!active_cpu_flags.bitfield.cpuno64)
1126 set_bitfield("Disp32S", types, 1, ARRAY_SIZE (types), lineno);
40fb9820
L		 1127 }
1128 }
7ac20022 1129 output_operand_type (table, types, ARRAY_SIZE (types), stage,
40fb9820
L		 1130 indent);
1131}
1132
c587b3f9
L		 1133static void
1134output_i386_opcode (FILE *table, const char *name, char *str,
bd5295b2 1135 char *last, int lineno)
c587b3f9
L		 1136{
1137 unsigned int i;
1138 char *operands, *base_opcode, *extension_opcode, *opcode_length;
1139 char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
1140
1141 /* Find number of operands. */
1142 operands = next_field (str, ',', &str, last);
1143
1144 /* Find base_opcode. */
1145 base_opcode = next_field (str, ',', &str, last);
1146
1147 /* Find extension_opcode. */
1148 extension_opcode = next_field (str, ',', &str, last);
1149
1150 /* Find opcode_length. */
1151 opcode_length = next_field (str, ',', &str, last);
1152
1153 /* Find cpu_flags. */
1154 cpu_flags = next_field (str, ',', &str, last);
1155
1156 /* Find opcode_modifier. */
1157 opcode_modifier = next_field (str, ',', &str, last);
1158
1159 /* Remove the first {. */
1160 str = remove_leading_whitespaces (str);
1161 if (*str != '{')
1162 abort ();
1163 str = remove_leading_whitespaces (str + 1);
1164
1165 i = strlen (str);
1166
1167 /* There are at least "X}". */
1168 if (i < 2)
1169 abort ();
1170
1171 /* Remove trailing white spaces and }. */
1172 do
1173 {
1174 i--;
1175 if (ISSPACE (str[i]) || str[i] == '}')
1176 str[i] = '\0';
1177 else
1178 break;
1179 }
1180 while (i != 0);
1181
1182 last = str + i;
1183
1184 /* Find operand_types. */
1185 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1186 {
1187 if (str >= last)
1188 {
1189 operand_types [i] = NULL;
1190 break;
1191 }
1192
1193 operand_types [i] = next_field (str, ',', &str, last);
1194 if (*operand_types[i] == '0')
1195 {
1196 if (i != 0)
1197 operand_types[i] = NULL;
1198 break;
1199 }
1200 }
1201
1202 fprintf (table, " { \"%s\", %s, %s, %s, %s,\n",
1203 name, operands, base_opcode, extension_opcode,
1204 opcode_length);
1205
bd5295b2 1206 process_i386_cpu_flag (table, cpu_flags, 0, ",", " ", lineno);
c587b3f9 1207
bd5295b2 1208 process_i386_opcode_modifier (table, opcode_modifier, lineno);
c587b3f9
L		 1209
1210 fprintf (table, " { ");
1211
1212 for (i = 0; i < ARRAY_SIZE (operand_types); i++)
1213 {
1214 if (operand_types[i] == NULL || *operand_types[i] == '0')
1215 {
1216 if (i == 0)
7ac20022
JB		 1217 process_i386_operand_type (table, "0", stage_opcodes, "\t ",
1218 lineno);
c587b3f9
L		 1219 break;
1220 }
1221
1222 if (i != 0)
1223 fprintf (table, ",\n ");
1224
7ac20022 1225 process_i386_operand_type (table, operand_types[i], stage_opcodes,
bd5295b2 1226 "\t ", lineno);
c587b3f9
L		 1227 }
1228 fprintf (table, " } },\n");
1229}
1230
1231struct opcode_hash_entry
1232{
1233 struct opcode_hash_entry *next;
1234 char *name;
1235 char *opcode;
bd5295b2 1236 int lineno;
c587b3f9
L		 1237};
1238
1239/* Calculate the hash value of an opcode hash entry P. */
1240
1241static hashval_t
1242opcode_hash_hash (const void *p)
1243{
1244 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1245 return htab_hash_string (entry->name);
1246}
1247
1248/* Compare a string Q against an opcode hash entry P. */
1249
1250static int
1251opcode_hash_eq (const void *p, const void *q)
1252{
1253 struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
1254 const char *name = (const char *) q;
1255 return strcmp (name, entry->name) == 0;
1256}
1257
40b8e679 1258static void
72ffa0fb 1259process_i386_opcodes (FILE *table)
40b8e679 1260{
3d4d5afa 1261 FILE *fp;
40b8e679 1262 char buf[2048];
c587b3f9
L		 1263 unsigned int i, j;
1264 char *str, *p, *last, *name;
1265 struct opcode_hash_entry **hash_slot, **entry, *next;
1266 htab_t opcode_hash_table;
1267 struct opcode_hash_entry **opcode_array;
1268 unsigned int opcode_array_size = 1024;
bd5295b2 1269 int lineno = 0;
40b8e679 1270
3d4d5afa
L		 1271 filename = "i386-opc.tbl";
1272 fp = fopen (filename, "r");
1273
40b8e679 1274 if (fp == NULL)
34edb9ad 1275 fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
40fb9820 1276 xstrerror (errno));
40b8e679 1277
c587b3f9
L		 1278 i = 0;
1279 opcode_array = (struct opcode_hash_entry **)
1280 xmalloc (sizeof (*opcode_array) * opcode_array_size);
1281
1282 opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
1283 opcode_hash_eq, NULL,
1284 xcalloc, free);
1285
34edb9ad 1286 fprintf (table, "\n/* i386 opcode table. */\n\n");
d3ce72d0 1287 fprintf (table, "const insn_template i386_optab[] =\n{\n");
40b8e679 1288
c587b3f9 1289 /* Put everything on opcode array. */
40b8e679
L		 1290 while (!feof (fp))
1291 {
1292 if (fgets (buf, sizeof (buf), fp) == NULL)
1293 break;
1294
3d4d5afa
L		 1295 lineno++;
1296
40b8e679
L		 1297 p = remove_leading_whitespaces (buf);
1298
1299 /* Skip comments. */
1300 str = strstr (p, "//");
1301 if (str != NULL)
1302 str[0] = '\0';
1303
1304 /* Remove trailing white spaces. */
1305 remove_trailing_whitespaces (p);
1306
1307 switch (p[0])
1308 {
1309 case '#':
c587b3f9 1310 /* Ignore comments. */
40b8e679
L		 1311 case '\0':
1312 continue;
1313 break;
1314 default:
1315 break;
1316 }
1317
1318 last = p + strlen (p);
1319
1320 /* Find name. */
c587b3f9 1321 name = next_field (p, ',', &str, last);
40b8e679 1322
c587b3f9
L		 1323 /* Get the slot in hash table. */
1324 hash_slot = (struct opcode_hash_entry **)
1325 htab_find_slot_with_hash (opcode_hash_table, name,
1326 htab_hash_string (name),
1327 INSERT);
40b8e679 1328
c587b3f9 1329 if (*hash_slot == NULL)
40b8e679 1330 {
c587b3f9
L		 1331 /* It is the new one. Put it on opcode array. */
1332 if (i >= opcode_array_size)
40b8e679 1333 {
c587b3f9
L		 1334 /* Grow the opcode array when needed. */
1335 opcode_array_size += 1024;
1336 opcode_array = (struct opcode_hash_entry **)
1337 xrealloc (opcode_array,
1338 sizeof (*opcode_array) * opcode_array_size);
40b8e679
L		 1339 }
1340
c587b3f9
L		 1341 opcode_array[i] = (struct opcode_hash_entry *)
1342 xmalloc (sizeof (struct opcode_hash_entry));
1343 opcode_array[i]->next = NULL;
1344 opcode_array[i]->name = xstrdup (name);
1345 opcode_array[i]->opcode = xstrdup (str);
bd5295b2 1346 opcode_array[i]->lineno = lineno;
c587b3f9
L		 1347 *hash_slot = opcode_array[i];
1348 i++;
40b8e679 1349 }
c587b3f9 1350 else
40b8e679 1351 {
c587b3f9
L		 1352 /* Append it to the existing one. */
1353 entry = hash_slot;
1354 while ((*entry) != NULL)
1355 entry = &(*entry)->next;
1356 *entry = (struct opcode_hash_entry *)
1357 xmalloc (sizeof (struct opcode_hash_entry));
1358 (*entry)->next = NULL;
1359 (*entry)->name = (*hash_slot)->name;
1360 (*entry)->opcode = xstrdup (str);
bd5295b2 1361 (*entry)->lineno = lineno;
c587b3f9
L		 1362 }
1363 }
40b8e679 1364
c587b3f9
L		 1365 /* Process opcode array. */
1366 for (j = 0; j < i; j++)
1367 {
1368 for (next = opcode_array[j]; next; next = next->next)
1369 {
1370 name = next->name;
1371 str = next->opcode;
bd5295b2 1372 lineno = next->lineno;
c587b3f9 1373 last = str + strlen (str);
bd5295b2 1374 output_i386_opcode (table, name, str, last, lineno);
40b8e679 1375 }
40b8e679
L		 1376 }
1377
34edb9ad
L		 1378 fclose (fp);
1379
4dffcebc 1380 fprintf (table, " { NULL, 0, 0, 0, 0,\n");
40fb9820 1381
bd5295b2 1382 process_i386_cpu_flag (table, "0", 0, ",", " ", -1);
40fb9820 1383
bd5295b2 1384 process_i386_opcode_modifier (table, "0", -1);
29c048b6 1385
40fb9820 1386 fprintf (table, " { ");
7ac20022 1387 process_i386_operand_type (table, "0", stage_opcodes, "\t ", -1);
40fb9820
L		 1388 fprintf (table, " } }\n");
1389
34edb9ad 1390 fprintf (table, "};\n");
40b8e679
L		 1391}
1392
1393static void
72ffa0fb 1394process_i386_registers (FILE *table)
40b8e679 1395{
3d4d5afa 1396 FILE *fp;
40b8e679
L		 1397 char buf[2048];
1398 char *str, *p, *last;
1399 char *reg_name, *reg_type, *reg_flags, *reg_num;
a60de03c 1400 char *dw2_32_num, *dw2_64_num;
bd5295b2 1401 int lineno = 0;
40b8e679 1402
3d4d5afa
L		 1403 filename = "i386-reg.tbl";
1404 fp = fopen (filename, "r");
40b8e679 1405 if (fp == NULL)
34edb9ad 1406 fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
40fb9820 1407 xstrerror (errno));
40b8e679 1408
34edb9ad
L		 1409 fprintf (table, "\n/* i386 register table. */\n\n");
1410 fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
40b8e679
L		 1411
1412 while (!feof (fp))
1413 {
1414 if (fgets (buf, sizeof (buf), fp) == NULL)
1415 break;
1416
3d4d5afa
L		 1417 lineno++;
1418
40b8e679
L		 1419 p = remove_leading_whitespaces (buf);
1420
1421 /* Skip comments. */
1422 str = strstr (p, "//");
1423 if (str != NULL)
1424 str[0] = '\0';
1425
1426 /* Remove trailing white spaces. */
1427 remove_trailing_whitespaces (p);
1428
1429 switch (p[0])
1430 {
1431 case '#':
34edb9ad 1432 fprintf (table, "%s\n", p);
40b8e679
L		 1433 case '\0':
1434 continue;
1435 break;
1436 default:
1437 break;
1438 }
1439
1440 last = p + strlen (p);
1441
1442 /* Find reg_name. */
c587b3f9 1443 reg_name = next_field (p, ',', &str, last);
40b8e679
L		 1444
1445 /* Find reg_type. */
c587b3f9 1446 reg_type = next_field (str, ',', &str, last);
40b8e679
L		 1447
1448 /* Find reg_flags. */
c587b3f9 1449 reg_flags = next_field (str, ',', &str, last);
40b8e679
L		 1450
1451 /* Find reg_num. */
c587b3f9 1452 reg_num = next_field (str, ',', &str, last);
a60de03c 1453
40fb9820
L		 1454 fprintf (table, " { \"%s\",\n ", reg_name);
1455
7ac20022
JB		 1456 process_i386_operand_type (table, reg_type, stage_registers, "\t",
1457 lineno);
40fb9820 1458
a60de03c 1459 /* Find 32-bit Dwarf2 register number. */
c587b3f9 1460 dw2_32_num = next_field (str, ',', &str, last);
a60de03c
JB		 1461
1462 /* Find 64-bit Dwarf2 register number. */
c587b3f9 1463 dw2_64_num = next_field (str, ',', &str, last);
a60de03c
JB		 1464
1465 fprintf (table, ",\n %s, %s, { %s, %s } },\n",
1466 reg_flags, reg_num, dw2_32_num, dw2_64_num);
40b8e679
L		 1467 }
1468
34edb9ad
L		 1469 fclose (fp);
1470
1471 fprintf (table, "};\n");
40b8e679 1472
34edb9ad 1473 fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
40b8e679
L		 1474}
1475
40fb9820
L		 1476static void
1477process_i386_initializers (void)
1478{
1479 unsigned int i;
1480 FILE *fp = fopen ("i386-init.h", "w");
1481 char *init;
1482
1483 if (fp == NULL)
1484 fail (_("can't create i386-init.h, errno = %s\n"),
1485 xstrerror (errno));
1486
1487 process_copyright (fp);
1488
1489 for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1490 {
1491 fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1492 init = xstrdup (cpu_flag_init[i].init);
bd5295b2 1493 process_i386_cpu_flag (fp, init, 1, "", " ", -1);
40fb9820
L		 1494 free (init);
1495 }
1496
1497 for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1498 {
1499 fprintf (fp, "\n\n#define %s \\\n ", operand_type_init[i].name);
1500 init = xstrdup (operand_type_init[i].init);
7ac20022 1501 process_i386_operand_type (fp, init, stage_macros, " ", -1);
40fb9820
L		 1502 free (init);
1503 }
1504 fprintf (fp, "\n");
1505
1506 fclose (fp);
1507}
1508
40b8e679
L		 1509/* Program options. */
1510#define OPTION_SRCDIR 200
1511
29c048b6 1512struct option long_options[] =
40b8e679
L		 1513{
1514 {"srcdir", required_argument, NULL, OPTION_SRCDIR},
1515 {"debug", no_argument, NULL, 'd'},
1516 {"version", no_argument, NULL, 'V'},
1517 {"help", no_argument, NULL, 'h'},
1518 {0, no_argument, NULL, 0}
1519};
1520
1521static void
1522print_version (void)
1523{
1524 printf ("%s: version 1.0\n", program_name);
1525 xexit (0);
1526}
1527
1528static void
1529usage (FILE * stream, int status)
1530{
1531 fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1532 program_name);
1533 xexit (status);
1534}
1535
1536int
1537main (int argc, char **argv)
1538{
1539 extern int chdir (char *);
1540 char *srcdir = NULL;
8b40d594 1541 int c;
e92bae62 1542 unsigned int i, cpumax;
72ffa0fb 1543 FILE *table;
29c048b6 1544
40b8e679
L		 1545 program_name = *argv;
1546 xmalloc_set_program_name (program_name);
1547
1548 while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1549 switch (c)
1550 {
1551 case OPTION_SRCDIR:
1552 srcdir = optarg;
1553 break;
1554 case 'V':
1555 case 'v':
1556 print_version ();
1557 break;
1558 case 'd':
1559 debug = 1;
1560 break;
1561 case 'h':
1562 case '?':
1563 usage (stderr, 0);
1564 default:
1565 case 0:
1566 break;
1567 }
1568
1569 if (optind != argc)
1570 usage (stdout, 1);
1571
29c048b6 1572 if (srcdir != NULL)
40b8e679
L		 1573 if (chdir (srcdir) != 0)
1574 fail (_("unable to change directory to \"%s\", errno = %s\n"),
40fb9820
L		 1575 srcdir, xstrerror (errno));
1576
e92bae62
L		 1577 /* cpu_flags isn't sorted by position. */
1578 cpumax = 0;
1579 for (i = 0; i < ARRAY_SIZE (cpu_flags); i++)
1580 if (cpu_flags[i].position > cpumax)
1581 cpumax = cpu_flags[i].position;
1582
40fb9820 1583 /* Check the unused bitfield in i386_cpu_flags. */
e89c5eaa 1584#ifdef CpuUnused
e92bae62
L		 1585 if ((cpumax - 1) != CpuMax)
1586 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1587#else
e92bae62
L		 1588 if (cpumax != CpuMax)
1589 fail (_("CpuMax != %d!\n"), cpumax);
e89c5eaa 1590
8b40d594
L		 1591 c = CpuNumOfBits - CpuMax - 1;
1592 if (c)
1593 fail (_("%d unused bits in i386_cpu_flags.\n"), c);
40fb9820
L		 1594#endif
1595
1596 /* Check the unused bitfield in i386_operand_type. */
1597#ifndef OTUnused
8b40d594
L		 1598 c = OTNumOfBits - OTMax - 1;
1599 if (c)
1600 fail (_("%d unused bits in i386_operand_type.\n"), c);
40fb9820
L		 1601#endif
1602
1603 qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1604 compare);
1605
1606 qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1607 sizeof (opcode_modifiers [0]), compare);
1608
1609 qsort (operand_types, ARRAY_SIZE (operand_types),
1610 sizeof (operand_types [0]), compare);
40b8e679 1611
34edb9ad
L		 1612 table = fopen ("i386-tbl.h", "w");
1613 if (table == NULL)
40fb9820
L		 1614 fail (_("can't create i386-tbl.h, errno = %s\n"),
1615 xstrerror (errno));
34edb9ad 1616
72ffa0fb 1617 process_copyright (table);
40b8e679 1618
72ffa0fb
L		 1619 process_i386_opcodes (table);
1620 process_i386_registers (table);
40fb9820 1621 process_i386_initializers ();
40b8e679 1622
34edb9ad
L		 1623 fclose (table);
1624
40b8e679
L		 1625 exit (0);
1626}
GDB Binutils - Deliverables
This page took 0.669595 seconds and 4 git commands to generate.