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
|
#include "id.h"
#include "accessor.h"
#include "instr.h"
#include "instrDTO.h"
#include "logger.h"
#include "response.h"
#include "stage.h"
ID::ID(Stage *stage) : Stage(stage) { this->id = DCDE; }
void ID::get_instr_fields(
signed int &s1, signed int &s2, signed int &s3, Mnemonic &m)
{
unsigned int type;
this->split_instr(s1, type, m);
switch (type) {
case 0b00:
this->decode_R_type(s1, s2, s3);
break;
case 0b01:
this->decode_I_type(s1, s2, s3);
break;
case 0b10:
this->decode_J_type(s1, s2);
break;
}
}
void ID::split_instr(signed int &raw, unsigned int &type, Mnemonic &m)
{
unsigned int opcode, opcode_size;
type = GET_LS_BITS(raw, TYPE_SIZE);
opcode_size = (type == 0b0) ? R_OPCODE_SIZE : OPCODE_SIZE;
opcode = GET_MID_BITS(raw, TYPE_SIZE, TYPE_SIZE + opcode_size);
try {
m = instr::mnemonic_map.at((opcode << TYPE_SIZE) + type);
} catch (std::out_of_range const &) {
m = NOP;
}
raw = (unsigned int)raw >> (TYPE_SIZE + opcode_size);
}
Response ID::read_guard(signed int &v)
{
Response r;
if (this->is_checked_out(v))
r = STALLED;
else {
r = OK;
v = this->dereference_register(v);
}
return r;
}
void ID::write_guard(signed int &v)
{
this->checked_out.push_back(v);
v = this->dereference_register(v);
}
void ID::advance_helper()
{
signed int s1, s2, s3;
Mnemonic m;
// it may be good to ensure we are not doing
// work that has already been done
if (this->curr_instr) {
s1 = curr_instr->get_instr_bits();
get_instr_fields(s1, s2, s3, m);
if (this->status == OK) {
curr_instr->set_s1(s1);
curr_instr->set_s2(s2);
curr_instr->set_s3(s3);
curr_instr->set_mnemonic(m);
}
}
}
void ID::decode_R_type(signed int &s1, signed int &s2, signed int &s3)
{
unsigned int s0b, s1b, s2b;
Response r1, r2;
s0b = REG_SIZE;
s1b = s0b + REG_SIZE;
s2b = s1b + REG_SIZE;
s3 = GET_MID_BITS(s1, s1b, s2b);
s2 = GET_MID_BITS(s1, s0b, s1b);
s1 = GET_LS_BITS(s1, s0b);
r1 = this->read_guard(s1);
r2 = this->read_guard(s2);
this->write_guard(s3);
this->status = (r1 == OK && r2 == OK) ? OK : STALLED;
}
void ID::decode_I_type(signed int &s1, signed int &s2, signed int &s3)
{
unsigned int s0b, s1b, s2b;
s0b = REG_SIZE;
s1b = s0b + REG_SIZE;
s2b = WORD_SPEC;
s3 = GET_MID_BITS(s1, s1b, s2b);
s2 = GET_MID_BITS(s1, s0b, s1b);
s1 = GET_LS_BITS(s1, s0b);
this->status = this->read_guard(s1);
this->write_guard(s2);
}
void ID::decode_J_type(signed int &s1, signed int &s2)
{
unsigned int s0b, s1b;
s0b = REG_SIZE;
s1b = WORD_SPEC;
s2 = GET_MID_BITS(s1, s0b, s1b);
s1 = GET_LS_BITS(s1, s0b);
this->status = this->read_guard(*&s1);
}
|
