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