Lines Matching full:data
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
311 static void get_modrm(byte data, int* mod, int* regop, int* rm) {
312 *mod = (data >> 6) & 3;
313 *regop = (data & 0x38) >> 3;
314 *rm = data & 7;
318 static void get_sib(byte data, int* scale, int* index, int* base) {
319 *scale = (data >> 6) & 3;
320 *index = (data >> 3) & 7;
321 *base = data & 7;
329 int PrintOperands(const char* mnem, OperandOrder op_order, byte* data);
330 int PrintImmediateOp(byte* data);
331 int F7Instruction(byte* data);
332 int D1D3C1Instruction(byte* data);
333 int JumpShort(byte* data);
334 int JumpConditional(byte* data, const char* comment);
335 int JumpConditionalShort(byte* data, const char* comment);
336 int SetCC(byte* data);
337 int CMov(byte* data);
338 int FPUInstruction(byte* data);
452 // Returns number of bytes used including the current *data.
456 byte* data) {
457 byte modrm = *data;
464 advance = PrintRightOperand(data);
469 advance = PrintRightOperand(data);
481 // Returns number of bytes used by machine instruction, including *data byte.
483 int DisassemblerIA32::PrintImmediateOp(byte* data) {
484 bool sign_extension_bit = (*data & 0x02) != 0;
485 byte modrm = *(data+1);
500 int count = PrintRightOperand(data+1);
502 AppendToBuffer(",0x%x", *(data + 1 + count));
505 AppendToBuffer(",0x%x", *reinterpret_cast<int32_t*>(data + 1 + count));
511 // Returns number of bytes used, including *data.
512 int DisassemblerIA32::F7Instruction(byte* data) {
513 ASSERT_EQ(0xF7, *data);
514 byte modrm = *(data+1);
529 int32_t imm = *reinterpret_cast<int32_t*>(data+2);
534 int count = PrintRightOperand(data+1);
535 int32_t imm = *reinterpret_cast<int32_t*>(data+1+count);
544 int DisassemblerIA32::D1D3C1Instruction(byte* data) {
545 byte op = *data;
547 byte modrm = *(data+1);
566 imm8 = *(data+2);
585 // Returns number of bytes used, including *data.
586 int DisassemblerIA32::JumpShort(byte* data) {
587 ASSERT_EQ(0xEB, *data);
588 byte b = *(data+1);
589 byte* dest = data + static_cast<int8_t>(b) + 2;
595 // Returns number of bytes used, including *data.
596 int DisassemblerIA32::JumpConditional(byte* data, const char* comment) {
597 ASSERT_EQ(0x0F, *data);
598 byte cond = *(data+1) & 0x0F;
599 byte* dest = data + *reinterpret_cast<int32_t*>(data+2) + 6;
609 // Returns number of bytes used, including *data.
610 int DisassemblerIA32::JumpConditionalShort(byte* data, const char* comment) {
611 byte cond = *data & 0x0F;
612 byte b = *(data+1);
613 byte* dest = data + static_cast<int8_t>(b) + 2;
623 // Returns number of bytes used, including *data.
624 int DisassemblerIA32::SetCC(byte* data) {
625 ASSERT_EQ(0x0F, *data);
626 byte cond = *(data+1) & 0x0F;
629 PrintRightByteOperand(data+2);
634 // Returns number of bytes used, including *data.
635 int DisassemblerIA32::CMov(byte* data) {
636 ASSERT_EQ(0x0F, *data);
637 byte cond = *(data + 1) & 0x0F;
639 int op_size = PrintOperands(mnem, REG_OPER_OP_ORDER, data + 2);
644 // Returns number of bytes used, including *data.
645 int DisassemblerIA32::FPUInstruction(byte* data) {
646 byte escape_opcode = *data;
648 byte modrm_byte = *(data+1);
653 return MemoryFPUInstruction(escape_opcode, modrm_byte, data+1);
834 byte* data = instr;
838 if (*data == 0x3E /*ds*/) {
840 data++;
841 } else if (*data == 0x2E /*cs*/) {
843 data++;
847 const InstructionDesc& idesc = instruction_table.Get(*data);
851 data++;
855 data++;
856 data += PrintOperands(idesc.mnem, idesc.op_order_, data);
860 data += JumpConditionalShort(data, branch_hint);
864 AppendToBuffer("%s %s", idesc.mnem, NameOfCPURegister(*data & 0x07));
865 data++;
869 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
871 NameOfCPURegister(*data & 0x07),
873 data += 5;
878 byte* addr = data + *reinterpret_cast<int32_t*>(data+1) + 5;
880 data += 5;
885 byte* addr = reinterpret_cast<byte*>(*reinterpret_cast<int32_t*>(data+1));
887 data += 5;
900 switch (*data) {
902 AppendToBuffer("ret 0x%x", *reinterpret_cast<uint16_t*>(data+1));
903 data += 3;
909 get_modrm(*(data+1), &mod, ®op, &rm);
911 *data == 0x6B ? *(data+2) : *reinterpret_cast<int32_t*>(data+2);
916 data += 2 + (*data == 0x6B ? 1 : 4);
922 get_modrm(*(data+1), &mod, ®op, &rm);
924 AppendToBuffer("test_b %s,%d", NameOfCPURegister(rm), *(data+2));
928 data += 3;
934 data += PrintImmediateOp(data);
938 { byte f0byte = *(data+1);
942 data += 2;
944 data += JumpConditional(data, branch_hint);
947 data += 2;
948 data += PrintOperands(f0mnem, REG_OPER_OP_ORDER, data);
950 data += SetCC(data);
952 data += CMov(data);
954 data += 2;
959 get_modrm(*data, &mod, ®op, &rm);
960 data += PrintRightOperand(data);
974 { data++;
976 get_modrm(*data, &mod, ®op, &rm);
979 data += PrintRightOperand(data);
985 { data++;
987 get_modrm(*data, &mod, ®op, &rm);
998 data += PrintRightOperand(data);
1004 { bool is_byte = *data == 0xC6;
1005 data++;
1007 data += PrintRightOperand(data);
1008 int32_t imm = is_byte ? *data : *reinterpret_cast<int32_t*>(data);
1010 data += is_byte ? 1 : 4;
1015 { data++;
1017 get_modrm(*data, &mod, ®op, &rm);
1025 data += PrintRightOperand(data);
1026 int32_t imm = *data;
1028 data++;
1034 { bool is_byte = *data == 0x88;
1036 data++;
1037 get_modrm(*data, &mod, ®op, &rm);
1039 data += PrintRightOperand(data);
1045 data++;
1046 if (*data == 0x8B) {
1047 data++;
1048 data += PrintOperands("mov_w", REG_OPER_OP_ORDER, data);
1049 } else if (*data == 0x89) {
1050 data++;
1052 get_modrm(*data, &mod, ®op, &rm);
1054 data += PrintRightOperand(data);
1056 } else if (*data == 0x0F) {
1057 data++;
1058 if (*data == 0x2F) {
1059 data++;
1061 get_modrm(*data, &mod, ®op, &rm);
1065 data++;
1066 } else if (*data == 0x57) {
1067 data++;
1069 get_modrm(*data, &mod, ®op, &rm);
1073 data++;
1074 } else if (*data == 0x6F) {
1075 data++;
1077 get_modrm(*data, &mod, ®op, &rm);
1079 data += PrintRightOperand(data);
1080 } else if (*data == 0x7F) {
1082 data++;
1084 get_modrm(*data, &mod, ®op, &rm);
1085 data += PrintRightOperand(data);
1096 { data++;
1098 get_modrm(*data, &mod, ®op, &rm);
1104 data++;
1109 AppendToBuffer("push 0x%x", *reinterpret_cast<int32_t*>(data+1));
1110 data += 5;
1114 data + 1));
1115 data += 2;
1119 AppendToBuffer("test al,0x%x", *reinterpret_cast<uint8_t*>(data+1));
1120 data += 2;
1124 AppendToBuffer("subb eax,0x%x", *reinterpret_cast<uint8_t*>(data+1));
1125 data += 2;
1129 AppendToBuffer("test eax,0x%x", *reinterpret_cast<int32_t*>(data+1));
1130 data += 5;
1136 data += D1D3C1Instruction(data);
1146 data += FPUInstruction(data);
1150 data += JumpShort(data);
1154 if (*(data+1) == 0x0F) {
1155 byte b2 = *(data+2);
1158 data += 3;
1160 get_modrm(*data, &mod, ®op, &rm);
1161 data += PrintRightOperand(data);
1164 data += 3;
1166 get_modrm(*data, &mod, ®op, &rm);
1168 data += PrintRightOperand(data);
1178 data += 3;
1180 get_modrm(*data, &mod, ®op, &rm);
1183 data += PrintRightOperand(data);
1189 data++;
1198 if (*(data+1) == 0x0F) {
1199 if (*(data+2) == 0x2C) {
1200 data += 3;
1201 data += PrintOperands("cvttss2si", REG_OPER_OP_ORDER, data);
1202 } else if (*(data+2) == 0x6F) {
1203 data += 3;
1205 get_modrm(*data, &mod, ®op, &rm);
1207 data += PrintRightOperand(data);
1208 } else if (*(data+2) == 0x7F) {
1210 data += 3;
1212 get_modrm(*data, &mod, ®op, &rm);
1213 data += PrintRightOperand(data);
1218 } else if (*(data+1) == 0xA5) {
1219 data += 2;
1227 data += F7Instruction(data);
1239 int instr_len = data - instr;
1241 printf("%02x", *data);
1247 for (byte* bp = instr; bp < data; bp++) {
