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