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