Lines Matching refs:data
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
335 static void get_modrm(byte data, int* mod, int* regop, int* rm) {
336 *mod = (data >> 6) & 3;
337 *regop = (data & 0x38) >> 3;
338 *rm = data & 7;
342 static void get_sib(byte data, int* scale, int* index, int* base) {
343 *scale = (data >> 6) & 3;
344 *index = (data >> 3) & 7;
345 *base = data & 7;
354 int PrintOperands(const char* mnem, OperandOrder op_order, byte* data);
355 int PrintImmediateOp(byte* data);
356 int F7Instruction(byte* data);
357 int D1D3C1Instruction(byte* data);
358 int JumpShort(byte* data);
359 int JumpConditional(byte* data, const char* comment);
360 int JumpConditionalShort(byte* data, const char* comment);
361 int SetCC(byte* data);
362 int CMov(byte* data);
363 int FPUInstruction(byte* data);
485 // Returns number of bytes used including the current *data.
489 byte* data) {
490 byte modrm = *data;
497 advance = PrintRightOperand(data);
502 advance = PrintRightOperand(data);
514 // Returns number of bytes used by machine instruction, including *data byte.
516 int DisassemblerIA32::PrintImmediateOp(byte* data) {
517 bool sign_extension_bit = (*data & 0x02) != 0;
518 byte modrm = *(data+1);
533 int count = PrintRightOperand(data+1);
535 AppendToBuffer(",0x%x", *(data + 1 + count));
538 AppendToBuffer(",0x%x", *reinterpret_cast<int32_t*>(data + 1 + count));
544 // Returns number of bytes used, including *data.
545 int DisassemblerIA32::F7Instruction(byte* data) {
546 ASSERT_EQ(0xF7, *data);
547 byte modrm = *(data+1);
563 int32_t imm = *reinterpret_cast<int32_t*>(data+2);
568 int count = PrintRightOperand(data+1);
569 int32_t imm = *reinterpret_cast<int32_t*>(data+1+count);
579 int DisassemblerIA32::D1D3C1Instruction(byte* data) {
580 byte op = *data;
582 byte modrm = *(data+1);
602 imm8 = *(data+2);
621 // Returns number of bytes used, including *data.
622 int DisassemblerIA32::JumpShort(byte* data) {
623 ASSERT_EQ(0xEB, *data);
624 byte b = *(data+1);
625 byte* dest = data + static_cast<int8_t>(b) + 2;
631 // Returns number of bytes used, including *data.
632 int DisassemblerIA32::JumpConditional(byte* data, const char* comment) {
633 ASSERT_EQ(0x0F, *data);
634 byte cond = *(data+1) & 0x0F;
635 byte* dest = data + *reinterpret_cast<int32_t*>(data+2) + 6;
645 // Returns number of bytes used, including *data.
646 int DisassemblerIA32::JumpConditionalShort(byte* data, const char* comment) {
647 byte cond = *data & 0x0F;
648 byte b = *(data+1);
649 byte* dest = data + static_cast<int8_t>(b) + 2;
659 // Returns number of bytes used, including *data.
660 int DisassemblerIA32::SetCC(byte* data) {
661 ASSERT_EQ(0x0F, *data);
662 byte cond = *(data+1) & 0x0F;
665 PrintRightByteOperand(data+2);
670 // Returns number of bytes used, including *data.
671 int DisassemblerIA32::CMov(byte* data) {
672 ASSERT_EQ(0x0F, *data);
673 byte cond = *(data + 1) & 0x0F;
675 int op_size = PrintOperands(mnem, REG_OPER_OP_ORDER, data + 2);
680 // Returns number of bytes used, including *data.
681 int DisassemblerIA32::FPUInstruction(byte* data) {
682 byte escape_opcode = *data;
684 byte modrm_byte = *(data+1);
689 return MemoryFPUInstruction(escape_opcode, modrm_byte, data+1);
893 byte* data = instr;
897 if (*data == 0x3E /*ds*/) {
899 data++;
900 } else if (*data == 0x2E /*cs*/) {
902 data++;
906 const InstructionDesc& idesc = instruction_table_->Get(*data);
910 data++;
914 data++;
915 data += PrintOperands(idesc.mnem, idesc.op_order_, data);
919 data += JumpConditionalShort(data, branch_hint);
923 AppendToBuffer("%s %s", idesc.mnem, NameOfCPURegister(*data & 0x07));
924 data++;
928 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
930 NameOfCPURegister(*data & 0x07),
932 data += 5;
937 byte* addr = data + *reinterpret_cast<int32_t*>(data+1) + 5;
939 data += 5;
944 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
946 data += 5;
951 AppendToBuffer("%s al,0x%x", idesc.mnem, data[1]);
952 data += 2;
965 switch (*data) {
967 AppendToBuffer("ret 0x%x", *reinterpret_cast<uint16_t*>(data+1));
968 data += 3;
974 get_modrm(*(data+1), &mod, ®op, &rm);
976 *data == 0x6B ? *(data+2) : *reinterpret_cast<int32_t*>(data+2);
981 data += 2 + (*data == 0x6B ? 1 : 4);
986 { data++;
988 get_modrm(*data, &mod, ®op, &rm);
991 data += PrintRightByteOperand(data);
992 int32_t imm = *data;
994 data++;
1003 data += PrintImmediateOp(data);
1007 { byte f0byte = data[1];
1011 get_modrm(*data, &mod, ®op, &rm);
1014 data += PrintRightOperand(data);
1015 } else if (f0byte == 0x1F && data[2] == 0) {
1017 data += 3;
1018 } else if (f0byte == 0x1F && data[2] == 0x40 && data[3] == 0) {
1020 data += 4;
1021 } else if (f0byte == 0x1F && data[2] == 0x44 && data[3] == 0 &&
1022 data[4] == 0) {
1024 data += 5;
1025 } else if (f0byte == 0x1F && data[2] == 0x80 && data[3] == 0 &&
1026 data[4] == 0 && data[5] == 0 && data[6] == 0) {
1028 data += 7;
1029 } else if (f0byte == 0x1F && data[2] == 0x84 && data[3] == 0 &&
1030 data[4] == 0 && data[5] == 0 && data[6] == 0 &&
1031 data[7] == 0) {
1033 data += 8;
1036 data += 2;
1038 data += 2;
1040 get_modrm(*data, &mod, ®op, &rm);
1044 data++;
1062 data += 2;
1064 get_modrm(*data, &mod, ®op, &rm);
1068 data += PrintRightXMMOperand(data);
1070 data += 2;
1072 get_modrm(*data, &mod, ®op, &rm);
1076 data++;
1079 data += 2;
1081 get_modrm(*data, &mod, ®op, &rm);
1082 int8_t imm8 = static_cast<int8_t>(data[1]);
1087 data += 2;
1089 datadata, branch_hint);
1092 data += 2;
1093 data += PrintOperands(f0mnem, REG_OPER_OP_ORDER, data);
1095 data += SetCC(data);
1097 data += CMov(data);
1099 data += 2;
1104 get_modrm(*data, &mod, ®op, &rm);
1105 data += PrintRightOperand(data);
1119 { data++;
1121 get_modrm(*data, &mod, ®op, &rm);
1124 data += PrintRightOperand(data);
1130 { data++;
1132 get_modrm(*data, &mod, ®op, &rm);
1143 data += PrintRightOperand(data);
1149 { bool is_byte = *data == 0xC6;
1150 data++;
1153 data += PrintRightByteOperand(data);
1154 int32_t imm = *data;
1156 data++;
1159 data += PrintRightOperand(data);
1160 int32_t imm = *reinterpret_cast<int32_t*>(data);
1162 data += 4;
1168 { data++;
1170 get_modrm(*data, &mod, ®op, &rm);
1178 data += PrintRightByteOperand(data);
1179 int32_t imm = *data;
1181 data++;
1187 { bool is_byte = *data == 0x88;
1189 data++;
1190 get_modrm(*data, &mod, ®op, &rm);
1193 data += PrintRightByteOperand(data);
1197 data += PrintRightOperand(data);
1204 while (*data == 0x66) data++;
1205 if (*data == 0xf && data[1] == 0x1f) {
1207 } else if (*data == 0x90) {
1209 } else if (*data == 0x8B) {
1210 data++;
1211 data += PrintOperands("mov_w", REG_OPER_OP_ORDER, data);
1212 } else if (*data == 0x89) {
1213 data++;
1215 get_modrm(*data, &mod, ®op, &rm);
1217 data += PrintRightOperand(data);
1219 } else if (*data == 0xC7) {
1220 data++;
1222 data += PrintRightOperand(data);
1223 int imm = *reinterpret_cast<int16_t*>(data);
1225 data += 2;
1226 } else if (*data == 0x0F) {
1227 data++;
1228 if (*data == 0x38) {
1229 data++;
1230 if (*data == 0x17) {
1231 data++;
1233 get_modrm(*data, &mod, ®op, &rm);
1237 data++;
1238 } else if (*data == 0x2A) {
1240 data++;
1242 get_modrm(*data, &mod, ®op, &rm);
1244 data += PrintRightOperand(data);
1248 } else if (*data == 0x3A) {
1249 data++;
1250 if (*data == 0x0B) {
1251 data++;
1253 get_modrm(*data, &mod, ®op, &rm);
1254 int8_t imm8 = static_cast<int8_t>(data[1]);
1259 data += 2;
1260 } else if (*data == 0x16) {
1261 data++;
1263 get_modrm(*data, &mod, ®op, &rm);
1264 int8_t imm8 = static_cast<int8_t>(data[1]);
1269 data += 2;
1270 } else if (*data == 0x17) {
1271 data++;
1273 get_modrm(*data, &mod, ®op, &rm);
1274 int8_t imm8 = static_cast<int8_t>(data[1]);
1279 data += 2;
1280 } else if (*data == 0x22) {
1281 data++;
1283 get_modrm(*data, &mod, ®op, &rm);
1284 int8_t imm8 = static_cast<int8_t>(data[1]);
1289 data += 2;
1293 } else if (*data == 0x2E || *data == 0x2F) {
1294 const char* mnem = (*data == 0x2E) ? "ucomisd" : "comisd";
1295 data++;
1297 get_modrm(*data, &mod, ®op, &rm);
1302 data++;
1305 data += PrintRightOperand(data);
1307 } else if (*data == 0x50) {
1308 data++;
1310 get_modrm(*data, &mod, ®op, &rm);
1314 data++;
1315 } else if (*data == 0x54) {
1316 data++;
1318 get_modrm(*data, &mod, ®op, &rm);
1322 data++;
1323 } else if (*data == 0x56) {
1324 data++;
1326 get_modrm(*data, &mod, ®op, &rm);
1330 data++;
1331 } else if (*data == 0x57) {
1332 data++;
1334 get_modrm(*data, &mod, ®op, &rm);
1338 data++;
1339 } else if (*data == 0x6E) {
1340 data++;
1342 get_modrm(*data, &mod, ®op, &rm);
1344 data += PrintRightOperand(data);
1345 } else if (*data == 0x6F) {
1346 data++;
1348 get_modrm(*data, &mod, ®op, &rm);
1350 data += PrintRightXMMOperand(data);
1351 } else if (*data == 0x70) {
1352 data++;
1354 get_modrm(*data, &mod, ®op, &rm);
1355 int8_t imm8 = static_cast<int8_t>(data[1]);
1360 data += 2;
1361 } else if (*data == 0x76) {
1362 data++;
1364 get_modrm(*data, &mod, ®op, &rm);
1368 data++;
1369 } else if (*data == 0x90) {
1370 data++;
1372 } else if (*data == 0xF3) {
1373 data++;
1375 get_modrm(*data, &mod, ®op, &rm);
1379 data++;
1380 } else if (*data == 0x73) {
1381 data++;
1383 get_modrm(*data, &mod, ®op, &rm);
1384 int8_t imm8 = static_cast<int8_t>(data[1]);
1390 data += 2;
1391 } else if (*data == 0xD3) {
1392 data++;
1394 get_modrm(*data, &mod, ®op, &rm);
1398 data++;
1399 } else if (*data == 0x7F) {
1401 data++;
1403 get_modrm(*data, &mod, ®op, &rm);
1404 data += PrintRightXMMOperand(data);
1406 } else if (*data == 0x7E) {
1407 data++;
1409 get_modrm(*data, &mod, ®op, &rm);
1411 data += PrintRightOperand(data);
1413 } else if (*data == 0xDB) {
1414 data++;
1416 get_modrm(*data, &mod, ®op, &rm);
1420 data++;
1421 } else if (*data == 0xE7) {
1422 data++;
1424 get_modrm(*data, &mod, ®op, &rm);
1427 data += PrintRightOperand(data);
1432 } else if (*data == 0xEF) {
1433 data++;
1435 get_modrm(*data, &mod, ®op, &rm);
1439 data++;
1440 } else if (*data == 0xEB) {
1441 data++;
1443 get_modrm(*data, &mod, ®op, &rm);
1447 data++;
1457 { data++;
1459 get_modrm(*data, &mod, ®op, &rm);
1462 data += PrintRightOperand(data);
1470 AppendToBuffer("push 0x%x", *reinterpret_cast<int32_t*>(data+1));
1471 data += 5;
1475 AppendToBuffer("push 0x%x", *reinterpret_cast<int8_t*>(data + 1));
1476 data += 2;
1480 AppendToBuffer("test al,0x%x", *reinterpret_cast<uint8_t*>(data+1));
1481 data += 2;
1485 AppendToBuffer("test eax,0x%x", *reinterpret_cast<int32_t*>(data+1));
1486 data += 5;
1492 data += D1D3C1Instruction(data);
1503 data += FPUInstruction(data);
1507 data += JumpShort(data);
1511 if (*(data+1) == 0x0F) {
1512 byte b2 = *(data+2);
1515 data += 3;
1517 get_modrm(*data, &mod, ®op, &rm);
1518 data += PrintRightXMMOperand(data);
1521 data += 3;
1523 get_modrm(*data, &mod, ®op, &rm);
1525 data += PrintRightXMMOperand(data);
1527 data += 3;
1529 get_modrm(*data, &mod, ®op, &rm);
1531 data += PrintRightXMMOperand(data);
1544 data += 3;
1546 get_modrm(*data, &mod, ®op, &rm);
1549 data += PrintRightOperand(data
1552 data += PrintRightXMMOperand(data);
1566 pseudo_op[data[1]],
1569 data += 2;
1572 data += PrintRightXMMOperand(data);
1581 if (*(data+1) == 0x0F) {
1582 byte b2 = *(data+2);
1585 data += 3;
1587 get_modrm(*data, &mod, ®op, &rm);
1588 data += PrintRightXMMOperand(data);
1591 data += 3;
1593 get_modrm(*data, &mod, ®op, &rm);
1595 data += PrintRightXMMOperand(data);
1597 data += 3;
1599 get_modrm(*data, &mod, ®op, &rm);
1601 data += PrintRightXMMOperand(data);
1603 data += 3;
1605 get_modrm(*data, &mod, ®op, &rm);
1607 data += PrintRightXMMOperand(data);
1609 data += 3;
1611 get_modrm(*data, &mod, ®op, &rm);
1613 data += PrintRightXMMOperand(data);
1616 data += 3;
1618 get_modrm(*data, &mod, ®op, &rm);
1619 data += PrintRightXMMOperand(data);
1624 } else if (*(data+1) == 0xA5) {
1625 data += 2;
1627 } else if (*(data+1) == 0xAB) {
1628 data += 2;
1636 data += F7Instruction(data);
1648 int instr_len = data - instr;
1650 printf("%02x", *data);
1656 for (byte* bp = instr; bp < data; bp++) {
