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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// See LICENSE for license details.
#ifndef _RISCV_PROCESSOR_H
#define _RISCV_PROCESSOR_H
#include "decode.h"
#include "config.h"
#include <cstring>
#include <vector>
#include <map>
class processor_t;
class mmu_t;
typedef reg_t (*insn_func_t)(processor_t*, insn_t, reg_t);
class sim_t;
class trap_t;
class extension_t;
class disassembler_t;
struct insn_desc_t
{
insn_bits_t match;
insn_bits_t mask;
insn_func_t rv32;
insn_func_t rv64;
};
struct commit_log_reg_t
{
reg_t addr;
reg_t data;
};
// architectural state of a RISC-V hart
struct state_t
{
void reset();
reg_t pc;
regfile_t<reg_t, NXPR, true> XPR;
regfile_t<freg_t, NFPR, false> FPR;
// control and status registers
reg_t mstatus;
reg_t mepc;
reg_t mbadaddr;
reg_t mtimecmp;
reg_t mscratch;
reg_t mcause;
reg_t minstret;
reg_t mie;
reg_t mip;
reg_t sepc;
reg_t sbadaddr;
reg_t sscratch;
reg_t stvec;
reg_t sptbr;
reg_t scause;
reg_t sutime_delta;
reg_t suinstret_delta;
reg_t tohost;
reg_t fromhost;
uint32_t fflags;
uint32_t frm;
bool serialized; // whether timer CSRs are in a well-defined state
reg_t load_reservation;
#ifdef RISCV_ENABLE_COMMITLOG
commit_log_reg_t log_reg_write;
#endif
};
// this class represents one processor in a RISC-V machine.
class processor_t
{
public:
processor_t(const char* isa, sim_t* sim, uint32_t id);
~processor_t();
void set_debug(bool value);
void set_histogram(bool value);
void reset(bool value);
void step(size_t n); // run for n cycles
void deliver_ipi(); // register an interprocessor interrupt
bool running() { return run; }
void set_csr(int which, reg_t val);
void raise_interrupt(reg_t which);
reg_t get_csr(int which);
mmu_t* get_mmu() { return mmu; }
state_t* get_state() { return &state; }
extension_t* get_extension() { return ext; }
bool supports_extension(unsigned char ext) {
return ext >= 'A' && ext <= 'Z' && ((cpuid >> (ext - 'A')) & 1);
}
void push_privilege_stack();
void pop_privilege_stack();
void yield_load_reservation() { state.load_reservation = (reg_t)-1; }
void update_histogram(size_t pc);
void register_insn(insn_desc_t);
void register_extension(extension_t*);
private:
sim_t* sim;
mmu_t* mmu; // main memory is always accessed via the mmu
extension_t* ext;
disassembler_t* disassembler;
state_t state;
reg_t cpuid;
uint32_t id;
int max_xlen;
int xlen;
bool run; // !reset
bool debug;
bool histogram_enabled;
std::vector<insn_desc_t> instructions;
std::map<size_t,size_t> pc_histogram;
static const size_t OPCODE_CACHE_SIZE = 8191;
insn_desc_t opcode_cache[OPCODE_CACHE_SIZE];
void check_timer();
void take_interrupt(); // take a trap if any interrupts are pending
void take_trap(trap_t& t, reg_t epc); // take an exception
void disasm(insn_t insn); // disassemble and print an instruction
friend class sim_t;
friend class mmu_t;
friend class extension_t;
void parse_isa_string(const char* isa);
void build_opcode_map();
void register_base_instructions();
insn_func_t decode_insn(insn_t insn);
};
reg_t illegal_instruction(processor_t* p, insn_t insn, reg_t pc);
#define REGISTER_INSN(proc, name, match, mask) \
extern reg_t rv32_##name(processor_t*, insn_t, reg_t); \
extern reg_t rv64_##name(processor_t*, insn_t, reg_t); \
proc->register_insn((insn_desc_t){match, mask, rv32_##name, rv64_##name});
#endif
|
