Lines Matching refs:instr
77 void Stop(Instruction* instr);
85 static const Instr kBreakpointInstr = SPECIAL | BREAK | 0xfffff << 6;
86 static const Instr kNopInstr = 0x0;
128 void MipsDebugger::Stop(Instruction* instr) {
130 char* str = reinterpret_cast<char*>(instr->InstructionBits());
136 instr->SetInstructionBits(0x0); // Overwrite with nop.
149 void MipsDebugger::Stop(Instruction* instr) {
150 const char* str = reinterpret_cast<char*>(instr->InstructionBits());
380 Instruction* instr = reinterpret_cast<Instruction*>(sim_->get_pc());
381 if (!(instr->IsTrap()) ||
382 instr->InstructionBits() == rtCallRedirInstr) {
719 Instruction* instr) {
720 intptr_t address = reinterpret_cast<intptr_t>(instr);
730 CHECK(memcmp(reinterpret_cast<void*>(instr),
996 int Simulator::ReadW(int32_t addr, Instruction* instr) {
1007 reinterpret_cast<void*>(instr));
1014 void Simulator::WriteW(int32_t addr, int value, Instruction* instr) {
1026 reinterpret_cast<void*>(instr));
1032 double Simulator::ReadD(int32_t addr, Instruction* instr) {
1038 reinterpret_cast<void*>(instr));
1044 void Simulator::WriteD(int32_t addr, double value, Instruction* instr) {
1051 reinterpret_cast<void*>(instr));
1056 uint16_t Simulator::ReadHU(int32_t addr, Instruction* instr) {
1062 reinterpret_cast<void*>(instr));
1068 int16_t Simulator::ReadH(int32_t addr, Instruction* instr) {
1074 reinterpret_cast<void*>(instr));
1080 void Simulator::WriteH(int32_t addr, uint16_t value, Instruction* instr) {
1087 reinterpret_cast<void*>(instr));
1092 void Simulator::WriteH(int32_t addr, int16_t value, Instruction* instr) {
1099 reinterpret_cast<void*>(instr));
1137 void Simulator::Format(Instruction* instr, const char* format) {
1139 reinterpret_cast<intptr_t>(instr), format);
1163 void Simulator::SoftwareInterrupt(Instruction* instr) {
1167 int32_t func = instr->FunctionFieldRaw();
1168 int32_t code = (func == BREAK) ? instr->Bits(25, 6) : -1;
1171 if (instr->InstructionBits() == rtCallRedirInstr) {
1177 Redirection* redirection = Redirection::FromSwiInstruction(instr);
1270 PrintF("\n---- break %d marker: %3d (instr count: %8d) ----------"
1293 void Simulator::ConfigureTypeRegister(Instruction* instr,
1304 const Opcode op = instr->OpcodeFieldRaw();
1305 const int32_t rs_reg = instr->RsValue();
1308 const int32_t rt_reg = instr->RtValue();
1311 const int32_t rd_reg = instr->RdValue();
1312 const uint32_t sa = instr->SaValue();
1314 const int32_t fs_reg = instr->FsValue();
1320 switch (instr->RsFieldRaw()) {
1352 switch (instr->FunctionFieldRaw()) {
1355 next_pc = get_register(instr->RsValue());
1486 switch (instr->FunctionFieldRaw()) {
1498 switch (instr->FunctionFieldRaw()) {
1529 void Simulator::DecodeTypeRegister(Instruction* instr) {
1531 const Opcode op = instr->OpcodeFieldRaw();
1532 const int32_t rs_reg = instr->RsValue();
1535 const int32_t rt_reg = instr->RtValue();
1538 const int32_t rd_reg = instr->RdValue();
1540 const int32_t fs_reg = instr->FsValue();
1541 const int32_t ft_reg = instr->FtValue();
1542 const int32_t fd_reg = instr->FdValue();
1561 ConfigureTypeRegister(instr,
1574 switch (instr->RsFieldRaw()) {
1599 switch (instr->FunctionFieldRaw()) {
1627 cc = instr->FCccValue();
1629 switch (instr->FunctionFieldRaw()) {
1756 switch (instr->FunctionFieldRaw()) {
1770 switch (instr->FunctionFieldRaw()) {
1792 switch (instr->FunctionFieldRaw()) {
1837 SoftwareInterrupt(instr);
1845 uint32_t cc = instr->FCccValue();
1847 if (instr->Bit(16)) { // Read Tf bit
1862 switch (instr->FunctionFieldRaw()) {
1874 switch (instr->FunctionFieldRaw()) {
1876 // Ins instr leaves result in Rt, rather than Rd.
1880 // Ext instr leaves result in Rt, rather than Rd.
1897 void Simulator::DecodeTypeImmediate(Instruction* instr) {
1899 Opcode op = instr->OpcodeFieldRaw();
1900 int32_t rs = get_register(instr->RsValue());
1902 int32_t rt_reg = instr->RtValue(); // destination register
1904 int16_t imm16 = instr->Imm16Value();
1906 int32_t ft_reg = instr->FtValue(); // destination register
1937 switch (instr->RsFieldRaw()) {
1939 cc = instr->FBccValue();
1942 do_branch = (instr->FBtrueValue()) ? cc_value : !cc_value;
1957 switch (instr->RtFieldRaw()) {
1973 switch (instr->RtFieldRaw()) {
1983 if (instr->IsLinkingInstruction()) {
2048 alu_out = ReadH(addr, instr);
2056 alu_out = ReadW(addr, instr);
2063 alu_out = ReadW(addr, instr);
2071 alu_out = ReadHU(addr, instr);
2079 alu_out = ReadW(addr, instr);
2095 mem_value = ReadW(addr, instr) & mask;
2106 mem_value = ReadW(addr, instr);
2112 alu_out = ReadW(addr, instr);
2116 fp_out = ReadD(addr, instr);
2141 if (instr->IsLinkingInstruction()) {
2173 WriteH(addr, static_cast<uint16_t>(rt), instr);
2176 WriteW(addr, mem_value, instr);
2179 WriteW(addr, rt, instr);
2182 WriteW(addr, mem_value, instr);
2192 WriteW(addr, get_fpu_register(ft_reg), instr);
2196 WriteD(addr, get_fpu_register_double(ft_reg), instr);
2220 void Simulator::DecodeTypeJump(Instruction* instr) {
2226 int32_t next_pc = pc_high_bits | (instr->Imm26Value() << 2);
2237 if (instr->IsLinkingInstruction()) {
2246 void Simulator::InstructionDecode(Instruction* instr) {
2248 CheckICache(isolate_->simulator_i_cache(), instr);
2256 dasm.InstructionDecode(buffer, reinterpret_cast<byte_*>(instr));
2257 PrintF(" 0x%08x %s\n", reinterpret_cast<intptr_t>(instr),
2261 switch (instr->InstructionType()) {
2263 DecodeTypeRegister(instr);
2266 DecodeTypeImmediate(instr);
2269 DecodeTypeJump(instr);
2275 set_register(pc, reinterpret_cast<int32_t>(instr) +
2290 Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
2292 InstructionDecode(instr);
2299 Instruction* instr = reinterpret_cast<Instruction*>(program_counter);
2305 InstructionDecode(instr);
