1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "disassembler_x86.h" 18 19 #include <inttypes.h> 20 21 #include <ostream> 22 #include <sstream> 23 24 #include "base/logging.h" 25 #include "base/stringprintf.h" 26 #include "thread.h" 27 28 namespace art { 29 namespace x86 { 30 31 size_t DisassemblerX86::Dump(std::ostream& os, const uint8_t* begin) { 32 return DumpInstruction(os, begin); 33 } 34 35 void DisassemblerX86::Dump(std::ostream& os, const uint8_t* begin, const uint8_t* end) { 36 size_t length = 0; 37 for (const uint8_t* cur = begin; cur < end; cur += length) { 38 length = DumpInstruction(os, cur); 39 } 40 } 41 42 static const char* gReg8Names[] = { 43 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh" 44 }; 45 static const char* gExtReg8Names[] = { 46 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", 47 "r8l", "r9l", "r10l", "r11l", "r12l", "r13l", "r14l", "r15l" 48 }; 49 static const char* gReg16Names[] = { 50 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", 51 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" 52 }; 53 static const char* gReg32Names[] = { 54 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", 55 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" 56 }; 57 static const char* gReg64Names[] = { 58 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", 59 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 60 }; 61 62 // 64-bit opcode REX modifier. 63 constexpr uint8_t REX_W = 8U /* 0b1000 */; 64 constexpr uint8_t REX_R = 4U /* 0b0100 */; 65 constexpr uint8_t REX_X = 2U /* 0b0010 */; 66 constexpr uint8_t REX_B = 1U /* 0b0001 */; 67 68 static void DumpReg0(std::ostream& os, uint8_t rex, size_t reg, 69 bool byte_operand, uint8_t size_override) { 70 DCHECK_LT(reg, (rex == 0) ? 8u : 16u); 71 bool rex_w = (rex & REX_W) != 0; 72 if (byte_operand) { 73 os << ((rex == 0) ? gReg8Names[reg] : gExtReg8Names[reg]); 74 } else if (rex_w) { 75 os << gReg64Names[reg]; 76 } else if (size_override == 0x66) { 77 os << gReg16Names[reg]; 78 } else { 79 os << gReg32Names[reg]; 80 } 81 } 82 83 static void DumpAnyReg(std::ostream& os, uint8_t rex, size_t reg, 84 bool byte_operand, uint8_t size_override, RegFile reg_file) { 85 if (reg_file == GPR) { 86 DumpReg0(os, rex, reg, byte_operand, size_override); 87 } else if (reg_file == SSE) { 88 os << "xmm" << reg; 89 } else { 90 os << "mm" << reg; 91 } 92 } 93 94 static void DumpReg(std::ostream& os, uint8_t rex, uint8_t reg, 95 bool byte_operand, uint8_t size_override, RegFile reg_file) { 96 bool rex_r = (rex & REX_R) != 0; 97 size_t reg_num = rex_r ? (reg + 8) : reg; 98 DumpAnyReg(os, rex, reg_num, byte_operand, size_override, reg_file); 99 } 100 101 static void DumpRmReg(std::ostream& os, uint8_t rex, uint8_t reg, 102 bool byte_operand, uint8_t size_override, RegFile reg_file) { 103 bool rex_b = (rex & REX_B) != 0; 104 size_t reg_num = rex_b ? (reg + 8) : reg; 105 DumpAnyReg(os, rex, reg_num, byte_operand, size_override, reg_file); 106 } 107 108 static void DumpAddrReg(std::ostream& os, uint8_t rex, uint8_t reg) { 109 if (rex != 0) { 110 os << gReg64Names[reg]; 111 } else { 112 os << gReg32Names[reg]; 113 } 114 } 115 116 static void DumpBaseReg(std::ostream& os, uint8_t rex, uint8_t reg) { 117 bool rex_b = (rex & REX_B) != 0; 118 size_t reg_num = rex_b ? (reg + 8) : reg; 119 DumpAddrReg(os, rex, reg_num); 120 } 121 122 static void DumpOpcodeReg(std::ostream& os, uint8_t rex, uint8_t reg, 123 bool byte_operand, uint8_t size_override) { 124 bool rex_b = (rex & REX_B) != 0; 125 size_t reg_num = rex_b ? (reg + 8) : reg; 126 DumpReg0(os, rex, reg_num, byte_operand, size_override); 127 } 128 129 enum SegmentPrefix { 130 kCs = 0x2e, 131 kSs = 0x36, 132 kDs = 0x3e, 133 kEs = 0x26, 134 kFs = 0x64, 135 kGs = 0x65, 136 }; 137 138 static void DumpSegmentOverride(std::ostream& os, uint8_t segment_prefix) { 139 switch (segment_prefix) { 140 case kCs: os << "cs:"; break; 141 case kSs: os << "ss:"; break; 142 case kDs: os << "ds:"; break; 143 case kEs: os << "es:"; break; 144 case kFs: os << "fs:"; break; 145 case kGs: os << "gs:"; break; 146 default: break; 147 } 148 } 149 150 // Do not inline to avoid Clang stack frame problems. b/18733806 151 NO_INLINE 152 static std::string DumpCodeHex(const uint8_t* begin, const uint8_t* end) { 153 std::stringstream hex; 154 for (size_t i = 0; begin + i < end; ++i) { 155 hex << StringPrintf("%02X", begin[i]); 156 } 157 return hex.str(); 158 } 159 160 std::string DisassemblerX86::DumpAddress(uint8_t mod, uint8_t rm, uint8_t rex64, uint8_t rex_w, 161 bool no_ops, bool byte_operand, bool byte_second_operand, 162 uint8_t* prefix, bool load, RegFile src_reg_file, 163 RegFile dst_reg_file, const uint8_t** instr, 164 uint32_t* address_bits) { 165 std::ostringstream address; 166 if (mod == 0 && rm == 5) { 167 if (!supports_rex_) { // Absolute address. 168 *address_bits = *reinterpret_cast<const uint32_t*>(*instr); 169 address << StringPrintf("[0x%x]", *address_bits); 170 } else { // 64-bit RIP relative addressing. 171 address << StringPrintf("[RIP + 0x%x]", *reinterpret_cast<const uint32_t*>(*instr)); 172 } 173 (*instr) += 4; 174 } else if (rm == 4 && mod != 3) { // SIB 175 uint8_t sib = **instr; 176 (*instr)++; 177 uint8_t scale = (sib >> 6) & 3; 178 uint8_t index = (sib >> 3) & 7; 179 uint8_t base = sib & 7; 180 address << "["; 181 182 // REX.x is bit 3 of index. 183 if ((rex64 & REX_X) != 0) { 184 index += 8; 185 } 186 187 // Mod = 0 && base = 5 (ebp): no base (ignores REX.b). 188 bool has_base = false; 189 if (base != 5 || mod != 0) { 190 has_base = true; 191 DumpBaseReg(address, rex64, base); 192 } 193 194 // Index = 4 (esp/rsp) is disallowed. 195 if (index != 4) { 196 if (has_base) { 197 address << " + "; 198 } 199 DumpAddrReg(address, rex64, index); 200 if (scale != 0) { 201 address << StringPrintf(" * %d", 1 << scale); 202 } 203 } 204 205 if (mod == 0) { 206 if (base == 5) { 207 if (index != 4) { 208 address << StringPrintf(" + %d", *reinterpret_cast<const int32_t*>(*instr)); 209 } else { 210 // 64-bit low 32-bit absolute address, redundant absolute address encoding on 32-bit. 211 *address_bits = *reinterpret_cast<const uint32_t*>(*instr); 212 address << StringPrintf("%d", *address_bits); 213 } 214 (*instr) += 4; 215 } 216 } else if (mod == 1) { 217 address << StringPrintf(" + %d", *reinterpret_cast<const int8_t*>(*instr)); 218 (*instr)++; 219 } else if (mod == 2) { 220 address << StringPrintf(" + %d", *reinterpret_cast<const int32_t*>(*instr)); 221 (*instr) += 4; 222 } 223 address << "]"; 224 } else { 225 if (mod == 3) { 226 if (!no_ops) { 227 DumpRmReg(address, rex_w, rm, byte_operand || byte_second_operand, 228 prefix[2], load ? src_reg_file : dst_reg_file); 229 } 230 } else { 231 address << "["; 232 DumpBaseReg(address, rex64, rm); 233 if (mod == 1) { 234 address << StringPrintf(" + %d", *reinterpret_cast<const int8_t*>(*instr)); 235 (*instr)++; 236 } else if (mod == 2) { 237 address << StringPrintf(" + %d", *reinterpret_cast<const int32_t*>(*instr)); 238 (*instr) += 4; 239 } 240 address << "]"; 241 } 242 } 243 return address.str(); 244 } 245 246 size_t DisassemblerX86::DumpInstruction(std::ostream& os, const uint8_t* instr) { 247 const uint8_t* begin_instr = instr; 248 bool have_prefixes = true; 249 uint8_t prefix[4] = {0, 0, 0, 0}; 250 do { 251 switch (*instr) { 252 // Group 1 - lock and repeat prefixes: 253 case 0xF0: 254 case 0xF2: 255 case 0xF3: 256 prefix[0] = *instr; 257 break; 258 // Group 2 - segment override prefixes: 259 case kCs: 260 case kSs: 261 case kDs: 262 case kEs: 263 case kFs: 264 case kGs: 265 prefix[1] = *instr; 266 break; 267 // Group 3 - operand size override: 268 case 0x66: 269 prefix[2] = *instr; 270 break; 271 // Group 4 - address size override: 272 case 0x67: 273 prefix[3] = *instr; 274 break; 275 default: 276 have_prefixes = false; 277 break; 278 } 279 if (have_prefixes) { 280 instr++; 281 } 282 } while (have_prefixes); 283 uint8_t rex = (supports_rex_ && (*instr >= 0x40) && (*instr <= 0x4F)) ? *instr : 0; 284 if (rex != 0) { 285 instr++; 286 } 287 const char** modrm_opcodes = nullptr; 288 bool has_modrm = false; 289 bool reg_is_opcode = false; 290 size_t immediate_bytes = 0; 291 size_t branch_bytes = 0; 292 std::string opcode_tmp; // Storage to keep StringPrintf result alive. 293 const char* opcode0 = ""; // Prefix part. 294 const char* opcode1 = ""; // Main opcode. 295 const char* opcode2 = ""; // Sub-opcode. E.g., jump type. 296 const char* opcode3 = ""; // Mod-rm part. 297 const char* opcode4 = ""; // Suffix part. 298 bool store = false; // stores to memory (ie rm is on the left) 299 bool load = false; // loads from memory (ie rm is on the right) 300 bool byte_operand = false; // true when the opcode is dealing with byte operands 301 // true when the source operand is a byte register but the target register isn't 302 // (ie movsxb/movzxb). 303 bool byte_second_operand = false; 304 bool target_specific = false; // register name depends on target (64 vs 32 bits). 305 bool ax = false; // implicit use of ax 306 bool cx = false; // implicit use of cx 307 bool reg_in_opcode = false; // low 3-bits of opcode encode register parameter 308 bool no_ops = false; 309 RegFile src_reg_file = GPR; 310 RegFile dst_reg_file = GPR; 311 switch (*instr) { 312 #define DISASSEMBLER_ENTRY(opname, \ 313 rm8_r8, rm32_r32, \ 314 r8_rm8, r32_rm32, \ 315 ax8_i8, ax32_i32) \ 316 case rm8_r8: opcode1 = #opname; store = true; has_modrm = true; byte_operand = true; break; \ 317 case rm32_r32: opcode1 = #opname; store = true; has_modrm = true; break; \ 318 case r8_rm8: opcode1 = #opname; load = true; has_modrm = true; byte_operand = true; break; \ 319 case r32_rm32: opcode1 = #opname; load = true; has_modrm = true; break; \ 320 case ax8_i8: opcode1 = #opname; ax = true; immediate_bytes = 1; byte_operand = true; break; \ 321 case ax32_i32: opcode1 = #opname; ax = true; immediate_bytes = 4; break; 322 323 DISASSEMBLER_ENTRY(add, 324 0x00 /* RegMem8/Reg8 */, 0x01 /* RegMem32/Reg32 */, 325 0x02 /* Reg8/RegMem8 */, 0x03 /* Reg32/RegMem32 */, 326 0x04 /* Rax8/imm8 opcode */, 0x05 /* Rax32/imm32 */) 327 DISASSEMBLER_ENTRY(or, 328 0x08 /* RegMem8/Reg8 */, 0x09 /* RegMem32/Reg32 */, 329 0x0A /* Reg8/RegMem8 */, 0x0B /* Reg32/RegMem32 */, 330 0x0C /* Rax8/imm8 opcode */, 0x0D /* Rax32/imm32 */) 331 DISASSEMBLER_ENTRY(adc, 332 0x10 /* RegMem8/Reg8 */, 0x11 /* RegMem32/Reg32 */, 333 0x12 /* Reg8/RegMem8 */, 0x13 /* Reg32/RegMem32 */, 334 0x14 /* Rax8/imm8 opcode */, 0x15 /* Rax32/imm32 */) 335 DISASSEMBLER_ENTRY(sbb, 336 0x18 /* RegMem8/Reg8 */, 0x19 /* RegMem32/Reg32 */, 337 0x1A /* Reg8/RegMem8 */, 0x1B /* Reg32/RegMem32 */, 338 0x1C /* Rax8/imm8 opcode */, 0x1D /* Rax32/imm32 */) 339 DISASSEMBLER_ENTRY(and, 340 0x20 /* RegMem8/Reg8 */, 0x21 /* RegMem32/Reg32 */, 341 0x22 /* Reg8/RegMem8 */, 0x23 /* Reg32/RegMem32 */, 342 0x24 /* Rax8/imm8 opcode */, 0x25 /* Rax32/imm32 */) 343 DISASSEMBLER_ENTRY(sub, 344 0x28 /* RegMem8/Reg8 */, 0x29 /* RegMem32/Reg32 */, 345 0x2A /* Reg8/RegMem8 */, 0x2B /* Reg32/RegMem32 */, 346 0x2C /* Rax8/imm8 opcode */, 0x2D /* Rax32/imm32 */) 347 DISASSEMBLER_ENTRY(xor, 348 0x30 /* RegMem8/Reg8 */, 0x31 /* RegMem32/Reg32 */, 349 0x32 /* Reg8/RegMem8 */, 0x33 /* Reg32/RegMem32 */, 350 0x34 /* Rax8/imm8 opcode */, 0x35 /* Rax32/imm32 */) 351 DISASSEMBLER_ENTRY(cmp, 352 0x38 /* RegMem8/Reg8 */, 0x39 /* RegMem32/Reg32 */, 353 0x3A /* Reg8/RegMem8 */, 0x3B /* Reg32/RegMem32 */, 354 0x3C /* Rax8/imm8 opcode */, 0x3D /* Rax32/imm32 */) 355 356 #undef DISASSEMBLER_ENTRY 357 case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: 358 opcode1 = "push"; 359 reg_in_opcode = true; 360 target_specific = true; 361 break; 362 case 0x58: case 0x59: case 0x5A: case 0x5B: case 0x5C: case 0x5D: case 0x5E: case 0x5F: 363 opcode1 = "pop"; 364 reg_in_opcode = true; 365 target_specific = true; 366 break; 367 case 0x63: 368 if ((rex & REX_W) != 0) { 369 opcode1 = "movsxd"; 370 has_modrm = true; 371 load = true; 372 } else { 373 // In 32-bit mode (!supports_rex_) this is ARPL, with no REX prefix the functionality is the 374 // same as 'mov' but the use of the instruction is discouraged. 375 opcode_tmp = StringPrintf("unknown opcode '%02X'", *instr); 376 opcode1 = opcode_tmp.c_str(); 377 } 378 break; 379 case 0x68: opcode1 = "push"; immediate_bytes = 4; break; 380 case 0x69: opcode1 = "imul"; load = true; has_modrm = true; immediate_bytes = 4; break; 381 case 0x6A: opcode1 = "push"; immediate_bytes = 1; break; 382 case 0x6B: opcode1 = "imul"; load = true; has_modrm = true; immediate_bytes = 1; break; 383 case 0x70: case 0x71: case 0x72: case 0x73: case 0x74: case 0x75: case 0x76: case 0x77: 384 case 0x78: case 0x79: case 0x7A: case 0x7B: case 0x7C: case 0x7D: case 0x7E: case 0x7F: 385 static const char* condition_codes[] = 386 {"o", "no", "b/nae/c", "nb/ae/nc", "z/eq", "nz/ne", "be/na", "nbe/a", 387 "s", "ns", "p/pe", "np/po", "l/nge", "nl/ge", "le/ng", "nle/g" 388 }; 389 opcode1 = "j"; 390 opcode2 = condition_codes[*instr & 0xF]; 391 branch_bytes = 1; 392 break; 393 case 0x86: case 0x87: 394 opcode1 = "xchg"; 395 store = true; 396 has_modrm = true; 397 byte_operand = (*instr == 0x86); 398 break; 399 case 0x88: opcode1 = "mov"; store = true; has_modrm = true; byte_operand = true; break; 400 case 0x89: opcode1 = "mov"; store = true; has_modrm = true; break; 401 case 0x8A: opcode1 = "mov"; load = true; has_modrm = true; byte_operand = true; break; 402 case 0x8B: opcode1 = "mov"; load = true; has_modrm = true; break; 403 404 case 0x0F: // 2 byte extended opcode 405 instr++; 406 switch (*instr) { 407 case 0x10: case 0x11: 408 if (prefix[0] == 0xF2) { 409 opcode1 = "movsd"; 410 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 411 } else if (prefix[0] == 0xF3) { 412 opcode1 = "movss"; 413 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 414 } else if (prefix[2] == 0x66) { 415 opcode1 = "movupd"; 416 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 417 } else { 418 opcode1 = "movups"; 419 } 420 has_modrm = true; 421 src_reg_file = dst_reg_file = SSE; 422 load = *instr == 0x10; 423 store = !load; 424 break; 425 case 0x12: case 0x13: 426 if (prefix[2] == 0x66) { 427 opcode1 = "movlpd"; 428 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 429 } else if (prefix[0] == 0) { 430 opcode1 = "movlps"; 431 } 432 has_modrm = true; 433 src_reg_file = dst_reg_file = SSE; 434 load = *instr == 0x12; 435 store = !load; 436 break; 437 case 0x16: case 0x17: 438 if (prefix[2] == 0x66) { 439 opcode1 = "movhpd"; 440 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 441 } else if (prefix[0] == 0) { 442 opcode1 = "movhps"; 443 } 444 has_modrm = true; 445 src_reg_file = dst_reg_file = SSE; 446 load = *instr == 0x16; 447 store = !load; 448 break; 449 case 0x28: case 0x29: 450 if (prefix[2] == 0x66) { 451 opcode1 = "movapd"; 452 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 453 } else if (prefix[0] == 0) { 454 opcode1 = "movaps"; 455 } 456 has_modrm = true; 457 src_reg_file = dst_reg_file = SSE; 458 load = *instr == 0x28; 459 store = !load; 460 break; 461 case 0x2A: 462 if (prefix[2] == 0x66) { 463 opcode1 = "cvtpi2pd"; 464 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 465 } else if (prefix[0] == 0xF2) { 466 opcode1 = "cvtsi2sd"; 467 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 468 } else if (prefix[0] == 0xF3) { 469 opcode1 = "cvtsi2ss"; 470 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 471 } else { 472 opcode1 = "cvtpi2ps"; 473 } 474 load = true; 475 has_modrm = true; 476 dst_reg_file = SSE; 477 break; 478 case 0x2C: 479 if (prefix[2] == 0x66) { 480 opcode1 = "cvttpd2pi"; 481 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 482 } else if (prefix[0] == 0xF2) { 483 opcode1 = "cvttsd2si"; 484 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 485 } else if (prefix[0] == 0xF3) { 486 opcode1 = "cvttss2si"; 487 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 488 } else { 489 opcode1 = "cvttps2pi"; 490 } 491 load = true; 492 has_modrm = true; 493 src_reg_file = SSE; 494 break; 495 case 0x2D: 496 if (prefix[2] == 0x66) { 497 opcode1 = "cvtpd2pi"; 498 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 499 } else if (prefix[0] == 0xF2) { 500 opcode1 = "cvtsd2si"; 501 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 502 } else if (prefix[0] == 0xF3) { 503 opcode1 = "cvtss2si"; 504 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 505 } else { 506 opcode1 = "cvtps2pi"; 507 } 508 load = true; 509 has_modrm = true; 510 src_reg_file = SSE; 511 break; 512 case 0x2E: 513 opcode0 = "u"; 514 FALLTHROUGH_INTENDED; 515 case 0x2F: 516 if (prefix[2] == 0x66) { 517 opcode1 = "comisd"; 518 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 519 } else { 520 opcode1 = "comiss"; 521 } 522 has_modrm = true; 523 load = true; 524 src_reg_file = dst_reg_file = SSE; 525 break; 526 case 0x38: // 3 byte extended opcode 527 instr++; 528 if (prefix[2] == 0x66) { 529 switch (*instr) { 530 case 0x01: 531 opcode1 = "phaddw"; 532 prefix[2] = 0; 533 has_modrm = true; 534 load = true; 535 src_reg_file = dst_reg_file = SSE; 536 break; 537 case 0x02: 538 opcode1 = "phaddd"; 539 prefix[2] = 0; 540 has_modrm = true; 541 load = true; 542 src_reg_file = dst_reg_file = SSE; 543 break; 544 case 0x40: 545 opcode1 = "pmulld"; 546 prefix[2] = 0; 547 has_modrm = true; 548 load = true; 549 src_reg_file = dst_reg_file = SSE; 550 break; 551 default: 552 opcode_tmp = StringPrintf("unknown opcode '0F 38 %02X'", *instr); 553 opcode1 = opcode_tmp.c_str(); 554 } 555 } else { 556 opcode_tmp = StringPrintf("unknown opcode '0F 38 %02X'", *instr); 557 opcode1 = opcode_tmp.c_str(); 558 } 559 break; 560 case 0x3A: // 3 byte extended opcode 561 instr++; 562 if (prefix[2] == 0x66) { 563 switch (*instr) { 564 case 0x0A: 565 opcode1 = "roundss"; 566 prefix[2] = 0; 567 has_modrm = true; 568 store = true; 569 src_reg_file = SSE; 570 dst_reg_file = SSE; 571 immediate_bytes = 1; 572 break; 573 case 0x0B: 574 opcode1 = "roundsd"; 575 prefix[2] = 0; 576 has_modrm = true; 577 store = true; 578 src_reg_file = SSE; 579 dst_reg_file = SSE; 580 immediate_bytes = 1; 581 break; 582 case 0x14: 583 opcode1 = "pextrb"; 584 prefix[2] = 0; 585 has_modrm = true; 586 store = true; 587 src_reg_file = SSE; 588 immediate_bytes = 1; 589 break; 590 case 0x15: 591 opcode1 = "pextrw"; 592 prefix[2] = 0; 593 has_modrm = true; 594 store = true; 595 src_reg_file = SSE; 596 immediate_bytes = 1; 597 break; 598 case 0x16: 599 opcode1 = "pextrd"; 600 prefix[2] = 0; 601 has_modrm = true; 602 store = true; 603 src_reg_file = SSE; 604 immediate_bytes = 1; 605 break; 606 default: 607 opcode_tmp = StringPrintf("unknown opcode '0F 3A %02X'", *instr); 608 opcode1 = opcode_tmp.c_str(); 609 } 610 } else { 611 opcode_tmp = StringPrintf("unknown opcode '0F 3A %02X'", *instr); 612 opcode1 = opcode_tmp.c_str(); 613 } 614 break; 615 case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47: 616 case 0x48: case 0x49: case 0x4A: case 0x4B: case 0x4C: case 0x4D: case 0x4E: case 0x4F: 617 opcode1 = "cmov"; 618 opcode2 = condition_codes[*instr & 0xF]; 619 has_modrm = true; 620 load = true; 621 break; 622 case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57: 623 case 0x58: case 0x59: case 0x5C: case 0x5D: case 0x5E: case 0x5F: { 624 switch (*instr) { 625 case 0x50: opcode1 = "movmsk"; break; 626 case 0x51: opcode1 = "sqrt"; break; 627 case 0x52: opcode1 = "rsqrt"; break; 628 case 0x53: opcode1 = "rcp"; break; 629 case 0x54: opcode1 = "and"; break; 630 case 0x55: opcode1 = "andn"; break; 631 case 0x56: opcode1 = "or"; break; 632 case 0x57: opcode1 = "xor"; break; 633 case 0x58: opcode1 = "add"; break; 634 case 0x59: opcode1 = "mul"; break; 635 case 0x5C: opcode1 = "sub"; break; 636 case 0x5D: opcode1 = "min"; break; 637 case 0x5E: opcode1 = "div"; break; 638 case 0x5F: opcode1 = "max"; break; 639 default: LOG(FATAL) << "Unreachable"; UNREACHABLE(); 640 } 641 if (prefix[2] == 0x66) { 642 opcode2 = "pd"; 643 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 644 } else if (prefix[0] == 0xF2) { 645 opcode2 = "sd"; 646 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 647 } else if (prefix[0] == 0xF3) { 648 opcode2 = "ss"; 649 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 650 } else { 651 opcode2 = "ps"; 652 } 653 load = true; 654 has_modrm = true; 655 src_reg_file = dst_reg_file = SSE; 656 break; 657 } 658 case 0x5A: 659 if (prefix[2] == 0x66) { 660 opcode1 = "cvtpd2ps"; 661 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 662 } else if (prefix[0] == 0xF2) { 663 opcode1 = "cvtsd2ss"; 664 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 665 } else if (prefix[0] == 0xF3) { 666 opcode1 = "cvtss2sd"; 667 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 668 } else { 669 opcode1 = "cvtps2pd"; 670 } 671 load = true; 672 has_modrm = true; 673 src_reg_file = dst_reg_file = SSE; 674 break; 675 case 0x5B: 676 if (prefix[2] == 0x66) { 677 opcode1 = "cvtps2dq"; 678 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 679 } else if (prefix[0] == 0xF2) { 680 opcode1 = "bad opcode F2 0F 5B"; 681 } else if (prefix[0] == 0xF3) { 682 opcode1 = "cvttps2dq"; 683 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 684 } else { 685 opcode1 = "cvtdq2ps"; 686 } 687 load = true; 688 has_modrm = true; 689 src_reg_file = dst_reg_file = SSE; 690 break; 691 case 0x60: case 0x61: case 0x62: case 0x6C: 692 if (prefix[2] == 0x66) { 693 src_reg_file = dst_reg_file = SSE; 694 prefix[2] = 0; // Clear prefix now. It has served its purpose as part of the opcode. 695 } else { 696 src_reg_file = dst_reg_file = MMX; 697 } 698 switch (*instr) { 699 case 0x60: opcode1 = "punpcklbw"; break; 700 case 0x61: opcode1 = "punpcklwd"; break; 701 case 0x62: opcode1 = "punpckldq"; break; 702 case 0x6c: opcode1 = "punpcklqdq"; break; 703 } 704 load = true; 705 has_modrm = true; 706 break; 707 case 0x6E: 708 if (prefix[2] == 0x66) { 709 dst_reg_file = SSE; 710 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 711 } else { 712 dst_reg_file = MMX; 713 } 714 opcode1 = "movd"; 715 load = true; 716 has_modrm = true; 717 break; 718 case 0x6F: 719 if (prefix[2] == 0x66) { 720 src_reg_file = dst_reg_file = SSE; 721 opcode1 = "movdqa"; 722 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 723 } else if (prefix[0] == 0xF3) { 724 src_reg_file = dst_reg_file = SSE; 725 opcode1 = "movdqu"; 726 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 727 } else { 728 dst_reg_file = MMX; 729 opcode1 = "movq"; 730 } 731 load = true; 732 has_modrm = true; 733 break; 734 case 0x70: 735 if (prefix[2] == 0x66) { 736 opcode1 = "pshufd"; 737 prefix[2] = 0; 738 has_modrm = true; 739 store = true; 740 src_reg_file = dst_reg_file = SSE; 741 immediate_bytes = 1; 742 } else if (prefix[0] == 0xF2) { 743 opcode1 = "pshuflw"; 744 prefix[0] = 0; 745 has_modrm = true; 746 store = true; 747 src_reg_file = dst_reg_file = SSE; 748 immediate_bytes = 1; 749 } else { 750 opcode_tmp = StringPrintf("unknown opcode '0F %02X'", *instr); 751 opcode1 = opcode_tmp.c_str(); 752 } 753 break; 754 case 0x71: 755 if (prefix[2] == 0x66) { 756 dst_reg_file = SSE; 757 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 758 } else { 759 dst_reg_file = MMX; 760 } 761 static const char* x71_opcodes[] = { 762 "unknown-71", "unknown-71", "psrlw", "unknown-71", 763 "psraw", "unknown-71", "psllw", "unknown-71"}; 764 modrm_opcodes = x71_opcodes; 765 reg_is_opcode = true; 766 has_modrm = true; 767 store = true; 768 immediate_bytes = 1; 769 break; 770 case 0x72: 771 if (prefix[2] == 0x66) { 772 dst_reg_file = SSE; 773 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 774 } else { 775 dst_reg_file = MMX; 776 } 777 static const char* x72_opcodes[] = { 778 "unknown-72", "unknown-72", "psrld", "unknown-72", 779 "psrad", "unknown-72", "pslld", "unknown-72"}; 780 modrm_opcodes = x72_opcodes; 781 reg_is_opcode = true; 782 has_modrm = true; 783 store = true; 784 immediate_bytes = 1; 785 break; 786 case 0x73: 787 if (prefix[2] == 0x66) { 788 dst_reg_file = SSE; 789 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 790 } else { 791 dst_reg_file = MMX; 792 } 793 static const char* x73_opcodes[] = { 794 "unknown-73", "unknown-73", "psrlq", "psrldq", 795 "unknown-73", "unknown-73", "psllq", "unknown-73"}; 796 modrm_opcodes = x73_opcodes; 797 reg_is_opcode = true; 798 has_modrm = true; 799 store = true; 800 immediate_bytes = 1; 801 break; 802 case 0x7C: 803 if (prefix[0] == 0xF2) { 804 opcode1 = "haddps"; 805 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 806 } else if (prefix[2] == 0x66) { 807 opcode1 = "haddpd"; 808 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 809 } else { 810 opcode_tmp = StringPrintf("unknown opcode '0F %02X'", *instr); 811 opcode1 = opcode_tmp.c_str(); 812 break; 813 } 814 src_reg_file = dst_reg_file = SSE; 815 has_modrm = true; 816 load = true; 817 break; 818 case 0x7E: 819 if (prefix[2] == 0x66) { 820 src_reg_file = SSE; 821 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 822 } else { 823 src_reg_file = MMX; 824 } 825 opcode1 = "movd"; 826 has_modrm = true; 827 store = true; 828 break; 829 case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87: 830 case 0x88: case 0x89: case 0x8A: case 0x8B: case 0x8C: case 0x8D: case 0x8E: case 0x8F: 831 opcode1 = "j"; 832 opcode2 = condition_codes[*instr & 0xF]; 833 branch_bytes = 4; 834 break; 835 case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97: 836 case 0x98: case 0x99: case 0x9A: case 0x9B: case 0x9C: case 0x9D: case 0x9E: case 0x9F: 837 opcode1 = "set"; 838 opcode2 = condition_codes[*instr & 0xF]; 839 modrm_opcodes = nullptr; 840 reg_is_opcode = true; 841 has_modrm = true; 842 store = true; 843 break; 844 case 0xA4: 845 opcode1 = "shld"; 846 has_modrm = true; 847 load = true; 848 immediate_bytes = 1; 849 break; 850 case 0xA5: 851 opcode1 = "shld"; 852 has_modrm = true; 853 load = true; 854 cx = true; 855 break; 856 case 0xAC: 857 opcode1 = "shrd"; 858 has_modrm = true; 859 load = true; 860 immediate_bytes = 1; 861 break; 862 case 0xAD: 863 opcode1 = "shrd"; 864 has_modrm = true; 865 load = true; 866 cx = true; 867 break; 868 case 0xAE: 869 if (prefix[0] == 0xF3) { 870 prefix[0] = 0; // clear prefix now it's served its purpose as part of the opcode 871 static const char* xAE_opcodes[] = { 872 "rdfsbase", "rdgsbase", "wrfsbase", "wrgsbase", 873 "unknown-AE", "unknown-AE", "unknown-AE", "unknown-AE"}; 874 modrm_opcodes = xAE_opcodes; 875 reg_is_opcode = true; 876 has_modrm = true; 877 uint8_t reg_or_opcode = (instr[1] >> 3) & 7; 878 switch (reg_or_opcode) { 879 case 0: 880 prefix[1] = kFs; 881 load = true; 882 break; 883 case 1: 884 prefix[1] = kGs; 885 load = true; 886 break; 887 case 2: 888 prefix[1] = kFs; 889 store = true; 890 break; 891 case 3: 892 prefix[1] = kGs; 893 store = true; 894 break; 895 default: 896 load = true; 897 break; 898 } 899 } else { 900 static const char* xAE_opcodes[] = { 901 "unknown-AE", "unknown-AE", "unknown-AE", "unknown-AE", 902 "unknown-AE", "lfence", "mfence", "sfence"}; 903 modrm_opcodes = xAE_opcodes; 904 reg_is_opcode = true; 905 has_modrm = true; 906 load = true; 907 no_ops = true; 908 } 909 break; 910 case 0xAF: 911 opcode1 = "imul"; 912 has_modrm = true; 913 load = true; 914 break; 915 case 0xB1: 916 opcode1 = "cmpxchg"; 917 has_modrm = true; 918 store = true; 919 break; 920 case 0xB6: 921 opcode1 = "movzxb"; 922 has_modrm = true; 923 load = true; 924 byte_second_operand = true; 925 break; 926 case 0xB7: 927 opcode1 = "movzxw"; 928 has_modrm = true; 929 load = true; 930 break; 931 case 0xBC: 932 opcode1 = "bsf"; 933 has_modrm = true; 934 load = true; 935 break; 936 case 0xBD: 937 opcode1 = "bsr"; 938 has_modrm = true; 939 load = true; 940 break; 941 case 0xB8: 942 opcode1 = "popcnt"; 943 has_modrm = true; 944 load = true; 945 break; 946 case 0xBE: 947 opcode1 = "movsxb"; 948 has_modrm = true; 949 load = true; 950 byte_second_operand = true; 951 rex |= (rex == 0 ? 0 : REX_W); 952 break; 953 case 0xBF: 954 opcode1 = "movsxw"; 955 has_modrm = true; 956 load = true; 957 break; 958 case 0xC3: 959 opcode1 = "movnti"; 960 store = true; 961 has_modrm = true; 962 break; 963 case 0xC5: 964 if (prefix[2] == 0x66) { 965 opcode1 = "pextrw"; 966 prefix[2] = 0; 967 has_modrm = true; 968 load = true; 969 src_reg_file = SSE; 970 immediate_bytes = 1; 971 } else { 972 opcode_tmp = StringPrintf("unknown opcode '0F %02X'", *instr); 973 opcode1 = opcode_tmp.c_str(); 974 } 975 break; 976 case 0xC6: 977 if (prefix[2] == 0x66) { 978 opcode1 = "shufpd"; 979 prefix[2] = 0; 980 } else { 981 opcode1 = "shufps"; 982 } 983 has_modrm = true; 984 store = true; 985 src_reg_file = dst_reg_file = SSE; 986 immediate_bytes = 1; 987 break; 988 case 0xC7: 989 static const char* x0FxC7_opcodes[] = { 990 "unknown-0f-c7", "cmpxchg8b", "unknown-0f-c7", "unknown-0f-c7", 991 "unknown-0f-c7", "unknown-0f-c7", "unknown-0f-c7", "unknown-0f-c7"}; 992 modrm_opcodes = x0FxC7_opcodes; 993 has_modrm = true; 994 reg_is_opcode = true; 995 store = true; 996 break; 997 case 0xC8: case 0xC9: case 0xCA: case 0xCB: case 0xCC: case 0xCD: case 0xCE: case 0xCF: 998 opcode1 = "bswap"; 999 reg_in_opcode = true; 1000 break; 1001 case 0xD4: 1002 if (prefix[2] == 0x66) { 1003 src_reg_file = dst_reg_file = SSE; 1004 prefix[2] = 0; 1005 } else { 1006 src_reg_file = dst_reg_file = MMX; 1007 } 1008 opcode1 = "paddq"; 1009 prefix[2] = 0; 1010 has_modrm = true; 1011 load = true; 1012 break; 1013 case 0xDB: 1014 if (prefix[2] == 0x66) { 1015 src_reg_file = dst_reg_file = SSE; 1016 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 1017 } else { 1018 src_reg_file = dst_reg_file = MMX; 1019 } 1020 opcode1 = "pand"; 1021 prefix[2] = 0; 1022 has_modrm = true; 1023 load = true; 1024 break; 1025 case 0xD5: 1026 if (prefix[2] == 0x66) { 1027 opcode1 = "pmullw"; 1028 prefix[2] = 0; 1029 has_modrm = true; 1030 load = true; 1031 src_reg_file = dst_reg_file = SSE; 1032 } else { 1033 opcode_tmp = StringPrintf("unknown opcode '0F %02X'", *instr); 1034 opcode1 = opcode_tmp.c_str(); 1035 } 1036 break; 1037 case 0xEB: 1038 if (prefix[2] == 0x66) { 1039 src_reg_file = dst_reg_file = SSE; 1040 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 1041 } else { 1042 src_reg_file = dst_reg_file = MMX; 1043 } 1044 opcode1 = "por"; 1045 prefix[2] = 0; 1046 has_modrm = true; 1047 load = true; 1048 break; 1049 case 0xEF: 1050 if (prefix[2] == 0x66) { 1051 src_reg_file = dst_reg_file = SSE; 1052 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 1053 } else { 1054 src_reg_file = dst_reg_file = MMX; 1055 } 1056 opcode1 = "pxor"; 1057 prefix[2] = 0; 1058 has_modrm = true; 1059 load = true; 1060 break; 1061 case 0xF4: 1062 case 0xF6: 1063 case 0xF8: 1064 case 0xF9: 1065 case 0xFA: 1066 case 0xFB: 1067 case 0xFC: 1068 case 0xFD: 1069 case 0xFE: 1070 if (prefix[2] == 0x66) { 1071 src_reg_file = dst_reg_file = SSE; 1072 prefix[2] = 0; // clear prefix now it's served its purpose as part of the opcode 1073 } else { 1074 src_reg_file = dst_reg_file = MMX; 1075 } 1076 switch (*instr) { 1077 case 0xF4: opcode1 = "pmuludq"; break; 1078 case 0xF6: opcode1 = "psadbw"; break; 1079 case 0xF8: opcode1 = "psubb"; break; 1080 case 0xF9: opcode1 = "psubw"; break; 1081 case 0xFA: opcode1 = "psubd"; break; 1082 case 0xFB: opcode1 = "psubq"; break; 1083 case 0xFC: opcode1 = "paddb"; break; 1084 case 0xFD: opcode1 = "paddw"; break; 1085 case 0xFE: opcode1 = "paddd"; break; 1086 } 1087 prefix[2] = 0; 1088 has_modrm = true; 1089 load = true; 1090 break; 1091 default: 1092 opcode_tmp = StringPrintf("unknown opcode '0F %02X'", *instr); 1093 opcode1 = opcode_tmp.c_str(); 1094 break; 1095 } 1096 break; 1097 case 0x80: case 0x81: case 0x82: case 0x83: 1098 static const char* x80_opcodes[] = {"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp"}; 1099 modrm_opcodes = x80_opcodes; 1100 has_modrm = true; 1101 reg_is_opcode = true; 1102 store = true; 1103 byte_operand = (*instr & 1) == 0; 1104 immediate_bytes = *instr == 0x81 ? 4 : 1; 1105 break; 1106 case 0x84: case 0x85: 1107 opcode1 = "test"; 1108 has_modrm = true; 1109 load = true; 1110 byte_operand = (*instr & 1) == 0; 1111 break; 1112 case 0x8D: 1113 opcode1 = "lea"; 1114 has_modrm = true; 1115 load = true; 1116 break; 1117 case 0x8F: 1118 opcode1 = "pop"; 1119 has_modrm = true; 1120 reg_is_opcode = true; 1121 store = true; 1122 break; 1123 case 0x99: 1124 opcode1 = "cdq"; 1125 break; 1126 case 0x9B: 1127 if (instr[1] == 0xDF && instr[2] == 0xE0) { 1128 opcode1 = "fstsw\tax"; 1129 instr += 2; 1130 } else { 1131 opcode_tmp = StringPrintf("unknown opcode '%02X'", *instr); 1132 opcode1 = opcode_tmp.c_str(); 1133 } 1134 break; 1135 case 0xA5: 1136 opcode1 = (prefix[2] == 0x66 ? "movsw" : "movsl"); 1137 break; 1138 case 0xA7: 1139 opcode1 = (prefix[2] == 0x66 ? "cmpsw" : "cmpsl"); 1140 break; 1141 case 0xAF: 1142 opcode1 = (prefix[2] == 0x66 ? "scasw" : "scasl"); 1143 break; 1144 case 0xB0: case 0xB1: case 0xB2: case 0xB3: case 0xB4: case 0xB5: case 0xB6: case 0xB7: 1145 opcode1 = "mov"; 1146 immediate_bytes = 1; 1147 byte_operand = true; 1148 reg_in_opcode = true; 1149 byte_operand = true; 1150 break; 1151 case 0xB8: case 0xB9: case 0xBA: case 0xBB: case 0xBC: case 0xBD: case 0xBE: case 0xBF: 1152 if ((rex & REX_W) != 0) { 1153 opcode1 = "movabsq"; 1154 immediate_bytes = 8; 1155 reg_in_opcode = true; 1156 break; 1157 } 1158 opcode1 = "mov"; 1159 immediate_bytes = 4; 1160 reg_in_opcode = true; 1161 break; 1162 case 0xC0: case 0xC1: 1163 case 0xD0: case 0xD1: case 0xD2: case 0xD3: 1164 static const char* shift_opcodes[] = 1165 {"rol", "ror", "rcl", "rcr", "shl", "shr", "unknown-shift", "sar"}; 1166 modrm_opcodes = shift_opcodes; 1167 has_modrm = true; 1168 reg_is_opcode = true; 1169 store = true; 1170 immediate_bytes = ((*instr & 0xf0) == 0xc0) ? 1 : 0; 1171 cx = (*instr == 0xD2) || (*instr == 0xD3); 1172 byte_operand = (*instr == 0xC0); 1173 break; 1174 case 0xC3: opcode1 = "ret"; break; 1175 case 0xC6: 1176 static const char* c6_opcodes[] = {"mov", "unknown-c6", "unknown-c6", 1177 "unknown-c6", "unknown-c6", "unknown-c6", 1178 "unknown-c6", "unknown-c6"}; 1179 modrm_opcodes = c6_opcodes; 1180 store = true; 1181 immediate_bytes = 1; 1182 has_modrm = true; 1183 reg_is_opcode = true; 1184 byte_operand = true; 1185 break; 1186 case 0xC7: 1187 static const char* c7_opcodes[] = {"mov", "unknown-c7", "unknown-c7", 1188 "unknown-c7", "unknown-c7", "unknown-c7", 1189 "unknown-c7", "unknown-c7"}; 1190 modrm_opcodes = c7_opcodes; 1191 store = true; 1192 immediate_bytes = 4; 1193 has_modrm = true; 1194 reg_is_opcode = true; 1195 break; 1196 case 0xCC: opcode1 = "int 3"; break; 1197 case 0xD9: 1198 if (instr[1] == 0xF8) { 1199 opcode1 = "fprem"; 1200 instr++; 1201 } else { 1202 static const char* d9_opcodes[] = {"flds", "unknown-d9", "fsts", "fstps", "fldenv", "fldcw", 1203 "fnstenv", "fnstcw"}; 1204 modrm_opcodes = d9_opcodes; 1205 store = true; 1206 has_modrm = true; 1207 reg_is_opcode = true; 1208 } 1209 break; 1210 case 0xDA: 1211 if (instr[1] == 0xE9) { 1212 opcode1 = "fucompp"; 1213 instr++; 1214 } else { 1215 opcode_tmp = StringPrintf("unknown opcode '%02X'", *instr); 1216 opcode1 = opcode_tmp.c_str(); 1217 } 1218 break; 1219 case 0xDB: 1220 static const char* db_opcodes[] = {"fildl", "unknown-db", "unknown-db", 1221 "unknown-db", "unknown-db", "unknown-db", 1222 "unknown-db", "unknown-db"}; 1223 modrm_opcodes = db_opcodes; 1224 load = true; 1225 has_modrm = true; 1226 reg_is_opcode = true; 1227 break; 1228 case 0xDD: 1229 static const char* dd_opcodes[] = {"fldl", "fisttp", "fstl", 1230 "fstpl", "frstor", "unknown-dd", 1231 "fnsave", "fnstsw"}; 1232 modrm_opcodes = dd_opcodes; 1233 store = true; 1234 has_modrm = true; 1235 reg_is_opcode = true; 1236 break; 1237 case 0xDF: 1238 static const char* df_opcodes[] = {"fild", "unknown-df", "unknown-df", 1239 "unknown-df", "unknown-df", "fildll", 1240 "unknown-df", "unknown-df"}; 1241 modrm_opcodes = df_opcodes; 1242 load = true; 1243 has_modrm = true; 1244 reg_is_opcode = true; 1245 break; 1246 case 0xE3: opcode1 = "jecxz"; branch_bytes = 1; break; 1247 case 0xE8: opcode1 = "call"; branch_bytes = 4; break; 1248 case 0xE9: opcode1 = "jmp"; branch_bytes = 4; break; 1249 case 0xEB: opcode1 = "jmp"; branch_bytes = 1; break; 1250 case 0xF5: opcode1 = "cmc"; break; 1251 case 0xF6: case 0xF7: 1252 static const char* f7_opcodes[] = { 1253 "test", "unknown-f7", "not", "neg", "mul edx:eax, eax *", 1254 "imul edx:eax, eax *", "div edx:eax, edx:eax /", 1255 "idiv edx:eax, edx:eax /"}; 1256 modrm_opcodes = f7_opcodes; 1257 has_modrm = true; 1258 reg_is_opcode = true; 1259 store = true; 1260 immediate_bytes = ((instr[1] & 0x38) == 0) ? 1 : 0; 1261 break; 1262 case 0xFF: 1263 { 1264 static const char* ff_opcodes[] = { 1265 "inc", "dec", "call", "call", 1266 "jmp", "jmp", "push", "unknown-ff"}; 1267 modrm_opcodes = ff_opcodes; 1268 has_modrm = true; 1269 reg_is_opcode = true; 1270 load = true; 1271 const uint8_t opcode_digit = (instr[1] >> 3) & 7; 1272 // 'call', 'jmp' and 'push' are target specific instructions 1273 if (opcode_digit == 2 || opcode_digit == 4 || opcode_digit == 6) { 1274 target_specific = true; 1275 } 1276 } 1277 break; 1278 default: 1279 opcode_tmp = StringPrintf("unknown opcode '%02X'", *instr); 1280 opcode1 = opcode_tmp.c_str(); 1281 break; 1282 } 1283 std::ostringstream args; 1284 // We force the REX prefix to be available for 64-bit target 1285 // in order to dump addr (base/index) registers correctly. 1286 uint8_t rex64 = supports_rex_ ? (rex | 0x40) : rex; 1287 // REX.W should be forced for 64-target and target-specific instructions (i.e., push or pop). 1288 uint8_t rex_w = (supports_rex_ && target_specific) ? (rex | 0x48) : rex; 1289 if (reg_in_opcode) { 1290 DCHECK(!has_modrm); 1291 DumpOpcodeReg(args, rex_w, *instr & 0x7, byte_operand, prefix[2]); 1292 } 1293 instr++; 1294 uint32_t address_bits = 0; 1295 if (has_modrm) { 1296 uint8_t modrm = *instr; 1297 instr++; 1298 uint8_t mod = modrm >> 6; 1299 uint8_t reg_or_opcode = (modrm >> 3) & 7; 1300 uint8_t rm = modrm & 7; 1301 std::string address = DumpAddress(mod, rm, rex64, rex_w, no_ops, byte_operand, 1302 byte_second_operand, prefix, load, src_reg_file, dst_reg_file, 1303 &instr, &address_bits); 1304 1305 if (reg_is_opcode && modrm_opcodes != nullptr) { 1306 opcode3 = modrm_opcodes[reg_or_opcode]; 1307 } 1308 1309 // Add opcode suffixes to indicate size. 1310 if (byte_operand) { 1311 opcode4 = "b"; 1312 } else if ((rex & REX_W) != 0) { 1313 opcode4 = "q"; 1314 } else if (prefix[2] == 0x66) { 1315 opcode4 = "w"; 1316 } 1317 1318 if (load) { 1319 if (!reg_is_opcode) { 1320 DumpReg(args, rex, reg_or_opcode, byte_operand, prefix[2], dst_reg_file); 1321 args << ", "; 1322 } 1323 DumpSegmentOverride(args, prefix[1]); 1324 args << address; 1325 } else { 1326 DCHECK(store); 1327 DumpSegmentOverride(args, prefix[1]); 1328 args << address; 1329 if (!reg_is_opcode) { 1330 args << ", "; 1331 DumpReg(args, rex, reg_or_opcode, byte_operand, prefix[2], src_reg_file); 1332 } 1333 } 1334 } 1335 if (ax) { 1336 // If this opcode implicitly uses ax, ax is always the first arg. 1337 DumpReg(args, rex, 0 /* EAX */, byte_operand, prefix[2], GPR); 1338 } 1339 if (cx) { 1340 args << ", "; 1341 DumpReg(args, rex, 1 /* ECX */, true, prefix[2], GPR); 1342 } 1343 if (immediate_bytes > 0) { 1344 if (has_modrm || reg_in_opcode || ax || cx) { 1345 args << ", "; 1346 } 1347 if (immediate_bytes == 1) { 1348 args << StringPrintf("%d", *reinterpret_cast<const int8_t*>(instr)); 1349 instr++; 1350 } else if (immediate_bytes == 4) { 1351 if (prefix[2] == 0x66) { // Operand size override from 32-bit to 16-bit. 1352 args << StringPrintf("%d", *reinterpret_cast<const int16_t*>(instr)); 1353 instr += 2; 1354 } else { 1355 args << StringPrintf("%d", *reinterpret_cast<const int32_t*>(instr)); 1356 instr += 4; 1357 } 1358 } else { 1359 CHECK_EQ(immediate_bytes, 8u); 1360 args << StringPrintf("%" PRId64, *reinterpret_cast<const int64_t*>(instr)); 1361 instr += 8; 1362 } 1363 } else if (branch_bytes > 0) { 1364 DCHECK(!has_modrm); 1365 int32_t displacement; 1366 if (branch_bytes == 1) { 1367 displacement = *reinterpret_cast<const int8_t*>(instr); 1368 instr++; 1369 } else { 1370 CHECK_EQ(branch_bytes, 4u); 1371 displacement = *reinterpret_cast<const int32_t*>(instr); 1372 instr += 4; 1373 } 1374 args << StringPrintf("%+d (", displacement) 1375 << FormatInstructionPointer(instr + displacement) 1376 << ")"; 1377 } 1378 if (prefix[1] == kFs && !supports_rex_) { 1379 args << " ; "; 1380 Thread::DumpThreadOffset<4>(args, address_bits); 1381 } 1382 if (prefix[1] == kGs && supports_rex_) { 1383 args << " ; "; 1384 Thread::DumpThreadOffset<8>(args, address_bits); 1385 } 1386 const char* prefix_str; 1387 switch (prefix[0]) { 1388 case 0xF0: prefix_str = "lock "; break; 1389 case 0xF2: prefix_str = "repne "; break; 1390 case 0xF3: prefix_str = "repe "; break; 1391 case 0: prefix_str = ""; break; 1392 default: LOG(FATAL) << "Unreachable"; UNREACHABLE(); 1393 } 1394 os << FormatInstructionPointer(begin_instr) 1395 << StringPrintf(": %22s \t%-7s%s%s%s%s%s ", DumpCodeHex(begin_instr, instr).c_str(), 1396 prefix_str, opcode0, opcode1, opcode2, opcode3, opcode4) 1397 << args.str() << '\n'; 1398 return instr - begin_instr; 1399 } // NOLINT(readability/fn_size) 1400 1401 } // namespace x86 1402 } // namespace art 1403
