From 14388ea6906534ac801830be3b452f7f72fa51db Mon Sep 17 00:00:00 2001 From: MerryMage Date: Mon, 4 Jul 2016 21:37:50 +0800 Subject: [PATCH] Proper implementation of Arm::Translate --- src/CMakeLists.txt | 5 +- src/backend_x64/emit_x64.cpp | 10 ++ src/backend_x64/emit_x64.h | 15 ++- src/backend_x64/interface_x64.cpp | 6 +- src/backend_x64/reg_alloc.cpp | 7 ++ src/backend_x64/reg_alloc.h | 2 + src/frontend/arm_types.h | 8 ++ src/frontend/decoder/decoder_detail.h | 3 + src/frontend/decoder/thumb1.h | 4 +- src/frontend/ir/ir.h | 1 + src/frontend/ir_emitter.h | 5 +- src/frontend/translate.cpp | 22 +++++ src/frontend/translate.h | 19 ++++ src/frontend/translate_arm.cpp | 21 ++++ ...{translate_thumb.h => translate_thumb.cpp} | 96 ++++++++++++++++--- tests/CMakeLists.txt | 2 +- tests/arm/test_thumb_instructions.cpp | 74 +++++++------- .../dyncom/arm_dyncom_dec.cpp | 4 +- .../dyncom/arm_dyncom_interpreter.cpp | 20 ++-- .../dyncom/arm_dyncom_run.h | 2 +- .../dyncom/arm_dyncom_thumb.cpp | 4 +- .../skyeye_common/armstate.cpp | 4 +- .../skyeye_common/armstate.h | 2 +- .../skyeye_common/armsupp.cpp | 6 +- .../skyeye_common/vfp/vfp.cpp | 6 +- .../skyeye_common/vfp/vfp.h | 2 +- .../skyeye_common/vfp/vfp_helper.h | 4 +- .../skyeye_common/vfp/vfpdouble.cpp | 6 +- .../skyeye_common/vfp/vfpsingle.cpp | 6 +- 29 files changed, 276 insertions(+), 90 deletions(-) create mode 100644 src/frontend/translate.cpp create mode 100644 src/frontend/translate.h create mode 100644 src/frontend/translate_arm.cpp rename src/frontend/{translate_thumb.h => translate_thumb.cpp} (50%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 370811a6..b18bbd41 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -14,6 +14,7 @@ set(SRCS frontend/disassembler_arm.cpp frontend/ir/ir.cpp frontend/ir_emitter.cpp + frontend/translate.cpp ) set(HEADERS @@ -43,7 +44,9 @@ set(HEADERS frontend/ir/ir.h frontend/ir/opcodes.h frontend/ir_emitter.h - frontend/translate_thumb.h + frontend/translate.h + frontend/translate_arm.cpp + frontend/translate_thumb.cpp interface/interface.h ) diff --git a/src/backend_x64/emit_x64.cpp b/src/backend_x64/emit_x64.cpp index bd40099f..4b997e7c 100644 --- a/src/backend_x64/emit_x64.cpp +++ b/src/backend_x64/emit_x64.cpp @@ -9,6 +9,7 @@ #include "backend_x64/emit_x64.h" #include "common/x64/emitter.h" +#include "frontend/arm_types.h" // TODO: More optimal use of immediates. // TODO: Have ARM flags in host flags and not have them use up GPR registers unless necessary. @@ -34,6 +35,9 @@ static IR::Inst* FindUseWithOpcode(IR::Inst* inst, IR::Opcode opcode) { } CodePtr EmitX64::Emit(Arm::LocationDescriptor descriptor, Dynarmic::IR::Block block) { + inhibit_emission.clear(); + reg_alloc.Reset(); + code->INT3(); CodePtr code_ptr = code->GetCodePtr(); @@ -46,6 +50,7 @@ CodePtr EmitX64::Emit(Arm::LocationDescriptor descriptor, Dynarmic::IR::Block bl reg_alloc.EndOfAllocScope(); } + EmitAddCycles(block.cycle_count); EmitReturnToDispatch(); return code_ptr; @@ -378,6 +383,11 @@ void EmitX64::EmitArithmeticShiftRight(IR::Value* value_) { } } +void EmitX64::EmitAddCycles(size_t cycles) { + ASSERT(cycles < std::numeric_limits::max()); + code->SUB(64, MDisp(R15, offsetof(JitState, cycles_remaining)), Imm32(cycles)); +} + void EmitX64::EmitReturnToDispatch() { // TODO: Update cycle counts diff --git a/src/backend_x64/emit_x64.h b/src/backend_x64/emit_x64.h index 6b5f7c7c..25d8143b 100644 --- a/src/backend_x64/emit_x64.h +++ b/src/backend_x64/emit_x64.h @@ -7,6 +7,7 @@ #pragma once #include +#include #include "backend_x64/reg_alloc.h" #include "backend_x64/routines.h" @@ -19,10 +20,15 @@ namespace BackendX64 { class EmitX64 final { public: - EmitX64(Gen::XEmitter* code, Routines* routines, UserCallbacks cb) : code(code), reg_alloc(code), routines(routines), cb(cb) {} + EmitX64(Gen::XEmitter* code, Routines* routines, UserCallbacks cb) + : reg_alloc(code), code(code), routines(routines), cb(cb) {} CodePtr Emit(Arm::LocationDescriptor descriptor, IR::Block ir); - CodePtr GetBasicBlock(Arm::LocationDescriptor descriptor); + + CodePtr GetBasicBlock(Arm::LocationDescriptor descriptor) { + auto iter = basic_blocks.find(descriptor); + return iter != basic_blocks.end() ? iter->second : nullptr; + } void EmitImmU1(IR::Value* value); void EmitImmU8(IR::Value* value); @@ -46,14 +52,17 @@ public: void EmitLogicalShiftRight(IR::Value* value); void EmitArithmeticShiftRight(IR::Value* value); + void EmitAddCycles(size_t cycles); void EmitReturnToDispatch(); private: std::set inhibit_emission; - Gen::XEmitter* code; RegAlloc reg_alloc; + + Gen::XEmitter* code; Routines* routines; UserCallbacks cb; + std::unordered_map basic_blocks; }; } // namespace BackendX64 diff --git a/src/backend_x64/interface_x64.cpp b/src/backend_x64/interface_x64.cpp index 887bb2da..fcec3c90 100644 --- a/src/backend_x64/interface_x64.cpp +++ b/src/backend_x64/interface_x64.cpp @@ -14,6 +14,7 @@ #include "common/common_types.h" #include "common/scope_exit.h" #include "frontend/arm_types.h" +#include "frontend/translate.h" #include "interface/interface.h" namespace Dynarmic { @@ -27,12 +28,13 @@ struct BlockOfCode : Gen::XCodeBlock { }; struct Jit::Impl { - Impl(UserCallbacks callbacks) : emitter(&block_of_code, &routines, callbacks) {} + Impl(UserCallbacks callbacks) : emitter(&block_of_code, &routines, callbacks), callbacks(callbacks) {} JitState jit_state{}; Routines routines{}; BlockOfCode block_of_code{}; EmitX64 emitter; + const UserCallbacks callbacks; size_t Execute(size_t cycle_count) { u32 pc = jit_state.Reg[15]; @@ -50,7 +52,7 @@ private: if (code_ptr) return code_ptr; - IR::Block ir_block = IR::Block({0, false, false}); // TODO: Do this. + IR::Block ir_block = Arm::Translate(descriptor, callbacks.MemoryRead32); return emitter.Emit(descriptor, ir_block); } }; diff --git a/src/backend_x64/reg_alloc.cpp b/src/backend_x64/reg_alloc.cpp index f4cf9b55..a050bbf8 100644 --- a/src/backend_x64/reg_alloc.cpp +++ b/src/backend_x64/reg_alloc.cpp @@ -201,5 +201,12 @@ void RegAlloc::EndOfAllocScope() { iter.second = nullptr; } +void RegAlloc::Reset() { + hostloc_to_value.clear(); + hostloc_state.clear(); + remaining_uses.clear(); +} + + } // namespace BackendX64 } // namespace Dynarmic diff --git a/src/backend_x64/reg_alloc.h b/src/backend_x64/reg_alloc.h index 967a1fe2..d5a25451 100644 --- a/src/backend_x64/reg_alloc.h +++ b/src/backend_x64/reg_alloc.h @@ -78,6 +78,8 @@ public: void EndOfAllocScope(); + void Reset(); + private: HostLoc SelectARegister(std::initializer_list desired_locations) const; std::vector ValueLocations(IR::Value* value) const; diff --git a/src/frontend/arm_types.h b/src/frontend/arm_types.h index 09651936..e7999a3a 100644 --- a/src/frontend/arm_types.h +++ b/src/frontend/arm_types.h @@ -72,5 +72,13 @@ struct LocationDescriptor { } }; +struct LocationDescriptorHash { + size_t operator()(const LocationDescriptor& x) const { + return std::hash()(static_cast(x.arm_pc) + ^ (static_cast(x.TFlag) << 32) + ^ (static_cast(x.EFlag) << 33)); + } +}; + } // namespace Arm } // namespace Dynarmic diff --git a/src/frontend/decoder/decoder_detail.h b/src/frontend/decoder/decoder_detail.h index a0222256..4cf97c19 100644 --- a/src/frontend/decoder/decoder_detail.h +++ b/src/frontend/decoder/decoder_detail.h @@ -43,6 +43,9 @@ private: expect |= 1 << bit_position; mask |= 1 << bit_position; break; + default: + // Ignore + break; } } return std::make_tuple(mask, expect); diff --git a/src/frontend/decoder/thumb1.h b/src/frontend/decoder/thumb1.h index ce0d6300..9bf0d2f1 100644 --- a/src/frontend/decoder/thumb1.h +++ b/src/frontend/decoder/thumb1.h @@ -56,7 +56,7 @@ private: }; template -static const std::array, 6> g_thumb1_instruction_table {{ +static const std::array, 7> g_thumb1_instruction_table {{ #define INST(fn, name, bitstring) detail::detail::GetMatcher(name, bitstring) @@ -138,7 +138,7 @@ static const std::array, 6> g_thumb1_instruction_table {{ // Branch instructions //{ INST(&V::thumb1_BX, "BX (reg)", "010001110mmmm000") }, // v4T //{ INST(&V::thumb1_BLX, "BLX (reg)", "010001111mmmm000") }, // v5T - //{ INST(&V::thumb1_UDF, "UDF", "11011110--------") }, + { INST(&V::thumb1_UDF, "UDF", "11011110--------") }, //{ INST(&V::thumb1_SWI, "SWI", "11011111xxxxxxxx") }, //{ INST(&V::thumb1_B_cond, "B (cond)", "1101ccccxxxxxxxx") }, //{ INST(&V::thumb1_B_imm, "B (imm)", "11100xxxxxxxxxxx") }, diff --git a/src/frontend/ir/ir.h b/src/frontend/ir/ir.h index acc61197..a8ffecdf 100644 --- a/src/frontend/ir/ir.h +++ b/src/frontend/ir/ir.h @@ -161,6 +161,7 @@ public: Arm::LocationDescriptor location; std::list instructions; + size_t cycle_count = 0; }; diff --git a/src/frontend/ir_emitter.h b/src/frontend/ir_emitter.h index 1c3d2c21..7965fd14 100644 --- a/src/frontend/ir_emitter.h +++ b/src/frontend/ir_emitter.h @@ -15,7 +15,10 @@ namespace Arm { class IREmitter { public: - IR::Block block = Dynarmic::IR::Block({0, false, false}); + explicit IREmitter(LocationDescriptor descriptor) : block(descriptor), current_location(descriptor) {} + + IR::Block block; + LocationDescriptor current_location; struct ResultAndCarry { IR::ValuePtr result; diff --git a/src/frontend/translate.cpp b/src/frontend/translate.cpp new file mode 100644 index 00000000..c68cbe7b --- /dev/null +++ b/src/frontend/translate.cpp @@ -0,0 +1,22 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * This software may be used and distributed according to the terms of the GNU + * General Public License version 2 or any later version. + */ + +#include "frontend/arm_types.h" +#include "frontend/ir/ir.h" +#include "frontend/translate.h" + +namespace Dynarmic { +namespace Arm { + +IR::Block TranslateArm(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32); +IR::Block TranslateThumb(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32); + +IR::Block Translate(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32) { + return (descriptor.TFlag ? TranslateThumb : TranslateArm)(descriptor, memory_read_32); +} + +} // namespace Arm +} // namespace Dynarmic diff --git a/src/frontend/translate.h b/src/frontend/translate.h new file mode 100644 index 00000000..9360b195 --- /dev/null +++ b/src/frontend/translate.h @@ -0,0 +1,19 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * This software may be used and distributed according to the terms of the GNU + * General Public License version 2 or any later version. + */ +#pragma once + +#include "frontend/arm_types.h" +#include "frontend/ir/ir.h" + +namespace Dynarmic { +namespace Arm { + +using MemoryRead32FuncType = u32 (*)(u32 vaddr); + +IR::Block Translate(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32); + +} // namespace Arm +} // namespace Dynarmic diff --git a/src/frontend/translate_arm.cpp b/src/frontend/translate_arm.cpp new file mode 100644 index 00000000..90d71c85 --- /dev/null +++ b/src/frontend/translate_arm.cpp @@ -0,0 +1,21 @@ +/* This file is part of the dynarmic project. + * Copyright (c) 2016 MerryMage + * This software may be used and distributed according to the terms of the GNU + * General Public License version 2 or any later version. + */ + +#include "common/assert.h" +#include "frontend/arm_types.h" +#include "frontend/ir/ir.h" +#include "frontend/translate.h" + +namespace Dynarmic { +namespace Arm { + +IR::Block TranslateArm(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32) { + ASSERT_MSG(0, "Unimplemented"); + return IR::Block(descriptor); +} + +} // namespace Arm +} // namespace Dynarmic diff --git a/src/frontend/translate_thumb.h b/src/frontend/translate_thumb.cpp similarity index 50% rename from src/frontend/translate_thumb.h rename to src/frontend/translate_thumb.cpp index 3e4f7f2e..cea644b1 100644 --- a/src/frontend/translate_thumb.h +++ b/src/frontend/translate_thumb.cpp @@ -4,19 +4,25 @@ * General Public License version 2 or any later version. */ -#pragma once +#include +#include "common/assert.h" #include "frontend/arm_types.h" +#include "frontend/decoder/thumb1.h" #include "frontend/ir_emitter.h" +#include "frontend/translate.h" namespace Dynarmic { namespace Arm { -class TranslatorVisitor { -public: +struct TranslatorVisitor final { + explicit TranslatorVisitor(LocationDescriptor descriptor) : ir(descriptor) { + ASSERT_MSG(descriptor.TFlag, "The processor must be in Thumb mode"); + } + IREmitter ir; - void thumb1_LSL_imm(Imm5 imm5, Reg m, Reg d) { + bool thumb1_LSL_imm(Imm5 imm5, Reg m, Reg d) { u8 shift_n = imm5; // LSLS , , # auto cpsr_c = ir.GetCFlag(); @@ -25,8 +31,9 @@ public: ir.SetNFlag(ir.MostSignificantBit(result.result)); ir.SetZFlag(ir.IsZero(result.result)); ir.SetCFlag(result.carry); + return true; } - void thumb1_LSR_imm(Imm5 imm5, Reg m, Reg d) { + bool thumb1_LSR_imm(Imm5 imm5, Reg m, Reg d) { u8 shift_n = imm5 != 0 ? imm5 : 32; // LSRS , , # auto cpsr_c = ir.GetCFlag(); @@ -35,8 +42,9 @@ public: ir.SetNFlag(ir.MostSignificantBit(result.result)); ir.SetZFlag(ir.IsZero(result.result)); ir.SetCFlag(result.carry); + return true; } - void thumb1_ASR_imm(Imm5 imm5, Reg m, Reg d) { + bool thumb1_ASR_imm(Imm5 imm5, Reg m, Reg d) { u8 shift_n = imm5 != 0 ? imm5 : 32; // ASRS , , # auto cpsr_c = ir.GetCFlag(); @@ -45,8 +53,10 @@ public: ir.SetNFlag(ir.MostSignificantBit(result.result)); ir.SetZFlag(ir.IsZero(result.result)); ir.SetCFlag(result.carry); + return true; } - void thumb1_LSL_reg(Reg m, Reg d_n) { + + bool thumb1_LSL_reg(Reg m, Reg d_n) { const Reg d = d_n, n = d_n; // LSLS , auto shift_n = ir.LeastSignificantByte(ir.GetRegister(m)); @@ -56,8 +66,9 @@ public: ir.SetNFlag(ir.MostSignificantBit(result_carry.result)); ir.SetZFlag(ir.IsZero(result_carry.result)); ir.SetCFlag(result_carry.carry); + return true; } - void thumb1_LSR_reg(Reg m, Reg d_n) { + bool thumb1_LSR_reg(Reg m, Reg d_n) { const Reg d = d_n, n = d_n; // LSRS , auto shift_n = ir.LeastSignificantByte(ir.GetRegister(m)); @@ -67,8 +78,9 @@ public: ir.SetNFlag(ir.MostSignificantBit(result.result)); ir.SetZFlag(ir.IsZero(result.result)); ir.SetCFlag(result.carry); + return true; } - void thumb1_ASR_reg(Reg m, Reg d_n) { + bool thumb1_ASR_reg(Reg m, Reg d_n) { const Reg d = d_n, n = d_n; // ASRS , auto shift_n = ir.LeastSignificantByte(ir.GetRegister(m)); @@ -78,11 +90,73 @@ public: ir.SetNFlag(ir.MostSignificantBit(result.result)); ir.SetZFlag(ir.IsZero(result.result)); ir.SetCFlag(result.carry); + return true; } - - void thumb1_UDF() {} + bool thumb1_UDF() { + return false; + } }; +enum class ThumbInstSize { + Thumb16, Thumb32 +}; + +static std::tuple ReadThumbInstruction(u32 arm_pc, MemoryRead32FuncType memory_read_32) { + u32 first_part = (*memory_read_32)(arm_pc & 0xFFFFFFFC); + if ((arm_pc & 0x2) != 0) + first_part >>= 16; + first_part &= 0xFFFF; + + if ((first_part & 0xF800) != 0xE800 && (first_part & 0xF000) != 0xF000) { + // 16-bit thumb instruction + return std::make_tuple(first_part, ThumbInstSize::Thumb16); + } + + // 32-bit thumb instruction + + u32 second_part = (*memory_read_32)((arm_pc+2) & 0xFFFFFFFC); + if (((arm_pc+2) & 0x2) != 0) + second_part >>= 16; + second_part &= 0xFFFF; + + return std::make_tuple(static_cast((first_part << 16) | second_part), ThumbInstSize::Thumb32); +} + +IR::Block TranslateThumb(LocationDescriptor descriptor, MemoryRead32FuncType memory_read_32) { + TranslatorVisitor visitor{descriptor}; + + bool should_continue = true; + while (should_continue) { + const u32 arm_pc = visitor.ir.current_location.arm_pc; + + u32 thumb_instruction; + ThumbInstSize inst_size; + std::tie(thumb_instruction, inst_size) = ReadThumbInstruction(arm_pc, memory_read_32); + + if (inst_size == ThumbInstSize::Thumb16) { + auto decoder = DecodeThumb1(static_cast(thumb_instruction)); + if (decoder) { + should_continue = decoder->call(visitor, static_cast(thumb_instruction)); + } else { + should_continue = visitor.thumb1_UDF(); + } + } else { + /*auto decoder = DecodeThumb2(thumb_instruction); + if (decoder) { + should_continue = decoder->call(visitor, thumb_instruction); + } else { + should_continue = visitor.thumb2_UDF(); + }*/ + ASSERT_MSG(0, "Unimplemented"); + } + + visitor.ir.current_location.arm_pc += inst_size == ThumbInstSize::Thumb16 ? 2 : 4; + visitor.ir.block.cycle_count++; + } + + return visitor.ir.block; +} + } // namespace Arm } // namepsace Dynarmic diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 27431d3c..33042a3d 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,4 +1,4 @@ -include_directories(.) +include_directories(. ../src) set(SRCS arm/fuzz_thumb.cpp diff --git a/tests/arm/test_thumb_instructions.cpp b/tests/arm/test_thumb_instructions.cpp index 6fc2413a..feece5f5 100644 --- a/tests/arm/test_thumb_instructions.cpp +++ b/tests/arm/test_thumb_instructions.cpp @@ -6,54 +6,56 @@ #include -#include "backend_x64/emit_x64.h" #include "common/common_types.h" -#include "frontend/decoder/thumb1.h" -#include "frontend/translate_thumb.h" +#include "interface/interface.h" -struct TinyBlockOfCode : Gen::XCodeBlock { - TinyBlockOfCode() { - AllocCodeSpace(256); +std::array code_mem{}; + +u32 MemoryRead32(u32 vaddr) { + if (vaddr < code_mem.size() * sizeof(u32)) { + return code_mem[vaddr / sizeof(u32)]; } -}; + return vaddr; +} -void RunSingleThumbInstruction(u16 thumb_instruction, Dynarmic::BackendX64::JitState* jit_state_ptr) { - Dynarmic::Arm::TranslatorVisitor visitor; - auto decoder = Dynarmic::Arm::DecodeThumb1(thumb_instruction); - REQUIRE(!!decoder); - decoder->call(visitor, thumb_instruction); - - TinyBlockOfCode block_of_code; - Dynarmic::BackendX64::Routines routines; - Dynarmic::UserCallbacks callbacks{}; - Dynarmic::BackendX64::EmitX64 emitter(&block_of_code, &routines, callbacks); - - Dynarmic::BackendX64::CodePtr code = emitter.Emit({0, true, false}, visitor.ir.block); - routines.RunCode(jit_state_ptr, code, 1); +Dynarmic::UserCallbacks GetUserCallbacks() { + Dynarmic::UserCallbacks user_callbacks{}; + user_callbacks.MemoryRead32 = &MemoryRead32; + return user_callbacks; } TEST_CASE( "thumb: lsls r0, r1, #2", "[thumb]" ) { - Dynarmic::BackendX64::JitState jit_state; - jit_state.Reg[0] = 1; - jit_state.Reg[1] = 2; - jit_state.Cpsr = 0; + Dynarmic::Jit jit{GetUserCallbacks()}; + code_mem.fill({}); + code_mem[0] = 0x0088; // lsls r0, r1, #2 + code_mem[1] = 0xDE00; // udf #0 - RunSingleThumbInstruction(0x0088, &jit_state); + jit.Regs()[0] = 1; + jit.Regs()[1] = 2; + jit.Regs()[15] = 0; // PC = 0 + jit.Cpsr() = 0x00000030; // Thumb, User-mode - REQUIRE( jit_state.Reg[0] == 8 ); - REQUIRE( jit_state.Reg[1] == 2 ); - REQUIRE( jit_state.Cpsr == 0 ); + jit.Run(1); + + REQUIRE( jit.Regs()[0] == 8 ); + REQUIRE( jit.Regs()[1] == 2 ); + REQUIRE( jit.Cpsr() == 0x00000030 ); } TEST_CASE( "thumb: lsls r0, r1, #31", "[thumb]" ) { - Dynarmic::BackendX64::JitState jit_state; - jit_state.Reg[0] = 1; - jit_state.Reg[1] = 0xFFFFFFFF; - jit_state.Cpsr = 0; + Dynarmic::Jit jit{GetUserCallbacks()}; + code_mem.fill({}); + code_mem[0] = 0x07C8; // lsls r0, r1, #31 + code_mem[1] = 0xDE00; // udf #0 - RunSingleThumbInstruction(0x07C8, &jit_state); + jit.Regs()[0] = 1; + jit.Regs()[1] = 0xFFFFFFFF; + jit.Regs()[15] = 0; // PC = 0 + jit.Cpsr() = 0x00000030; // Thumb, User-mode - REQUIRE( jit_state.Reg[0] == 0x80000000 ); - REQUIRE( jit_state.Reg[1] == 0xffffffff ); - REQUIRE( jit_state.Cpsr == 0x20000000 ); + jit.Run(1); + + REQUIRE( jit.Regs()[0] == 0x80000000 ); + REQUIRE( jit.Regs()[1] == 0xffffffff ); + REQUIRE( jit.Cpsr() == 0x20000030 ); // C flag, Thumb, User-mode } diff --git a/tests/skyeye_interpreter/dyncom/arm_dyncom_dec.cpp b/tests/skyeye_interpreter/dyncom/arm_dyncom_dec.cpp index d161e76e..b311ab26 100644 --- a/tests/skyeye_interpreter/dyncom/arm_dyncom_dec.cpp +++ b/tests/skyeye_interpreter/dyncom/arm_dyncom_dec.cpp @@ -2,8 +2,8 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_dec.h" -#include "tests/skyeye_interpreter/skyeye_common/armsupp.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_dec.h" +#include "skyeye_interpreter/skyeye_common/armsupp.h" const InstructionSetEncodingItem arm_instruction[] = { { "vmla", 5, ARMVFP2, { 23, 27, 0x1C, 20, 21, 0x0, 9, 11, 0x5, 6, 6, 0, 4, 4, 0 }}, diff --git a/tests/skyeye_interpreter/dyncom/arm_dyncom_interpreter.cpp b/tests/skyeye_interpreter/dyncom/arm_dyncom_interpreter.cpp index b8732f92..63092da7 100644 --- a/tests/skyeye_interpreter/dyncom/arm_dyncom_interpreter.cpp +++ b/tests/skyeye_interpreter/dyncom/arm_dyncom_interpreter.cpp @@ -10,13 +10,13 @@ #include "common/common_types.h" #include "common/logging/log.h" -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_dec.h" -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_interpreter.h" -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.h" -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_run.h" -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" -#include "tests/skyeye_interpreter/skyeye_common/armsupp.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_dec.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_interpreter.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_thumb.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_run.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/armsupp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp.h" enum { COND = (1 << 0), @@ -3184,11 +3184,11 @@ static ARM_INST_PTR INTERPRETER_TRANSLATE(yield)(unsigned int inst, int index) // Floating point VFPv3 structures and instructions #define VFP_INTERPRETER_STRUCT -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" +#include "skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" #undef VFP_INTERPRETER_STRUCT #define VFP_INTERPRETER_TRANS -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" +#include "skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" #undef VFP_INTERPRETER_TRANS typedef ARM_INST_PTR (*transop_fp_t)(unsigned int, int); @@ -6859,7 +6859,7 @@ unsigned InterpreterMainLoop(ARMul_State* cpu) { } #define VFP_INTERPRETER_IMPL - #include "tests/skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" + #include "skyeye_interpreter/skyeye_common/vfp/vfpinstr.cpp" #undef VFP_INTERPRETER_IMPL END: diff --git a/tests/skyeye_interpreter/dyncom/arm_dyncom_run.h b/tests/skyeye_interpreter/dyncom/arm_dyncom_run.h index 5e0eb5f2..9c8b11bd 100644 --- a/tests/skyeye_interpreter/dyncom/arm_dyncom_run.h +++ b/tests/skyeye_interpreter/dyncom/arm_dyncom_run.h @@ -18,7 +18,7 @@ #pragma once -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" /** * Checks if the PC is being read, and if so, word-aligns it. diff --git a/tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.cpp b/tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.cpp index a2c1f9e9..2348bfa4 100644 --- a/tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.cpp +++ b/tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.cpp @@ -5,8 +5,8 @@ // We can provide simple Thumb simulation by decoding the Thumb instruction into its corresponding // ARM instruction, and using the existing ARM simulator. -#include "tests/skyeye_interpreter/dyncom/arm_dyncom_thumb.h" -#include "tests/skyeye_interpreter/skyeye_common/armsupp.h" +#include "skyeye_interpreter/dyncom/arm_dyncom_thumb.h" +#include "skyeye_interpreter/skyeye_common/armsupp.h" // Decode a 16bit Thumb instruction. The instruction is in the low 16-bits of the tinstr field, // with the following Thumb instruction held in the high 16-bits. Passing in two Thumb instructions diff --git a/tests/skyeye_interpreter/skyeye_common/armstate.cpp b/tests/skyeye_interpreter/skyeye_common/armstate.cpp index ad5f1fb6..4d38a142 100644 --- a/tests/skyeye_interpreter/skyeye_common/armstate.cpp +++ b/tests/skyeye_interpreter/skyeye_common/armstate.cpp @@ -4,8 +4,8 @@ #include #include "common/logging/log.h" -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp.h" namespace Common { inline u16 swap16(u16 data) {return (data >> 8) | (data << 8);} diff --git a/tests/skyeye_interpreter/skyeye_common/armstate.h b/tests/skyeye_interpreter/skyeye_common/armstate.h index e85eea9f..54063e43 100644 --- a/tests/skyeye_interpreter/skyeye_common/armstate.h +++ b/tests/skyeye_interpreter/skyeye_common/armstate.h @@ -22,7 +22,7 @@ #include "common/common_types.h" #include "interface/interface.h" -#include "tests/skyeye_interpreter/skyeye_common/arm_regformat.h" +#include "skyeye_interpreter/skyeye_common/arm_regformat.h" // Signal levels enum { diff --git a/tests/skyeye_interpreter/skyeye_common/armsupp.cpp b/tests/skyeye_interpreter/skyeye_common/armsupp.cpp index a1ff2022..34837d16 100644 --- a/tests/skyeye_interpreter/skyeye_common/armsupp.cpp +++ b/tests/skyeye_interpreter/skyeye_common/armsupp.cpp @@ -17,9 +17,9 @@ #include "common/logging/log.h" -#include "tests/skyeye_interpreter/skyeye_common/arm_regformat.h" -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" -#include "tests/skyeye_interpreter/skyeye_common/armsupp.h" +#include "skyeye_interpreter/skyeye_common/arm_regformat.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/armsupp.h" // Unsigned sum of absolute difference u8 ARMul_UnsignedAbsoluteDifference(u8 left, u8 right) diff --git a/tests/skyeye_interpreter/skyeye_common/vfp/vfp.cpp b/tests/skyeye_interpreter/skyeye_common/vfp/vfp.cpp index d804ea0a..cabb6d3c 100644 --- a/tests/skyeye_interpreter/skyeye_common/vfp/vfp.cpp +++ b/tests/skyeye_interpreter/skyeye_common/vfp/vfp.cpp @@ -23,9 +23,9 @@ #include "common/common_types.h" #include "common/logging/log.h" -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp.h" void VFPInit(ARMul_State* state) { diff --git a/tests/skyeye_interpreter/skyeye_common/vfp/vfp.h b/tests/skyeye_interpreter/skyeye_common/vfp/vfp.h index 6783f89c..f2ead61d 100644 --- a/tests/skyeye_interpreter/skyeye_common/vfp/vfp.h +++ b/tests/skyeye_interpreter/skyeye_common/vfp/vfp.h @@ -20,7 +20,7 @@ #pragma once -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" /* for references to cdp SoftFloat functions */ +#include "skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" /* for references to cdp SoftFloat functions */ #define VFP_DEBUG_UNTESTED(x) LOG_TRACE(Core_ARM11, "in func %s, " #x " untested", __FUNCTION__); #define CHECK_VFP_ENABLED diff --git a/tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h b/tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h index f31dffed..e2721661 100644 --- a/tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h +++ b/tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h @@ -34,8 +34,8 @@ #include #include "common/common_types.h" -#include "tests/skyeye_interpreter/skyeye_common/armstate.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" +#include "skyeye_interpreter/skyeye_common/armstate.h" +#include "skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" #define do_div(n, base) {n/=base;} diff --git a/tests/skyeye_interpreter/skyeye_common/vfp/vfpdouble.cpp b/tests/skyeye_interpreter/skyeye_common/vfp/vfpdouble.cpp index 1c33d418..f993f9bc 100644 --- a/tests/skyeye_interpreter/skyeye_common/vfp/vfpdouble.cpp +++ b/tests/skyeye_interpreter/skyeye_common/vfp/vfpdouble.cpp @@ -53,9 +53,9 @@ #include #include "common/logging/log.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" +#include "skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" static struct vfp_double vfp_double_default_qnan = { 2047, diff --git a/tests/skyeye_interpreter/skyeye_common/vfp/vfpsingle.cpp b/tests/skyeye_interpreter/skyeye_common/vfp/vfpsingle.cpp index 8b85b8da..5b8f498e 100644 --- a/tests/skyeye_interpreter/skyeye_common/vfp/vfpsingle.cpp +++ b/tests/skyeye_interpreter/skyeye_common/vfp/vfpsingle.cpp @@ -57,9 +57,9 @@ #include "common/common_types.h" #include "common/logging/log.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" -#include "tests/skyeye_interpreter/skyeye_common/vfp/vfp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp_helper.h" +#include "skyeye_interpreter/skyeye_common/vfp/asm_vfp.h" +#include "skyeye_interpreter/skyeye_common/vfp/vfp.h" static struct vfp_single vfp_single_default_qnan = { 255,