1 // Copyright 2016 Citra Emulator Project
2 // Licensed under GPLv2 or any later version
3 // Refer to the license.txt file included.
4
5 #include "core/core.h"
6 #include "core/core_timing.h"
7 #include "core/hle/kernel/process.h"
8 #include "core/memory.h"
9 #include "tests/core/arm/arm_test_common.h"
10
11 namespace ArmTests {
12
13 static std::shared_ptr<Memory::PageTable> page_table = nullptr;
14
TestEnvironment(bool mutable_memory_)15 TestEnvironment::TestEnvironment(bool mutable_memory_)
16 : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
17
18 timing = std::make_unique<Core::Timing>(1, 100);
19 memory = std::make_unique<Memory::MemorySystem>();
20 kernel = std::make_unique<Kernel::KernelSystem>(
21 *memory, *timing, [] {}, 0, 1, 0);
22
23 kernel->SetCurrentProcess(kernel->CreateProcess(kernel->CreateCodeSet("", 0)));
24 page_table = kernel->GetCurrentProcess()->vm_manager.page_table;
25
26 page_table->Clear();
27
28 memory->MapIoRegion(*page_table, 0x00000000, 0x80000000, test_memory);
29 memory->MapIoRegion(*page_table, 0x80000000, 0x80000000, test_memory);
30
31 kernel->SetCurrentMemoryPageTable(page_table);
32 }
33
~TestEnvironment()34 TestEnvironment::~TestEnvironment() {
35 memory->UnmapRegion(*page_table, 0x80000000, 0x80000000);
36 memory->UnmapRegion(*page_table, 0x00000000, 0x80000000);
37 }
38
SetMemory64(VAddr vaddr,u64 value)39 void TestEnvironment::SetMemory64(VAddr vaddr, u64 value) {
40 SetMemory32(vaddr + 0, static_cast<u32>(value));
41 SetMemory32(vaddr + 4, static_cast<u32>(value >> 32));
42 }
43
SetMemory32(VAddr vaddr,u32 value)44 void TestEnvironment::SetMemory32(VAddr vaddr, u32 value) {
45 SetMemory16(vaddr + 0, static_cast<u16>(value));
46 SetMemory16(vaddr + 2, static_cast<u16>(value >> 16));
47 }
48
SetMemory16(VAddr vaddr,u16 value)49 void TestEnvironment::SetMemory16(VAddr vaddr, u16 value) {
50 SetMemory8(vaddr + 0, static_cast<u8>(value));
51 SetMemory8(vaddr + 1, static_cast<u8>(value >> 8));
52 }
53
SetMemory8(VAddr vaddr,u8 value)54 void TestEnvironment::SetMemory8(VAddr vaddr, u8 value) {
55 test_memory->data[vaddr] = value;
56 }
57
GetWriteRecords() const58 std::vector<WriteRecord> TestEnvironment::GetWriteRecords() const {
59 return write_records;
60 }
61
ClearWriteRecords()62 void TestEnvironment::ClearWriteRecords() {
63 write_records.clear();
64 }
65
~TestMemory()66 TestEnvironment::TestMemory::~TestMemory() {}
67
IsValidAddress(VAddr addr)68 bool TestEnvironment::TestMemory::IsValidAddress(VAddr addr) {
69 return true;
70 }
71
Read8(VAddr addr)72 u8 TestEnvironment::TestMemory::Read8(VAddr addr) {
73 auto iter = data.find(addr);
74 if (iter == data.end()) {
75 return addr; // Some arbitrary data
76 }
77 return iter->second;
78 }
79
Read16(VAddr addr)80 u16 TestEnvironment::TestMemory::Read16(VAddr addr) {
81 return Read8(addr) | static_cast<u16>(Read8(addr + 1)) << 8;
82 }
83
Read32(VAddr addr)84 u32 TestEnvironment::TestMemory::Read32(VAddr addr) {
85 return Read16(addr) | static_cast<u32>(Read16(addr + 2)) << 16;
86 }
87
Read64(VAddr addr)88 u64 TestEnvironment::TestMemory::Read64(VAddr addr) {
89 return Read32(addr) | static_cast<u64>(Read32(addr + 4)) << 32;
90 }
91
ReadBlock(VAddr src_addr,void * dest_buffer,std::size_t size)92 bool TestEnvironment::TestMemory::ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) {
93 VAddr addr = src_addr;
94 u8* data = static_cast<u8*>(dest_buffer);
95
96 for (std::size_t i = 0; i < size; i++, addr++, data++) {
97 *data = Read8(addr);
98 }
99
100 return true;
101 }
102
Write8(VAddr addr,u8 data)103 void TestEnvironment::TestMemory::Write8(VAddr addr, u8 data) {
104 env->write_records.emplace_back(8, addr, data);
105 if (env->mutable_memory)
106 env->SetMemory8(addr, data);
107 }
108
Write16(VAddr addr,u16 data)109 void TestEnvironment::TestMemory::Write16(VAddr addr, u16 data) {
110 env->write_records.emplace_back(16, addr, data);
111 if (env->mutable_memory)
112 env->SetMemory16(addr, data);
113 }
114
Write32(VAddr addr,u32 data)115 void TestEnvironment::TestMemory::Write32(VAddr addr, u32 data) {
116 env->write_records.emplace_back(32, addr, data);
117 if (env->mutable_memory)
118 env->SetMemory32(addr, data);
119 }
120
Write64(VAddr addr,u64 data)121 void TestEnvironment::TestMemory::Write64(VAddr addr, u64 data) {
122 env->write_records.emplace_back(64, addr, data);
123 if (env->mutable_memory)
124 env->SetMemory64(addr, data);
125 }
126
WriteBlock(VAddr dest_addr,const void * src_buffer,std::size_t size)127 bool TestEnvironment::TestMemory::WriteBlock(VAddr dest_addr, const void* src_buffer,
128 std::size_t size) {
129 VAddr addr = dest_addr;
130 const u8* data = static_cast<const u8*>(src_buffer);
131
132 for (std::size_t i = 0; i < size; i++, addr++, data++) {
133 env->write_records.emplace_back(8, addr, *data);
134 if (env->mutable_memory)
135 env->SetMemory8(addr, *data);
136 }
137
138 return true;
139 }
140
141 } // namespace ArmTests
142