1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
#pragma once
#include <algorithm>
#include <array>
#include <cstring>
#include <deque>
#include <map>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
#include "aisa/aisa.h"
namespace aisa {
template<unsigned int PAGE_BITS=20> struct PagedMem {
using page_t = std::array<byte_t, 1 << PAGE_BITS>;
static const addr_t PAGE_SIZE = 1 << PAGE_BITS;
static const addr_t PAGE_MASK = PAGE_SIZE - 1;
std::map<addr_t, page_t> pages;
bool fetch_mem(byte_t *bytes, addr_t addr, addr_t size)
{
if (size == 0)
return true;
auto page_base = addr >> PAGE_BITS;
auto page_offset = addr & PAGE_MASK;
auto size_here = std::min(size, PAGE_SIZE - page_offset);
if (auto page = pages.find(page_base); page != pages.end())
std::memcpy(bytes, page->second.data() + page_offset, size_here);
else
std::memset(bytes, 0, size_here);
return fetch_mem(bytes + size_here, addr + size_here, size - size_here);
}
bool store_mem(addr_t addr, const byte_t *bytes, addr_t size)
{
if (size == 0)
return true;
auto page_base = addr >> PAGE_BITS;
auto page_offset = addr & PAGE_MASK;
auto size_here = std::min(size, PAGE_SIZE - page_offset);
std::memcpy(pages[page_base].data() + page_offset, bytes, size_here);
return store_mem(addr + size_here, bytes + size_here, size - size_here);
}
};
struct TaskStack {
std::deque<std::unique_ptr<const Task>> tasks;
bool pop_task()
{
if (tasks.empty())
return false;
tasks.pop_back();
return true;
}
bool push_task(std::unique_ptr<const Task> &&task)
{
tasks.emplace_back(std::move(task));
return true;
}
std::optional<const Task *> top_task()
{
if (tasks.empty())
return {};
return tasks.back().get();
}
};
struct VectorRF {
std::vector<std::optional<regval_t>> rf;
std::optional<regval_t> load_reg(regnum_t rn) const
{
if (rf.size() <= rn)
return {};
return rf[rn];
}
bool store_reg(regnum_t rn, regval_t rv)
{
if (rf.size() <= rn)
rf.resize(rn + 1);
rf[rn] = rv;
return true;
}
};
}
|
