Lines Matching refs:data
193 int8_t Imm8(const uint8_t* data) {
194 return *reinterpret_cast<const int8_t*>(data);
196 uint8_t Imm8_U(const uint8_t* data) {
197 return *reinterpret_cast<const uint8_t*>(data);
199 int16_t Imm16(const uint8_t* data) {
200 return *reinterpret_cast<const int16_t*>(data);
202 uint16_t Imm16_U(const uint8_t* data) {
203 return *reinterpret_cast<const uint16_t*>(data);
205 int32_t Imm32(const uint8_t* data) {
206 return *reinterpret_cast<const int32_t*>(data);
338 static void get_modrm(byte data, int* mod, int* regop, int* rm) {
339 *mod = (data >> 6) & 3;
340 *regop = (data & 0x38) >> 3;
341 *rm = data & 7;
344 static void get_sib(byte data, int* scale, int* index, int* base) {
345 *scale = (data >> 6) & 3;
346 *index = (data >> 3) & 7;
347 *base = data & 7;
356 int PrintOperands(const char* mnem, OperandOrder op_order, byte* data);
357 int PrintImmediateOp(byte* data);
358 int F7Instruction(byte* data);
359 int D1D3C1Instruction(byte* data);
360 int JumpShort(byte* data);
361 int JumpConditional(byte* data, const char* comment);
362 int JumpConditionalShort(byte* data, const char* comment);
363 int SetCC(byte* data);
364 int CMov(byte* data);
365 int FPUInstruction(byte* data);
368 int AVXInstruction(byte* data);
472 // Returns number of bytes used including the current *data.
475 byte* data) {
476 byte modrm = *data;
483 advance = PrintRightOperand(data);
488 advance = PrintRightOperand(data);
498 // Returns number of bytes used by machine instruction, including *data byte.
500 int DisassemblerIA32::PrintImmediateOp(byte* data) {
501 bool sign_extension_bit = (*data & 0x02) != 0;
502 byte modrm = *(data + 1);
532 int count = PrintRightOperand(data + 1);
534 AppendToBuffer(",0x%x", *(data + 1 + count));
537 AppendToBuffer(",0x%x", Imm32(data + 1 + count));
542 // Returns number of bytes used, including *data.
543 int DisassemblerIA32::F7Instruction(byte* data) {
544 DCHECK_EQ(0xF7, *data);
545 byte modrm = *++data;
575 int count = PrintRightOperand(data);
577 AppendToBuffer(",0x%x", Imm32(data + count));
583 int DisassemblerIA32::D1D3C1Instruction(byte* data) {
584 byte op = *data;
586 byte modrm = *++data;
617 int count = PrintRightOperand(data);
621 imm8 = *(data + 1);
634 // Returns number of bytes used, including *data.
635 int DisassemblerIA32::JumpShort(byte* data) {
636 DCHECK_EQ(0xEB, *data);
637 byte b = *(data + 1);
638 byte* dest = data + static_cast<int8_t>(b) + 2;
643 // Returns number of bytes used, including *data.
644 int DisassemblerIA32::JumpConditional(byte* data, const char* comment) {
645 DCHECK_EQ(0x0F, *data);
646 byte cond = *(data + 1) & 0x0F;
647 byte* dest = data + Imm32(data + 2) + 6;
656 // Returns number of bytes used, including *data.
657 int DisassemblerIA32::JumpConditionalShort(byte* data, const char* comment) {
658 byte cond = *data & 0x0F;
659 byte b = *(data + 1);
660 byte* dest = data + static_cast<int8_t>(b) + 2;
669 // Returns number of bytes used, including *data.
670 int DisassemblerIA32::SetCC(byte* data) {
671 DCHECK_EQ(0x0F, *data);
672 byte cond = *(data + 1) & 0x0F;
675 PrintRightByteOperand(data + 2);
679 // Returns number of bytes used, including *data.
680 int DisassemblerIA32::CMov(byte* data) {
681 DCHECK_EQ(0x0F, *data);
682 byte cond = *(data + 1) & 0x0F;
684 int op_size = PrintOperands(mnem, REG_OPER_OP_ORDER, data + 2);
690 int DisassemblerIA32::AVXInstruction(byte* data) {
691 byte opcode = *data;
692 byte* current = data + 1;
1405 return static_cast<int>(current - data);
1408 // Returns number of bytes used, including *data.
1409 int DisassemblerIA32::FPUInstruction(byte* data) {
1410 byte escape_opcode = *data;
1412 byte modrm_byte = *(data + 1);
1417 return MemoryFPUInstruction(escape_opcode, modrm_byte, data + 1);
1751 byte* data = instr;
1755 if (*data == 0x3E /*ds*/) {
1757 data++;
1758 } else if (*data == 0x2E /*cs*/) {
1760 data++;
1761 } else if (*data == 0xC4 && *(data + 1) >= 0xC0) {
1762 vex_byte0_ = *data;
1763 vex_byte1_ = *(data + 1);
1764 vex_byte2_ = *(data + 2);
1765 data += 3;
1766 } else if (*data == 0xC5 && *(data + 1) >= 0xC0) {
1767 vex_byte0_ = *data;
1768 vex_byte1_ = *(data + 1);
1769 data += 2;
1770 } else if (*data == 0xF0 /*lock*/) {
1772 data++;
1779 data += AVXInstruction(data);
1781 const InstructionDesc& idesc = instruction_table_->Get(*data);
1785 data++;
1789 data++;
1790 data += PrintOperands(idesc.mnem, idesc.op_order_, data);
1794 data += JumpConditionalShort(data, branch_hint);
1798 AppendToBuffer("%s %s", idesc.mnem, NameOfCPURegister(*data & 0x07));
1799 data++;
1803 byte* addr = reinterpret_cast<byte*>(Imm32(data + 1));
1804 AppendToBuffer("mov %s,%s", NameOfCPURegister(*data & 0x07),
1806 data += 5;
1811 byte* addr = data + Imm32(data + 1) + 5;
1813 data += 5;
1818 byte* addr = reinterpret_cast<byte*>(Imm32(data + 1));
1820 data += 5;
1825 AppendToBuffer("%s al,0x%x", idesc.mnem, data[1]);
1826 data += 2;
1840 switch (*data) {
1842 AppendToBuffer("ret 0x%x", Imm16_U(data + 1));
1843 data += 3;
1847 data++;
1848 data += PrintOperands("imul", REG_OPER_OP_ORDER, data);
1849 AppendToBuffer(",%d", *data);
1850 data++;
1854 data++;
1855 data += PrintOperands("imul", REG_OPER_OP_ORDER, data);
1856 AppendToBuffer(",%d", Imm32(data));
1857 data += 4;
1861 data++;
1863 get_modrm(*data, &mod, ®op, &rm);
1866 data += PrintRightByteOperand(data);
1867 int32_t imm = *data;
1869 data++;
1877 data += PrintImmediateOp(data);
1881 byte f0byte = data[1];
1884 // Not every instruction use this, and it is safe to index data+2 as all
1886 get_modrm(*(data + 2), &mod, ®op, &rm);
1888 data += 2;
1894 data += PrintRightXMMOperand(data);
1896 data += 2;
1898 data += PrintRightXMMOperand(data);
1901 data += 2;
1903 data += PrintRightXMMOperand(data);
1905 data += 2;
1907 data += PrintRightXMMOperand(data);
1909 data += 2;
1911 data += PrintRightXMMOperand(data);
1914 data += 2;
1917 data += PrintRightOperand(data);
1918 } else if (f0byte == 0x1F && data[2] == 0) {
1920 data += 3;
1921 } else if (f0byte == 0x1F && data[2] == 0x40 && data[3] == 0) {
1923 data += 4;
1924 } else if (f0byte == 0x1F && data[2] == 0x44 && data[3] == 0 &&
1925 data[4] == 0) {
1927 data += 5;
1928 } else if (f0byte == 0x1F && data[2] == 0x80 && data[3] == 0 &&
1929 data[4] == 0 && data[5] == 0 && data[6] == 0) {
1931 data += 7;
1932 } else if (f0byte == 0x1F && data[2] == 0x84 && data[3] == 0 &&
1933 data[4] == 0 && data[5] == 0 && data[6] == 0 &&
1934 data[7] == 0) {
1936 data += 8;
1939 data += 2;
1941 data += 2;
1944 data++;
1946 data += 2;
1951 data += PrintRightXMMOperand(data);
1955 data += PrintRightXMMOperand(data);
1958 data += 2;
1960 data += PrintRightXMMOperand(data);
1968 data += 2;
1971 data += PrintRightXMMOperand(data);
1973 data += 2;
1976 data++;
1978 data += 2;
1979 data += PrintOperands("xadd_b", OPER_REG_OP_ORDER, data);
1981 data += 2;
1982 data += PrintOperands("xadd", OPER_REG_OP_ORDER, data);
1984 data += 2;
1986 data += PrintRightXMMOperand(data);
1987 AppendToBuffer(", (%s)", cmp_pseudo_op[*data]);
1988 data++;
1991 data += 2;
1992 int8_t imm8 = static_cast<int8_t>(data[1]);
1995 data += 2;
1998 data += 2;
2002 data += JumpConditional(data, branch_hint);
2005 data += 2;
2006 data += PrintOperands(f0mnem, REG_OPER_OP_ORDER, data);
2008 data += SetCC(data);
2010 data += CMov(data);
2013 data += 2;
2015 int8_t imm8 = static_cast<int8_t>(data[1]);
2016 data += 2;
2021 data += 2;
2023 data += PrintRightOperand(data);
2031 data += 2;
2033 data += PrintRightOperand(data);
2037 data += 2;
2038 data += PrintOperands(f0mnem, OPER_REG_OP_ORDER, data);
2040 data += 2;
2042 data += PrintRightOperand(data);
2044 data += 2;
2046 data += PrintRightOperand(data);
2049 data += 2;
2051 data += PrintRightOperand(data);
2052 } else if (f0byte == 0xAE && (data[2] & 0xF8) == 0xF0) {
2054 data += 3;
2055 } else if (f0byte == 0xAE && (data[2] & 0xF8) == 0xE8) {
2057 data += 3;
2060 data += 1;
2065 data++;
2067 get_modrm(*data, &mod, ®op, &rm);
2070 data += PrintRightOperand(data);
2075 data++;
2077 get_modrm(*data, &mod, ®op, &rm);
2099 data += PrintRightOperand(data);
2105 bool is_byte = *data == 0xC6;
2106 data++;
2109 data += PrintRightByteOperand(data);
2110 int32_t imm = *data;
2112 data++;
2115 data += PrintRightOperand(data);
2116 AppendToBuffer(",0x%x", Imm32(data));
2117 data += 4;
2122 data++;
2124 get_modrm(*data, &mod, ®op, &rm);
2137 data += PrintRightByteOperand(data);
2138 int32_t imm = *data;
2140 data++;
2146 bool is_byte = *data == 0x88;
2148 data++;
2149 get_modrm(*data, &mod, ®op, &rm);
2152 data += PrintRightByteOperand(data);
2156 data += PrintRightOperand(data);
2162 while (*data == 0x66) data++;
2163 if (*data == 0xF && data[1] == 0x1F) {
2165 } else if (*data == 0x39) {
2166 data++;
2167 data += PrintOperands("cmpw", OPER_REG_OP_ORDER, data);
2168 } else if (*data == 0x3B) {
2169 data++;
2170 data += PrintOperands("cmpw", REG_OPER_OP_ORDER, data);
2171 } else if (*data == 0x81) {
2172 data++;
2174 data += PrintRightOperand(data);
2175 AppendToBuffer(",0x%x", Imm16(data));
2176 data += 2;
2177 } else if (*data == 0x87) {
2178 data++;
2180 get_modrm(*data, &mod, ®op, &rm);
2182 data += PrintRightOperand(data);
2183 } else if (*data == 0x89) {
2184 data++;
2186 get_modrm(*data, &mod, ®op, &rm);
2188 data += PrintRightOperand(data);
2190 } else if (*data == 0x8B) {
2191 data++;
2192 data += PrintOperands("mov_w", REG_OPER_OP_ORDER, data);
2193 } else if (*data == 0x90) {
2195 } else if (*data == 0xC7) {
2196 data++;
2198 data += PrintRightOperand(data);
2199 AppendToBuffer(",0x%x", Imm16(data));
2200 data += 2;
2201 } else if (*data == 0xF7) {
2202 data++;
2204 data += PrintRightOperand(data);
2205 AppendToBuffer(",0x%x", Imm16(data));
2206 data += 2;
2207 } else if (*data == 0x0F) {
2208 data++;
2209 if (*data == 0x10) {
2210 data++;
2212 get_modrm(*data, &mod, ®op, &rm);
2214 data += PrintRightXMMOperand(data);
2215 } else if (*data == 0x28) {
2216 data++;
2218 get_modrm(*data, &mod, ®op, &rm);
2220 data += PrintRightXMMOperand(data);
2221 } else if (*data == 0x38) {
2222 data++;
2223 byte op = *data;
2224 data++;
2226 get_modrm(*data, &mod, ®op, &rm);
2231 data += PrintRightXMMOperand(data); \
2242 data += PrintRightXMMOperand(data);
2247 data += PrintRightXMMOperand(data);
2252 data += PrintRightXMMOperand(data);
2257 data += PrintRightXMMOperand(data);
2262 } else if (*data == 0x3A) {
2263 data++;
2264 if (*data >= 0x08 && *data <= 0x0B) {
2271 byte op = *data;
2272 data++;
2274 get_modrm(*data, &mod, ®op, &rm);
2275 int8_t imm8 = static_cast<int8_t>(data[1]);
2279 data += 2;
2280 } else if (*data == 0x0E) {
2281 data++;
2283 get_modrm(*data, &mod, ®op, &rm);
2285 data += PrintRightXMMOperand(data);
2286 AppendToBuffer(",%d", Imm8_U(data));
2287 data++;
2288 } else if (*data == 0x0F) {
2289 data++;
2291 get_modrm(*data, &mod, ®op, &rm);
2293 data += PrintRightXMMOperand(data);
2294 AppendToBuffer(",%d", Imm8_U(data));
2295 data++;
2296 } else if (*data == 0x14) {
2297 data++;
2299 get_modrm(*data, &mod, ®op, &rm);
2301 data += PrintRightOperand(data);
2302 AppendToBuffer(",%s,%d", NameOfXMMRegister(regop), Imm8(data));
2303 data++;
2304 } else if (*data == 0x15) {
2305 data++;
2307 get_modrm(*data, &mod, ®op, &rm);
2309 data += PrintRightOperand(data);
2310 AppendToBuffer(",%s,%d", NameOfXMMRegister(regop), Imm8(data));
2311 data++;
2312 } else if (*data == 0x16) {
2313 data++;
2315 get_modrm(*data, &mod, ®op, &rm);
2317 data += PrintRightOperand(data);
2318 AppendToBuffer(",%s,%d", NameOfXMMRegister(regop), Imm8(data));
2319 data++;
2320 } else if (*data == 0x17) {
2321 data++;
2323 get_modrm(*data, &mod, ®op, &rm);
2324 int8_t imm8 = static_cast<int8_t>(data[1]);
2327 data += 2;
2328 } else if (*data == 0x20) {
2329 data++;
2331 get_modrm(*data, &mod, ®op, &rm);
2333 data += PrintRightOperand(data);
2334 AppendToBuffer(",%d", Imm8(data));
2335 data++;
2336 } else if (*data == 0x21) {
2337 data++;
2339 get_modrm(*data, &mod, ®op, &rm);
2341 data += PrintRightXMMOperand(data);
2342 AppendToBuffer(",%d", Imm8(data));
2343 data++;
2344 } else if (*data == 0x22) {
2345 data++;
2347 get_modrm(*data, &mod, ®op, &rm);
2349 data += PrintRightOperand(data);
2350 AppendToBuffer(",%d", Imm8(data));
2351 data++;
2355 } else if (*data == 0x2E || *data == 0x2F) {
2356 const char* mnem = (*data == 0x2E) ? "ucomisd" : "comisd";
2357 data++;
2359 get_modrm(*data, &mod, ®op, &rm);
2363 data++;
2366 data += PrintRightOperand(data);
2368 } else if (*data == 0x50) {
2369 data++;
2371 get_modrm(*data, &mod, ®op, &rm);
2374 data++;
2375 } else if (*data >= 0x54 && *data <= 0x5A) {
2379 byte op = *data;
2380 data++;
2382 get_modrm(*data, &mod, ®op, &rm);
2385 data += PrintRightXMMOperand(data);
2386 } else if (*data >= 0x5c && *data <= 0x5f) {
2393 byte op = *data;
2394 data++;
2396 get_modrm(*data, &mod, ®op, &rm);
2399 data += PrintRightXMMOperand(data);
2400 } else if (*data == 0x6E) {
2401 data++;
2403 get_modrm(*data, &mod, ®op, &rm);
2405 data += PrintRightOperand(data);
2406 } else if (*data == 0x6F) {
2407 data++;
2409 get_modrm(*data, &mod, ®op, &rm);
2411 data += PrintRightXMMOperand(data);
2412 } else if (*data == 0x70) {
2413 data++;
2415 get_modrm(*data, &mod, ®op, &rm);
2417 data += PrintRightXMMOperand(data);
2418 AppendToBuffer(",%d", Imm8(data));
2419 data++;
2420 } else if (*data == 0x90) {
2421 data++;
2423 } else if (*data == 0x71) {
2424 data++;
2426 get_modrm(*data, &mod, ®op, &rm);
2427 int8_t imm8 = static_cast<int8_t>(data[1]);
2430 data += 2;
2431 } else if (*data == 0x72) {
2432 data++;
2434 get_modrm(*data, &mod, ®op, &rm);
2435 int8_t imm8 = static_cast<int8_t>(data[1]);
2438 data += 2;
2439 } else if (*data == 0x73) {
2440 data++;
2442 get_modrm(*data, &mod, ®op, &rm);
2443 int8_t imm8 = static_cast<int8_t>(data[1]);
2447 data += 2;
2448 } else if (*data == 0x7F) {
2450 data++;
2452 get_modrm(*data, &mod, ®op, &rm);
2453 data += PrintRightXMMOperand(data);
2455 } else if (*data == 0x7E) {
2456 data++;
2458 get_modrm(*data, &mod, ®op, &rm);
2460 data += PrintRightOperand(data);
2462 } else if (*data == 0xC1) {
2463 data += 2;
2464 data += PrintOperands("xadd_w", OPER_REG_OP_ORDER, data);
2465 } else if (*data == 0xC2) {
2466 data++;
2468 get_modrm(*data, &mod, ®op, &rm);
2470 data += PrintRightXMMOperand(data);
2471 AppendToBuffer(", (%s)", cmp_pseudo_op[*data]);
2472 data++;
2473 } else if (*data == 0xC4) {
2474 data++;
2476 get_modrm(*data, &mod, ®op, &rm);
2478 data += PrintRightOperand(data);
2479 AppendToBuffer(",%d", Imm8(data));
2480 data++;
2481 } else if (*data == 0xC6) {
2483 data++;
2485 get_modrm(*data, &mod, ®op, &rm);
2487 data += PrintRightXMMOperand(data);
2488 AppendToBuffer(",%d", Imm8(data));
2489 data++;
2490 } else if (*data == 0xE6) {
2491 data++;
2493 get_modrm(*data, &mod, ®op, &rm);
2495 data += PrintRightXMMOperand(data);
2496 } else if (*data == 0xE7) {
2497 data++;
2499 get_modrm(*data, &mod, ®op, &rm);
2506 } else if (*data == 0xB1) {
2507 data++;
2508 data += PrintOperands("cmpxchg_w", OPER_REG_OP_ORDER, data);
2509 } else if (*data == 0xD7) {
2510 data++;
2512 get_modrm(*data, &mod, ®op, &rm);
2515 data++;
2517 byte op = *data;
2518 data++;
2520 get_modrm(*data, &mod, ®op, &rm);
2525 data += PrintRightXMMOperand(data); \
2541 data++;
2543 get_modrm(*data, &mod, ®op, &rm);
2546 data += PrintRightOperand(data);
2553 AppendToBuffer("push 0x%x", Imm32(data + 1));
2554 data += 5;
2558 AppendToBuffer("push 0x%x", Imm8(data + 1));
2559 data += 2;
2563 AppendToBuffer("test al,0x%x", Imm8_U(data + 1));
2564 data += 2;
2568 AppendToBuffer("test eax,0x%x", Imm32(data + 1));
2569 data += 5;
2575 data += D1D3C1Instruction(data);
2586 data += FPUInstruction(data);
2590 data += JumpShort(data);
2594 if (*(data + 1) == 0x0F) {
2595 byte b2 = *(data + 2);
2598 data += 3;
2600 get_modrm(*data, &mod, ®op, &rm);
2601 data += PrintRightXMMOperand(data);
2604 data += 3;
2606 get_modrm(*data, &mod, ®op, &rm);
2608 data += PrintRightXMMOperand(data);
2610 data += 3;
2612 get_modrm(*data, &mod, ®op, &rm);
2614 data += PrintRightXMMOperand(data);
2616 data += 3;
2618 get_modrm(*data, &mod, ®op, &rm);
2620 data += PrintRightXMMOperand(data);
2622 data += 3;
2624 get_modrm(*data, &mod, ®op, &rm);
2626 data += PrintRightXMMOperand(data);
2627 AppendToBuffer(",%d", Imm8(data));
2628 data++;
2651 data += 3;
2653 get_modrm(*data, &mod, ®op, &rm);
2656 data += PrintRightOperand(data);
2659 data += PrintRightXMMOperand(data);
2662 AppendToBuffer("cmp%ssd %s,%s", cmp_pseudo_op[data[1]],
2664 data += 2;
2667 data += PrintRightXMMOperand(data);
2672 data++;
2677 if (*(data + 1) == 0x0F) {
2678 byte b2 = *(data + 2);
2681 data += 3;
2683 get_modrm(*data, &mod, ®op, &rm);
2684 data += PrintRightXMMOperand(data);
2687 data += 3;
2689 get_modrm(*data, &mod, ®op, &rm);
2691 data += PrintRightXMMOperand(data);
2693 data += 3;
2695 get_modrm(*data, &mod, ®op, &rm);
2697 data += PrintRightXMMOperand(data);
2699 data += 3;
2701 get_modrm(*data, &mod, ®op, &rm);
2703 data += PrintRightXMMOperand(data);
2705 data += 3;
2707 get_modrm(*data, &mod, ®op, &rm);
2709 data += PrintRightXMMOperand(data);
2711 data += 3;
2713 get_modrm(*data, &mod, ®op, &rm);
2715 data += PrintRightXMMOperand(data);
2716 AppendToBuffer(",%d", Imm8(data));
2717 data++;
2720 data += 3;
2722 get_modrm(*data, &mod, ®op, &rm);
2723 data += PrintRightXMMOperand(data);
2726 data += 3;
2728 get_modrm(*data, &mod, ®op, &rm);
2730 data += PrintRightOperand(data);
2732 data += 3;
2734 get_modrm(*data, &mod, ®op, &rm);
2736 data += PrintRightOperand(data);
2738 data += 3;
2740 get_modrm(*data, &mod, ®op, &rm);
2742 data += PrintRightOperand(data);
2744 data += 3;
2746 get_modrm(*data, &mod, ®op, &rm);
2748 data += PrintRightXMMOperand(data);
2789 data += 3;
2791 get_modrm(*data, &mod, ®op, &rm);
2794 data += PrintRightOperand(data);
2797 data += PrintRightXMMOperand(data);
2800 AppendToBuffer("cmp%sss %s,%s", cmp_pseudo_op[data[1]],
2802 data += 2;
2805 data += PrintRightXMMOperand(data);
2808 } else if (*(data + 1) == 0xA5) {
2809 data += 2;
2811 } else if (*(data + 1) == 0xAB) {
2812 data += 2;
2814 } else if (*(data + 1) == 0x90) {
2815 data += 2;
2823 data += F7Instruction(data);
2828 data++;
2836 int instr_len = data - instr;
2838 printf("%02x", *data);
2844 for (byte* bp = instr; bp < data; bp++) {