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);
884 byte* data = instr;
888 if (*data == 0x3E /*ds*/) {
890 data++;
891 } else if (*data == 0x2E /*cs*/) {
893 data++;
897 const InstructionDesc& idesc = instruction_table_->Get(*data);
901 data++;
905 data++;
906 data += PrintOperands(idesc.mnem, idesc.op_order_, data);
910 data += JumpConditionalShort(data, branch_hint);
914 AppendToBuffer("%s %s", idesc.mnem, NameOfCPURegister(*data & 0x07));
915 data++;
919 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
921 NameOfCPURegister(*data & 0x07),
923 data += 5;
928 byte* addr = data + *reinterpret_cast<int32_t*>(data+1) + 5;
930 data += 5;
935 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
937 data += 5;
942 AppendToBuffer("%s al, 0x%x", idesc.mnem, data[1]);
943 data += 2;
956 switch (*data) {
958 AppendToBuffer("ret 0x%x", *reinterpret_cast<uint16_t*>(data+1));
959 data += 3;
965 get_modrm(*(data+1), &mod, ®op, &rm);
967 *data == 0x6B ? *(data+2) : *reinterpret_cast<int32_t*>(data+2);
972 data += 2 + (*data == 0x6B ? 1 : 4);
977 { data++;
979 get_modrm(*data, &mod, ®op, &rm);
982 data += PrintRightByteOperand(data);
983 int32_t imm = *data;
985 data++;
994 data += PrintImmediateOp(data);
998 { byte f0byte = data[1];
1002 get_modrm(*data, &mod, ®op, &rm);
1005 data += PrintRightOperand(data);
1006 } else if (f0byte == 0x1F && data[2] == 0) {
1008 data += 3;
1009 } else if (f0byte == 0x1F && data[2] == 0x40 && data[3] == 0) {
1011 data += 4;
1012 } else if (f0byte == 0x1F && data[2] == 0x44 && data[3] == 0 &&
1013 data[4] == 0) {
1015 data += 5;
1016 } else if (f0byte == 0x1F && data[2] == 0x80 && data[3] == 0 &&
1017 data[4] == 0 && data[5] == 0 && data[6] == 0) {
1019 data += 7;
1020 } else if (f0byte == 0x1F && data[2] == 0x84 && data[3] == 0 &&
1021 data[4] == 0 && data[5] == 0 && data[6] == 0 &&
1022 data[7] == 0) {
1024 data += 8;
1027 data += 2;
1029 data += 2;
1031 get_modrm(*data, &mod, ®op, &rm);
1035 data++;
1037 data += 2;
1039 get_modrm(*data, &mod, ®op, &rm);
1043 data++;
1045 data += 2;
1047 get_modrm(*data, &mod, ®op, &rm);
1051 data++;
1053 data += JumpConditional(data, branch_hint);
1056 data += 2;
1057 data += PrintOperands(f0mnem, REG_OPER_OP_ORDER, data);
1059 data += SetCC(data);
1061 data += CMov(data);
1063 data += 2;
1068 get_modrm(*data, &mod, ®op, &rm);
1069 data += PrintRightOperand(data);
1083 { data++;
1085 get_modrm(*data, &mod, ®op, &rm);
1088 data += PrintRightOperand(data);
1094 { data++;
1096 get_modrm(*data, &mod, ®op, &rm);
1107 data += PrintRightOperand(data);
1113 { bool is_byte = *data == 0xC6;
1114 data++;
1117 data += PrintRightByteOperand(data);
1118 int32_t imm = *data;
1120 data++;
1123 data += PrintRightOperand(data);
1124 int32_t imm = *reinterpret_cast<int32_t*>(data);
1126 data += 4;
1132 { data++;
1134 get_modrm(*data, &mod, ®op, &rm);
1142 data += PrintRightByteOperand(data);
1143 int32_t imm = *data;
1145 data++;
1151 { bool is_byte = *data == 0x88;
1153 data++;
1154 get_modrm(*data, &mod, ®op, &rm);
1157 data += PrintRightByteOperand(data);
1161 data += PrintRightOperand(data);
1168 while (*data == 0x66) data++;
1169 if (*data == 0xf && data[1] == 0x1f) {
1171 } else if (*data == 0x90) {
1173 } else if (*data == 0x8B) {
1174 data++;
1175 data += PrintOperands("mov_w", REG_OPER_OP_ORDER, data);
1176 } else if (*data == 0x89) {
1177 data++;
1179 get_modrm(*data, &mod, ®op, &rm);
1181 data += PrintRightOperand(data);
1183 } else if (*data == 0x0F) {
1184 data++;
1185 if (*data == 0x38) {
1186 data++;
1187 if (*data == 0x17) {
1188 data++;
1190 get_modrm(*data, &mod, ®op, &rm);
1194 data++;
1195 } else if (*data == 0x2A) {
1197 data++;
1199 get_modrm(*data, &mod, ®op, &rm);
1201 data += PrintRightOperand(data);
1205 } else if (*data == 0x3A) {
1206 data++;
1207 if (*data == 0x0B) {
1208 data++;
1210 get_modrm(*data, &mod, ®op, &rm);
1211 int8_t imm8 = static_cast<int8_t>(data[1]);
1216 data += 2;
1217 } else if (*data == 0x16) {
1218 data++;
1220 get_modrm(*data, &mod, ®op, &rm);
1221 int8_t imm8 = static_cast<int8_t>(data[1]);
1226 data += 2;
1227 } else if (*data == 0x17) {
1228 data++;
1230 get_modrm(*data, &mod, ®op, &rm);
1231 int8_t imm8 = static_cast<int8_t>(data[1]);
1236 data += 2;
1237 } else if (*data == 0x22) {
1238 data++;
1240 get_modrm(*data, &mod, ®op, &rm);
1241 int8_t imm8 = static_cast<int8_t>(data[1]);
1246 data += 2;
1250 } else if (*data == 0x2E || *data == 0x2F) {
1251 const char* mnem = (*data == 0x2E) ? "ucomisd" : "comisd";
1252 data++;
1254 get_modrm(*data, &mod, ®op, &rm);
1259 data++;
1262 data += PrintRightOperand(data);
1264 } else if (*data == 0x50) {
1265 data++;
1267 get_modrm(*data, &mod, ®op, &rm);
1271 data++;
1272 } else if (*data == 0x54) {
1273 data++;
1275 get_modrm(*data, &mod, ®op, &rm);
1279 data++;
1280 } else if (*data == 0x56) {
1281 data++;
1283 get_modrm(*data, &mod, ®op, &rm);
1287 data++;
1288 } else if (*data == 0x57) {
1289 data++;
1291 get_modrm(*data, &mod, ®op, &rm);
1295 data++;
1296 } else if (*data == 0x6E) {
1297 data++;
1299 get_modrm(*data, &mod, ®op, &rm);
1301 data += PrintRightOperand(data);
1302 } else if (*data == 0x6F) {
1303 data++;
1305 get_modrm(*data, &mod, ®op, &rm);
1307 data += PrintRightXMMOperand(data);
1308 } else if (*data == 0x70) {
1309 data++;
1311 get_modrm(*data, &mod, ®op, &rm);
1312 int8_t imm8 = static_cast<int8_t>(data[1]);
1317 data += 2;
1318 } else if (*data == 0x76) {
1319 data++;
1321 get_modrm(*data, &mod, ®op, &rm);
1325 data++;
1326 } else if (*data == 0x90) {
1327 data++;
1329 } else if (*data == 0xF3) {
1330 data++;
1332 get_modrm(*data, &mod, ®op, &rm);
1336 data++;
1337 } else if (*data == 0x73) {
1338 data++;
1340 get_modrm(*data, &mod, ®op, &rm);
1341 int8_t imm8 = static_cast<int8_t>(data[1]);
1347 data += 2;
1348 } else if (*data == 0xD3) {
1349 data++;
1351 get_modrm(*data, &mod, ®op, &rm);
1355 data++;
1356 } else if (*data == 0x7F) {
1358 data++;
1360 get_modrm(*data, &mod, ®op, &rm);
1361 data += PrintRightXMMOperand(data);
1363 } else if (*data == 0x7E) {
1364 data++;
1366 get_modrm(*data, &mod, ®op, &rm);
1368 data += PrintRightOperand(data);
1370 } else if (*data == 0xDB) {
1371 data++;
1373 get_modrm(*data, &mod, ®op, &rm);
1377 data++;
1378 } else if (*data == 0xE7) {
1379 data++;
1381 get_modrm(*data, &mod, ®op, &rm);
1384 data += PrintRightOperand(data);
1389 } else if (*data == 0xEF) {
1390 data++;
1392 get_modrm(*data, &mod, ®op, &rm);
1396 data++;
1397 } else if (*data == 0xEB) {
1398 data++;
1400 get_modrm(*data, &mod, ®op, &rm);
1404 data++;
1414 { data++;
1416 get_modrm(*data, &mod, ®op, &rm);
1419 data += PrintRightOperand(data);
1427 AppendToBuffer("push 0x%x", *reinterpret_cast<int32_t*>(data+1));
1428 data += 5;
1432 AppendToBuffer("push 0x%x", *reinterpret_cast<int8_t*>(data + 1));
1433 data += 2;
1437 AppendToBuffer("test al,0x%x", *reinterpret_cast<uint8_t*>(data+1));
1438 data += 2;
1442 AppendToBuffer("test eax,0x%x", *reinterpret_cast<int32_t*>(data+1));
1443 data += 5;
1449 data += D1D3C1Instruction(data);
1459 data += FPUInstruction(data);
1463 data += JumpShort(data);
1467 if (*(data+1) == 0x0F) {
1468 byte b2 = *(data+2);
1471 data += 3;
1473 get_modrm(*data, &mod, ®op, &rm);
1474 data += PrintRightXMMOperand(data);
1477 data += 3;
1479 get_modrm(*data, &mod, ®op, &rm);
1481 data += PrintRightXMMOperand(data);
1483 data += 3;
1485 get_modrm(*data, &mod, ®op, &rm);
1487 data += PrintRightXMMOperand(data);
1500 data += 3;
1502 get_modrm(*data, &mod, ®op, &rm);
1505 data += PrintRightOperand(data);
1508 data += PrintRightXMMOperand(data);
1522 pseudo_op[data[1]],
1525 data += 2;
1528 data += PrintRightXMMOperand(data);
1537 if (*(data+1) == 0x0F) {
1538 byte b2 = *(data+2);
1541 data += 3;
1543 get_modrm(*data, &mod, ®op, &rm);
1544 data += PrintRightXMMOperand(data);
1547 data += 3;
1549 get_modrm(*data, &mod, ®op, &rm);
1551 data += PrintRightXMMOperand(data);
1553 data += 3;
1555 get_modrm(*data, &mod, ®op, &rm);
1557 data += PrintRightXMMOperand(data);
1559 data += 3;
1561 get_modrm(*data, &mod, ®op, &rm);
1563 data += PrintRightXMMOperand(data);
1565 data += 3;
1567 get_modrm(*data, &mod, ®op, &rm);
1569 data += PrintRightXMMOperand(data);
1572 data += 3;
1574 get_modrm(*data, &mod, ®op, &rm);
1575 data += PrintRightXMMOperand(data);
1580 } else if (*(data+1) == 0xA5) {
1581 data += 2;
1583 } else if (*(data+1) == 0xAB) {
1584 data += 2;
1592 data += F7Instruction(data);
1604 int instr_len = data - instr;
1606 printf("%02x", *data);
1612 for (byte* bp = instr; bp < data; bp++) {
