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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
from .instructions import Instruction, InstructionSet
from ctypes import c_uint32
RV32I = InstructionSet()
class R(Instruction):
funct3 = None
funct7 = None
opcode = None
def __init__(self, rd, rs1, rs2):
self.rd = rd
self.rs1 = rs1
self.rs2 = rs2
def compile(self):
# TODO: ensure sizes and convert register names to number...
return c_uint32(
(self.funct7 << 25) +\
(self.rs2 << 20) +\
(self.rs1 << 15) +\
(self.funct3 << 12) +\
(self.rd << 7) +\
self.opcode
)
class I(Instruction):
funct3 = None
opcode = None
def __init__(self, rd, rs, imm):
self.rd = rd
self.rs = rs
self.imm = imm
def compile(self):
return c_uint32(
(self.imm << 20) +\
(self.rs << 15) +\
(self.funct3 << 12) +\
(self.rd << 7) +\
self.opcode
)
class S(Instruction):
funct3 = None
opcode = None
def __init__(self, rs1, rs2, imm):
self.rs1 = rs1
self.rs2 = rs2
self.imm = imm
def compile(self):
imm_0_4 = self.imm & 0x1F
imm_5_11 = (self.imm & 0xFE0)>>5
return c_uint32(
(imm_5_11 << 25) +\
(self.rs2 << 20) +\
(self.rs1 << 15) +\
(self.funct3 << 12) +\
(imm_0_4 << 7) +\
self.opcode
)
class B(Instruction):
funct3 = None
opcode = None
def __init__(self, rs1, rs2, imm):
self.rs1 = rs1
self.rs2 = rs2
self.imm = imm
def compile(self):
# NOTE: The lowest bit of the imm is always 0 because instructions
# are at least 16 bits wide, so it's not used, that's why this
# instruction looks that weird
imm_11 = (self.imm & 0b0100000000000)>>11
imm_12 = (self.imm & 0b1000000000000)>>12
imm_1_4 = (self.imm & 0b0000000011110)>>1
imm_5_10 = (self.imm & 0b0011111100000)>>5
return c_uint32(
(im_12 << 30) +\
(imm_5_10 << 25) +\
(self.rs2 << 20) +\
(self.rs1 << 15) +\
(self.funct3 << 12) +\
(imm_1_4 << 8) +\
(imm_11 << 7) +\
self.opcode
)
class U(Instruction):
opcode = None
def __init__(self, rd, imm):
self.rd = rd
self.imm = imm
def compile(self):
# NOTE: U Type is for AUIPC and LUI that only use the high part of the
# immediate
imm_12_32 = (imm & 0xFFFFF000)>>12
return c_uint32(
(self.imm_12_32 << 12) +\
(self.rd << 7) +\
self.opcode
)
class J(Instruction):
opcode = None
def __init__(self, rd, imm):
self.rd = rd
self.imm = imm
def compile(self):
# NOTE: Jumps are also weird
imm_12_19 = 0x0FF000
imm_11 = 0x000800
imm_1_10 = 0x0007FE
imm_20 = 0x100000
return c_uint32(
(self.imm_20 << 31) +\
(self.imm_1_10 << 21) +\
(self.imm_11 << 20) +\
(self.imm_12_19 << 12) +\
(self.rd << 7) +\
self.opcode
)
@RV32I.instruction
class lui(U):
name = "lui"
opcode = 0b0110111
@RV32I.instruction
class auipc(U):
name = "auipc"
opcode = 0b0010111
@RV32I.instruction
class jal(J):
name = "jal"
opcode = 0b1101111
def execute(self, pc):
# TODO
# - Save current pc in rd
# - Make pc from `imm`
# - Return new pc
return pc
@RV32I.instruction
class jalr(I):
name = "jalr"
opcode = 0b1100111
funct3 = 0b000
@RV32I.instruction
class beq(B):
name = "beq"
opcode = 0b1100011
funct3 = 0b000
@RV32I.instruction
class bne(B):
name = "bne"
opcode = 0b1100011
funct3 = 0b001
@RV32I.instruction
class blt(B):
name = "blt"
opcode = 0b1100011
funct3 = 0b100
@RV32I.instruction
class bge(B):
name = "bge"
opcode = 0b1100011
funct3 = 0b101
@RV32I.instruction
class bltu(B):
name = "bltu"
opcode = 0b1100011
funct3 = 0b110
@RV32I.instruction
class bgeu(B):
name = "bgeu"
opcode = 0b1100011
funct3 = 0b111
@RV32I.instruction
class lb(I):
name = "lb"
opcode = 0b0000011
funct3 = 0b000
@RV32I.instruction
class lh(I):
name = "lh"
opcode = 0b0000011
funct3 = 0b001
@RV32I.instruction
class lw(I):
name = "lw"
opcode = 0b0000011
funct3 = 0b010
@RV32I.instruction
class lbu(I):
name = "lbu"
opcode = 0b0000011
funct3 = 0b100
@RV32I.instruction
class lb(I):
name = "lhu"
opcode = 0b0000011
funct3 = 0b101
@RV32I.instruction
class sb(S):
name = "sb"
opcode = 0b010001
funct3 = 0b000
@RV32I.instruction
class sh(S):
name = "sh"
opcode = 0b010001
funct3 = 0b001
@RV32I.instruction
class sw(S):
name = "sw"
opcode = 0b010001
funct3 = 0b010
@RV32I.instruction
class addi(I):
name = "addi"
opcode = 0b0010011
funct3 = 0b000
def execute(self, pc):
# TODO
return pc + self.size
@RV32I.instruction
class slti(I):
name = "slti"
opcode = 0b0010011
funct3 = 0b010
@RV32I.instruction
class sltiu(I):
name = "sltiu"
opcode = 0b0010011
funct3 = 0b011
@RV32I.instruction
class xori(I):
name = "xori"
opcode = 0b0010011
funct3 = 0b100
@RV32I.instruction
class ori(I):
name = "ori"
opcode = 0b0010011
funct3 = 0b110
@RV32I.instruction
class andi(I):
name = "andi"
opcode = 0b0010011
funct3 = 0b111
@RV32I.instruction
class add(R):
name = "add"
opcode = 0b0110011
funct3 = 0b000
funct7 = 0b0000000
def execute(self, pc):
# TODO
return pc + self.size
@RV32I.pseudoinstruction
class j(J):
name = "j"
def __new__(cls, imm):
return jal("x0", imm)
if __name__ == "__main__":
print(RV32I)
print(RV32I.instructions)
|