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