1 |
2 |
rockee |
#!/usr/bin/env python
|
2 |
|
|
# -*- coding: utf-8 -*-
|
3 |
|
|
"""
|
4 |
|
|
emulator.py
|
5 |
|
|
===========
|
6 |
|
|
|
7 |
|
|
An Emulator for MicroBlaze INA
|
8 |
|
|
|
9 |
|
|
:copyright: Copyright (c) 2010 Jian Luo
|
10 |
|
|
:author-email: jian.luo.cn(at_)gmail.com
|
11 |
|
|
:license: LGPL, see LICENSE for details
|
12 |
|
|
:revision: $Id: emulator.py 3 2010-11-21 07:17:00Z rockee $
|
13 |
|
|
"""
|
14 |
|
|
|
15 |
|
|
from random import randrange
|
16 |
|
|
from myhdl import *
|
17 |
|
|
|
18 |
|
|
operations = """
|
19 |
|
|
| ADD | Rd,Ra,Rb | 000000 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra
|
20 |
|
|
| RSUB | Rd,Ra,Rb | 000001 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + 1
|
21 |
|
|
| ADDC | Rd,Ra,Rb | 000010 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + C
|
22 |
|
|
| RSUBC | Rd,Ra,Rb | 000011 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + C
|
23 |
|
|
| ADDK | Rd,Ra,Rb | 000100 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra
|
24 |
|
|
| RSUBK | Rd,Ra,Rb | 000101 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + 1
|
25 |
|
|
| ADDKC | Rd,Ra,Rb | 000110 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + C
|
26 |
|
|
| RSUBKC | Rd,Ra,Rb | 000111 | Rd | Ra | Rb & 00000000000 | Rd := Rb + Ra + C
|
27 |
|
|
| CMP | Rd,Ra,Rb | 000101 | Rd | Ra | Rb & 00000000001 | Rd := Rb + Ra + 1
|
28 |
|
|
Rd[0] := 0 if (Rb >= Ra) else
|
29 |
|
|
Rd[0] := 1
|
30 |
|
|
| CMPU | Rd,Ra,Rb | 000101 | Rd | Ra | Rb & 00000000011 | Rd := Rb + Ra + 1 (unsigned)
|
31 |
|
|
Rd[0] := 0 if (Rb >= Ra, unsigned) else
|
32 |
|
|
Rd[0] := 1
|
33 |
|
|
| ADDI | Rd,Ra,Imm | 001000 | Rd | Ra | Imm | Rd := s(Imm) + Ra
|
34 |
|
|
| RSUBI | Rd,Ra,Imm | 001001 | Rd | Ra | Imm | Rd := s(Imm) + Ra + 1
|
35 |
|
|
| ADDIC | Rd,Ra,Imm | 001010 | Rd | Ra | Imm | Rd := s(Imm) + Ra + C
|
36 |
|
|
| RSUBIC | Rd,Ra,Imm | 001011 | Rd | Ra | Imm | Rd := s(Imm) + Ra + C
|
37 |
|
|
| ADDIK | Rd,Ra,Imm | 001100 | Rd | Ra | Imm | Rd := s(Imm) + Ra
|
38 |
|
|
| RSUBIK | Rd,Ra,Imm | 001101 | Rd | Ra | Imm | Rd := s(Imm) + Ra + 1
|
39 |
|
|
| ADDIKC | Rd,Ra,Imm | 001110 | Rd | Ra | Imm | Rd := s(Imm) + Ra + C
|
40 |
|
|
| RSUBIKC | Rd,Ra,Imm | 001111 | Rd | Ra | Imm | Rd := s(Imm) + Ra + C
|
41 |
|
|
#| MUL | Rd,Ra,Rb | 010000 | Rd | Ra | Rb & 00000000000 | Rd := Ra * Rb
|
42 |
|
|
#| MULH | Rd,Ra,Rb | 010000 | Rd | Ra | Rb & 00000000001 | Rd := (Ra * Rb) >> 32 (signed)
|
43 |
|
|
#| MULHU | Rd,Ra,Rb | 010000 | Rd | Ra | Rb & 00000000011 | Rd := (Ra * Rb) >> 32 (unsigned)
|
44 |
|
|
#| MULHSU | Rd,Ra,Rb | 010000 | Rd | Ra | Rb & 00000000010 | Rd := (Ra, signed * Rb, unsigned) >> 32 (signed)
|
45 |
|
|
#| BSRA | Rd,Ra,Rb | 010001 | Rd | Ra | Rb & 01000000000 | Rd := s(Ra >> Rb)
|
46 |
|
|
#| BSLL | Rd,Ra,Rb | 010001 | Rd | Ra | Rb & 10000000000 | Rd := (Ra << Rb) & 0
|
47 |
|
|
#| MULI | Rd,Ra,Imm | 011000 | Rd | Ra | Imm | Rd := Ra * s(Imm)
|
48 |
|
|
#| BSRLI | Rd,Ra,Imm | 011001 | Rd | Ra | 00000000000 & Imm5 | Rd := 0 & (Ra >> Imm5)
|
49 |
|
|
#| BSRAI | Rd,Ra,Imm | 011001 | Rd | Ra | 00000010000 & Imm5 | Rd := s(Ra >> Imm5)
|
50 |
|
|
#| BSLLI | Rd,Ra,Imm | 011001 | Rd | Ra | 00000100000 & Imm5 | Rd := (Ra << Imm5) & 0
|
51 |
|
|
#| IDIV | Rd,Ra,Rb | 010010 | Rd | Ra | Rb & 00000000000 | Rd := Rb/Ra
|
52 |
|
|
#| IDIVU | Rd,Ra,Rb | 010010 | Rd | Ra | Rb & 00000000010 | Rd := Rb/Ra, unsigned
|
53 |
|
|
#| TNEAGETD | Rd,Rb | 010011 | Rd | 00000 | Rb & 0N0TAE00000 | Rd := FSL Rb[28:31] (data read)
|
54 |
|
|
#MSR[FSL] := 1 if (FSL_S_Control = 1)
|
55 |
|
|
#MSR[C] := not FSL_S_Exists if N = 1
|
56 |
|
|
#| TNAPUTD | Ra,Rb | 010011 | 00000 | Ra | Rb & 0N0TA000000 | FSL Rb[28:31] := Ra (data write)
|
57 |
|
|
#MSR[C] := FSL_M_Full if N = 1
|
58 |
|
|
#| TNECAGETD | Rd,Rb | 010011 | Rd | 00000 | Rb & 0N1TAE00000 | Rd := FSL Rb[28:31] (control read)
|
59 |
|
|
#MSR[FSL] := 1 if (FSL_S_Control = 0)
|
60 |
|
|
#MSR[C] := not FSL_S_Exists if N = 1
|
61 |
|
|
#| TNCAPUTD | Ra,Rb | 010011 | 00000 | Ra | Rb & 0N1TA000000 | FSL Rb[28:31] := Ra (control write)
|
62 |
|
|
#MSR[C] := FSL_M_Full if N = 1
|
63 |
|
|
#Rd := Rb+Ra, float1
|
64 |
|
|
#FADD Rd,Ra,Rb 010110 Rd Ra Rb 00000000000
|
65 |
|
|
#Rd := Rb-Ra, float1
|
66 |
|
|
#FRSUB Rd,Ra,Rb 010110 Rd Ra Rb 00010000000
|
67 |
|
|
#Rd := Rb*Ra, float1
|
68 |
|
|
#FMUL Rd,Ra,Rb 010110 Rd Ra Rb 00100000000
|
69 |
|
|
#Rd := Rb/Ra, float1
|
70 |
|
|
#FDIV Rd,Ra,Rb 010110 Rd Ra Rb 00110000000
|
71 |
|
|
#Rd := 1 if (Rb = NaN or Ra = NaN, float1)
|
72 |
|
|
#FCMP.UN Rd,Ra,Rb 010110 Rd Ra Rb 01000000000
|
73 |
|
|
#else
|
74 |
|
|
#Rd := 0
|
75 |
|
|
#Rd := 1 if (Rb < Ra, float1) else
|
76 |
|
|
#FCMP.LT Rd,Ra,Rb 010110 Rd Ra Rb 01000010000
|
77 |
|
|
#Rd := 0
|
78 |
|
|
#Rd := 1 if (Rb = Ra, float1) else
|
79 |
|
|
#FCMP.EQ Rd,Ra,Rb 010110 Rd Ra Rb 01000100000
|
80 |
|
|
#Rd := 0
|
81 |
|
|
#Rd := 1 if (Rb <= Ra, float1) else
|
82 |
|
|
#FCMP.LE Rd,Ra,Rb 010110 Rd Ra Rb 01000110000
|
83 |
|
|
#Rd := 0
|
84 |
|
|
#Rd := 1 if (Rb > Ra, float1) else
|
85 |
|
|
#FCMP.GT Rd,Ra,Rb 010110 Rd Ra Rb 01001000000
|
86 |
|
|
#Rd := 0
|
87 |
|
|
#Rd := 1 if (Rb != Ra, float1) else
|
88 |
|
|
#FCMP.NE Rd,Ra,Rb 010110 Rd Ra Rb 01001010000
|
89 |
|
|
#Rd := 0
|
90 |
|
|
#Rd := 1 if (Rb >= Ra, float1) else
|
91 |
|
|
#FCMP.GE Rd,Ra,Rb 010110 Rd Ra Rb 01001100000
|
92 |
|
|
#Rd := 0
|
93 |
|
|
#Rd := float (Ra)1
|
94 |
|
|
#FLT Rd,Ra 010110 Rd Ra 0 01010000000
|
95 |
|
|
#Rd := int (Ra)1
|
96 |
|
|
#FINT Rd,Ra 010110 Rd Ra 0 01100000000
|
97 |
|
|
#Rd := sqrt (Ra)1
|
98 |
|
|
#FSQRT Rd,Ra 010110 Rd Ra 0 01110000000
|
99 |
|
|
#| TNEAGET | Rd,FSLx | 011011 | Rd | 00000 | 0N0TAE000000 & FSLx | Rd := FSLx (data read, blocking if N = 0)
|
100 |
|
|
#MSR[FSL] := 1 if (FSLx_S_Control = 1)
|
101 |
|
|
#MSR[C] := not FSLx_S_Exists if N = 1
|
102 |
|
|
#| TNAPUT | Ra,FSLx | 011011 | 00000 | Ra | 1N0TA0000000 & FSLx | FSLx := Ra (data write, blocking if N = 0)
|
103 |
|
|
#MSR[C] := FSLx_M_Full if N = 1
|
104 |
|
|
#| TNECAGET | Rd,FSLx | 011011 | Rd | 00000 | 0N1TAE000000 & FSLx | Rd := FSLx (control read, blocking if N = 0)
|
105 |
|
|
#MSR[FSL] := 1 if (FSLx_S_Control = 0)
|
106 |
|
|
#MSR[C] := not FSLx_S_Exists if N = 1
|
107 |
|
|
#| TNCAPUT | Ra,FSLx | 011011 | 00000 | Ra | 1N1TA0000000 & FSLx | FSLx := Ra (control write, blocking if N = 0)
|
108 |
|
|
#MSR[C] := FSLx_M_Full if N = 1
|
109 |
|
|
| OR | Rd,Ra,Rb | 100000 | Rd | Ra | Rb & 00000000000 | Rd := Ra or Rb
|
110 |
|
|
| AND | Rd,Ra,Rb | 100001 | Rd | Ra | Rb & 00000000000 | Rd := Ra and Rb
|
111 |
|
|
| XOR | Rd,Ra,Rb | 100010 | Rd | Ra | Rb & 00000000000 | Rd := Ra xor Rb
|
112 |
|
|
| ANDN | Rd,Ra,Rb | 100011 | Rd | Ra | Rb & 00000000000 | Rd := Ra and Rb
|
113 |
|
|
#| PCMPBF | Rd,Ra,Rb | 100000 | Rd | Ra | Rb & 10000000000 | Rd := 1 if (Rb[0:7] = Ra[0:7]) else
|
114 |
|
|
Rd := 2 if (Rb[8:15] = Ra[8:15]) else
|
115 |
|
|
Rd := 3 if (Rb[16:23] = Ra[16:23]) else
|
116 |
|
|
Rd := 4 if (Rb[24:31] = Ra[24:31]) else
|
117 |
|
|
Rd := 0
|
118 |
|
|
#PCMPEQ Rd,Ra,Rb 100010 Rd Ra Rb 10000000000 Rd := 1 if (Rd = Ra) else
|
119 |
|
|
#Rd := 0
|
120 |
|
|
#PCMPNE Rd,Ra,Rb 100011 Rd Ra Rb 10000000000 Rd := 1 if (Rd != Ra) else
|
121 |
|
|
#Rd := 0
|
122 |
|
|
| SRA | Rd,Ra | 100100 | Rd | Ra | 0000000000000001 | Rd := s(Ra >> 1)
|
123 |
|
|
C := Ra[31]
|
124 |
|
|
| SRC | Rd,Ra | 100100 | Rd | Ra | 0000000000100001 | Rd := C & (Ra >> 1)
|
125 |
|
|
C := Ra[31]
|
126 |
|
|
| SRL | Rd,Ra | 100100 | Rd | Ra | 0000000001000001 | Rd := 0 & (Ra >> 1)
|
127 |
|
|
C := Ra[31]
|
128 |
|
|
|
129 |
|
|
|
130 |
|
|
| SEXT8 | Rd,Ra | 100100 | Rd | Ra | 0000000001100000 | Rd := s(Ra[24:31])
|
131 |
|
|
| SEXT16 | Rd,Ra | 100100 | Rd | Ra | 0000000001100001 | Rd := s(Ra[16:31])
|
132 |
|
|
|
133 |
|
|
#WIC Ra,Rb 100100 00000 Ra Rb 01101000 ICache_Line[Ra >> 4].Tag := 0 if
|
134 |
|
|
#(C_ICACHE_LINE_LEN = 4)
|
135 |
|
|
#ICache_Line[Ra >> 5].Tag := 0 if
|
136 |
|
|
#(C_ICACHE_LINE_LEN = 8)
|
137 |
|
|
#WDC Ra,Rb 100100 00000 Ra Rb 01100100 DCache_Line[Ra >> 4].Tag := 0 if
|
138 |
|
|
#(C_DCACHE_LINE_LEN = 4)
|
139 |
|
|
#DCache_Line[Ra >> 5].Tag := 0 if
|
140 |
|
|
#(C_DCACHE_LINE_LEN = 8)
|
141 |
|
|
#| MTS | Sd,Ra | 100101 | 00000 | Ra | 11 & Sd | SPR[Sd] := Ra, where:
|
142 |
|
|
#• SPR[0x0001] is MSR
|
143 |
|
|
#• SPR[0x0007] is FSR
|
144 |
|
|
#• SPR[0x1000] is PID
|
145 |
|
|
#• SPR[0x1001] is ZPR
|
146 |
|
|
#• SPR[0x1002] is TLBX
|
147 |
|
|
#• SPR[0x1003] is TLBLO
|
148 |
|
|
#• SPR[0x1004] is TLBHI
|
149 |
|
|
#• SPR[0x1005] is TLBSX
|
150 |
|
|
#| MFS | Rd,Sa | 100101 | Rd | 00000 | 10 & Sa | Rd := SPR[Sa], where:
|
151 |
|
|
#• SPR[0x0000] is PC
|
152 |
|
|
#• SPR[0x0001] is MSR
|
153 |
|
|
#• SPR[0x0003] is EAR
|
154 |
|
|
#• SPR[0x0005] is ESR
|
155 |
|
|
#• SPR[0x0007] is FSR
|
156 |
|
|
#• SPR[0x000B] is BTR
|
157 |
|
|
#• SPR[0x000D] is EDR
|
158 |
|
|
#• SPR[0x1000] is PID
|
159 |
|
|
#• SPR[0x1001] is ZPR
|
160 |
|
|
#• SPR[0x1002] is TLBX
|
161 |
|
|
#• SPR[0x1003] is TLBLO
|
162 |
|
|
#• SPR[0x1004] is TLBHI
|
163 |
|
|
#• SPR[0x2000 to 0x200B] is PVR[0 to 11]
|
164 |
|
|
#| MSRCLR | Rd,Imm | 100101 | Rd | 00001 | 00 & Imm14 | Rd := MSR
|
165 |
|
|
#MSR := MSR and Imm14
|
166 |
|
|
#| MSRSET | Rd,Imm | 100101 | Rd | 00000 | 00 & Imm14 | Rd := MSR
|
167 |
|
|
#MSR := MSR or Imm14
|
168 |
|
|
| BR | Rb | 100110 | 00000 | 00000 | Rb & 00000000000 | PC := PC + Rb
|
169 |
|
|
| BRD | Rb | 100110 | 00000 | 10000 | Rb & 00000000000 | PC := PC + Rb
|
170 |
|
|
| BRLD | Rd,Rb | 100110 | Rd | 10100 | Rb & 00000000000 | PC := PC + Rb
|
171 |
|
|
Rd := PC
|
172 |
|
|
| BRA | Rb | 100110 | 00000 | 01000 | Rb & 00000000000 | PC := Rb
|
173 |
|
|
| BRAD | Rb | 100110 | 00000 | 11000 | Rb & 00000000000 | PC := Rb
|
174 |
|
|
| BRALD | Rd,Rb | 100110 | Rd | 11100 | Rb & 00000000000 | PC := Rb
|
175 |
|
|
Rd := PC
|
176 |
|
|
| BRK | Rd,Rb | 100110 | Rd | 01100 | Rb & 00000000000 | PC := Rb
|
177 |
|
|
Rd := PC
|
178 |
|
|
MSR[BIP] := 1
|
179 |
|
|
| BEQ | Ra,Rb | 100111 | 00000 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra = 0
|
180 |
|
|
| BNE | Ra,Rb | 100111 | 00001 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra != 0
|
181 |
|
|
| BLT | Ra,Rb | 100111 | 00010 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra < 0
|
182 |
|
|
| BLE | Ra,Rb | 100111 | 00011 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra <= 0
|
183 |
|
|
| BGT | Ra,Rb | 100111 | 00100 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra > 0
|
184 |
|
|
| BGE | Ra,Rb | 100111 | 00101 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra >= 0
|
185 |
|
|
| BEQD | Ra,Rb | 100111 | 10000 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra = 0
|
186 |
|
|
| BNED | Ra,Rb | 100111 | 10001 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra != 0
|
187 |
|
|
| BLTD | Ra,Rb | 100111 | 10010 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra < 0
|
188 |
|
|
| BLED | Ra,Rb | 100111 | 10011 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra <= 0
|
189 |
|
|
| BGTD | Ra,Rb | 100111 | 10100 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra > 0
|
190 |
|
|
| BGED | Ra,Rb | 100111 | 10101 | Ra | Rb & 00000000000 | PC := PC + Rb if Ra >= 0
|
191 |
|
|
| ORI | Rd,Ra,Imm | 101000 | Rd | Ra | Imm | Rd := Ra or s(Imm)
|
192 |
|
|
| ANDI | Rd,Ra,Imm | 101001 | Rd | Ra | Imm | Rd := Ra and s(Imm)
|
193 |
|
|
| XORI | Rd,Ra,Imm | 101010 | Rd | Ra | Imm | Rd := Ra xor s(Imm)
|
194 |
|
|
| ANDNI | Rd,Ra,Imm | 101011 | Rd | Ra | Imm | Rd := Ra and s(Imm)
|
195 |
|
|
|
196 |
|
|
|
197 |
|
|
| IMM | Imm | 101100 | 00000 | 00000 | Imm | Imm[0:15] := Imm
|
198 |
|
|
| RTSD | Ra,Imm | 101101 | 10000 | Ra | Imm | PC := Ra + s(Imm)
|
199 |
|
|
| RTID | Ra,Imm | 101101 | 10001 | Ra | Imm | PC := Ra + s(Imm)
|
200 |
|
|
MSR[IE] := 1
|
201 |
|
|
| RTBD | Ra,Imm | 101101 | 10010 | Ra | Imm | PC := Ra + s(Imm)
|
202 |
|
|
MSR[BIP] := 0
|
203 |
|
|
| RTED | Ra,Imm | 101101 | 10100 | Ra | Imm | PC := Ra + s(Imm)
|
204 |
|
|
MSR[EE] := 1, MSR[EIP] := 0
|
205 |
|
|
ESR := 0
|
206 |
|
|
| BRI | Imm | 101110 | 00000 | 00000 | Imm | PC := PC + s(Imm)
|
207 |
|
|
| BRID | Imm | 101110 | 00000 | 10000 | Imm | PC := PC + s(Imm)
|
208 |
|
|
| BRLID | Rd,Imm | 101110 | Rd | 10100 | Imm | PC := PC + s(Imm)
|
209 |
|
|
Rd := PC
|
210 |
|
|
| BRAI | Imm | 101110 | 00000 | 01000 | Imm | PC := s(Imm)
|
211 |
|
|
| BRAID | Imm | 101110 | 00000 | 11000 | Imm | PC := s(Imm)
|
212 |
|
|
| BRALID | Rd,Imm | 101110 | Rd | 11100 | Imm | PC := s(Imm)
|
213 |
|
|
Rd := PC
|
214 |
|
|
| BRKI | Rd,Imm | 101110 | Rd | 01100 | Imm | PC := s(Imm)
|
215 |
|
|
Rd := PC
|
216 |
|
|
MSR[BIP] := 1
|
217 |
|
|
| BEQI | Ra,Imm | 101111 | 00000 | Ra | Imm | PC := PC + s(Imm) if Ra = 0
|
218 |
|
|
| BNEI | Ra,Imm | 101111 | 00001 | Ra | Imm | PC := PC + s(Imm) if Ra != 0
|
219 |
|
|
| BLTI | Ra,Imm | 101111 | 00010 | Ra | Imm | PC := PC + s(Imm) if Ra < 0
|
220 |
|
|
| BLEI | Ra,Imm | 101111 | 00011 | Ra | Imm | PC := PC + s(Imm) if Ra <= 0
|
221 |
|
|
| BGTI | Ra,Imm | 101111 | 00100 | Ra | Imm | PC := PC + s(Imm) if Ra > 0
|
222 |
|
|
| BGEI | Ra,Imm | 101111 | 00101 | Ra | Imm | PC := PC + s(Imm) if Ra >= 0
|
223 |
|
|
| BEQID | Ra,Imm | 101111 | 10000 | Ra | Imm | PC := PC + s(Imm) if Ra = 0
|
224 |
|
|
| BNEID | Ra,Imm | 101111 | 10001 | Ra | Imm | PC := PC + s(Imm) if Ra != 0
|
225 |
|
|
| BLTID | Ra,Imm | 101111 | 10010 | Ra | Imm | PC := PC + s(Imm) if Ra < 0
|
226 |
|
|
| BLEID | Ra,Imm | 101111 | 10011 | Ra | Imm | PC := PC + s(Imm) if Ra <= 0
|
227 |
|
|
| BGTID | Ra,Imm | 101111 | 10100 | Ra | Imm | PC := PC + s(Imm) if Ra > 0
|
228 |
|
|
| BGEID | Ra,Imm | 101111 | 10101 | Ra | Imm | PC := PC + s(Imm) if Ra >= 0
|
229 |
|
|
| LBU | Rd,Ra,Rb | 110000 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
230 |
|
|
Rd[0:23] := 0
|
231 |
|
|
Rd[24:31] := *Addr[0:7]
|
232 |
|
|
| LHU | Rd,Ra,Rb | 110001 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
233 |
|
|
Rd[0:15] := 0
|
234 |
|
|
Rd[16:31] := *Addr[0:15]
|
235 |
|
|
| LW | Rd,Ra,Rb | 110010 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
236 |
|
|
Rd := *Addr
|
237 |
|
|
| SB | Rd,Ra,Rb | 110100 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
238 |
|
|
*Addr[0:8] := Rd[24:31]
|
239 |
|
|
| SH | Rd,Ra,Rb | 110101 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
240 |
|
|
*Addr[0:16] := Rd[16:31]
|
241 |
|
|
| SW | Rd,Ra,Rb | 110110 | Rd | Ra | Rb & 00000000000 | Addr := Ra + Rb
|
242 |
|
|
*Addr := Rd
|
243 |
|
|
| LBUI | Rd,Ra,Imm | 111000 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
244 |
|
|
Rd[0:23] := 0
|
245 |
|
|
Rd[24:31] := *Addr[0:7]
|
246 |
|
|
| LHUI | Rd,Ra,Imm | 111001 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
247 |
|
|
Rd[0:15] := 0
|
248 |
|
|
Rd[16:31] := *Addr[0:15]
|
249 |
|
|
| LWI | Rd,Ra,Imm | 111010 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
250 |
|
|
Rd := *Addr
|
251 |
|
|
| SBI | Rd,Ra,Imm | 111100 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
252 |
|
|
*Addr[0:7] := Rd[24:31]
|
253 |
|
|
| SHI | Rd,Ra,Imm | 111101 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
254 |
|
|
*Addr[0:15] := Rd[16:31]
|
255 |
|
|
| SWI | Rd,Ra,Imm | 111110 | Rd | Ra | Imm | Addr := Ra + s(Imm)
|
256 |
|
|
*Addr := Rd
|
257 |
|
|
"""
|
258 |
|
|
|
259 |
|
|
OPC_SFT = 26
|
260 |
|
|
OPC_MSK = 0x3f
|
261 |
|
|
REG_MSK = 0x1f
|
262 |
|
|
RD_SFT = 21
|
263 |
|
|
RA_SFT = 16
|
264 |
|
|
RB_SFT = 11
|
265 |
|
|
IMM_MSK = 0xffff
|
266 |
|
|
|
267 |
|
|
# mask
|
268 |
|
|
OPC_IMM = 0x08
|
269 |
|
|
ADDSUB_K = 0x04
|
270 |
|
|
ADDSUB_C = 0x02
|
271 |
|
|
SUB_CMP = 0x01
|
272 |
|
|
SUB_CMPU = 0x02
|
273 |
|
|
|
274 |
|
|
import sys
|
275 |
|
|
|
276 |
|
|
QUIET=1
|
277 |
|
|
def log(string, params, file=sys.stdout):
|
278 |
|
|
if QUIET:
|
279 |
|
|
return
|
280 |
|
|
params.update(
|
281 |
|
|
rd = params['r'][params['d']],
|
282 |
|
|
ra = params['r'][params['a']],
|
283 |
|
|
rb = params['r'][params['b']],
|
284 |
|
|
)
|
285 |
|
|
print >>file, string.format(**params)
|
286 |
|
|
|
287 |
|
|
def log_gpr(params, file=sys.stdout):
|
288 |
|
|
if QUIET:
|
289 |
|
|
return
|
290 |
|
|
print >>file, '\tGPRF:\t',
|
291 |
|
|
for i, v in enumerate(params['r']):
|
292 |
|
|
print >>file, '%8x' % v,
|
293 |
|
|
if i%8 == 7:
|
294 |
|
|
print >>file, '\n\t\t',
|
295 |
|
|
print >>file, ''
|
296 |
|
|
|
297 |
|
|
def log_spr(params, file=sys.stdout):
|
298 |
|
|
if QUIET:
|
299 |
|
|
#print '{pc:x}'.format(**params)
|
300 |
|
|
return
|
301 |
|
|
|
302 |
|
|
print >>file, '{steps}:\tPC={pc:#x}\tCarry={m[0]:d}'.format(**params)
|
303 |
|
|
|
304 |
|
|
__max = 0x7fffffff
|
305 |
|
|
__min = 0x80000000
|
306 |
|
|
|
307 |
|
|
def _signed32(v):
|
308 |
|
|
return (v & __max) - (v & __min)
|
309 |
|
|
|
310 |
|
|
def _signed16(v):
|
311 |
|
|
return (v % (2**15)) - (v & (1<<15))
|
312 |
|
|
|
313 |
|
|
_umax = 0xffffffff
|
314 |
|
|
_max = _signed32(__max)
|
315 |
|
|
_min = _signed32(__min)
|
316 |
|
|
|
317 |
|
|
class MyBlazeEmulator(object):
|
318 |
|
|
|
319 |
|
|
def __init__(self, filename='rom.vmem'):
|
320 |
|
|
ram = read_vmem(filename)
|
321 |
|
|
print 'size=%d' % len(ram)
|
322 |
|
|
fetch(ram, max_steps=1000)
|
323 |
|
|
|
324 |
|
|
def addi(d, a, i, k, c, r, m, **kw):
|
325 |
|
|
x = _signed32(r[a]) + _signed32(i) + (bool(c) & m[0])
|
326 |
|
|
r[d] = _signed32(x)
|
327 |
|
|
m[0] = m[0] if k else not (_min <= x <= _max)
|
328 |
|
|
|
329 |
|
|
def add(b, r, i=None, **kw):
|
330 |
|
|
addi(i=r[b], r=r, **kw)
|
331 |
|
|
|
332 |
|
|
def rsubi(d, a, i, k, c, r, m, **kw):
|
333 |
|
|
x = _signed32(i) - _signed32(r[a]) - (bool(c) & m[0])
|
334 |
|
|
r[d] = _signed32(x)
|
335 |
|
|
m[0] = m[0] if k else not (_min <= x <= _max)
|
336 |
|
|
|
337 |
|
|
def rsub(b, r, i=None, **kw):
|
338 |
|
|
rsubi(i=r[b], r=r, **kw)
|
339 |
|
|
|
340 |
|
|
def cmp(d, a, b, u, r, m, **kw):
|
341 |
|
|
rsub(d=d, a=a, b=b, k=True, c=False, r=r, m=m, **kw)
|
342 |
|
|
#if u:
|
343 |
|
|
#if (r[a] & _umax) > (r[b] & _umax):
|
344 |
|
|
#r[d] |= __min
|
345 |
|
|
#else:
|
346 |
|
|
#r[d] &= __max
|
347 |
|
|
#r[d] = _signed32(r[d])
|
348 |
|
|
if u and (r[a] & __min) ^ (r[b] & __min):
|
349 |
|
|
msb = r[a] & __min
|
350 |
|
|
r[d] = _signed32((r[d]&__max) | msb)
|
351 |
|
|
|
352 |
|
|
def sra(d, a, r, m, **kw):
|
353 |
|
|
msb = (bool(r[a]&__min)) << 31
|
354 |
|
|
m[0] = r[d] & 1
|
355 |
|
|
r[d] = _signed32(msb | (r[d] >> 1))
|
356 |
|
|
|
357 |
|
|
def src(d, r, m, **kw):
|
358 |
|
|
msb = m[0] << 31
|
359 |
|
|
m[0] = r[d] & 1
|
360 |
|
|
r[d] = _signed32(msb | (r[d] >> 1))
|
361 |
|
|
|
362 |
|
|
def srl(d, r, m, **kw):
|
363 |
|
|
m[0] = r[d] & 1
|
364 |
|
|
r[d] = _signed32((r[d] >> 1))
|
365 |
|
|
|
366 |
|
|
def sext8(d, a, r, **kw):
|
367 |
|
|
if (r[a] & 0x80):
|
368 |
|
|
r[d] = _signed32(0xffffff00 | r[a])
|
369 |
|
|
else:
|
370 |
|
|
r[d] = _signed32(0xff & r[a])
|
371 |
|
|
|
372 |
|
|
def sext16(d, a, r, **kw):
|
373 |
|
|
if (r[a] & 0x8000):
|
374 |
|
|
r[d] = _signed32(0xffff0000 | r[a])
|
375 |
|
|
else:
|
376 |
|
|
r[d] = _signed32(0xffff & r[a])
|
377 |
|
|
|
378 |
|
|
def bri(d, i, ab, ln, pc, r, **kw):
|
379 |
|
|
if ln:
|
380 |
|
|
r[d] = pc
|
381 |
|
|
return i if ab else pc + i
|
382 |
|
|
|
383 |
|
|
def br(b, r, i=None, **kw):
|
384 |
|
|
return bri(i=r[b], r=r, **kw)
|
385 |
|
|
|
386 |
|
|
def logici(d, a, i, op, r, **kw):
|
387 |
|
|
ra = r[a]
|
388 |
|
|
r[d] = _signed32([ra | i, ra & i, ra ^ i, ~ra & i][op])
|
389 |
|
|
|
390 |
|
|
def logic(b, r, i=None, **kw):
|
391 |
|
|
logici(i=r[b], r=r, **kw)
|
392 |
|
|
|
393 |
|
|
def bcci(a, i, op, pc, r, **kw):
|
394 |
|
|
ra = _signed32(r[a])
|
395 |
|
|
branch = [ra == 0,
|
396 |
|
|
ra != 0,
|
397 |
|
|
ra < 0,
|
398 |
|
|
ra <= 0,
|
399 |
|
|
ra > 0,
|
400 |
|
|
ra >= 0][op]
|
401 |
|
|
return pc+i if branch else None
|
402 |
|
|
|
403 |
|
|
def bcc(b, r, i=None, **kw):
|
404 |
|
|
return bcc(i=r[b], r=r, **kw)
|
405 |
|
|
|
406 |
|
|
def loadi(d, a, i, op, r, ram, **kw):
|
407 |
|
|
addr = r[a] + i
|
408 |
|
|
if op == 0:
|
409 |
|
|
r[d] = ram[addr]
|
410 |
|
|
elif op == 1:
|
411 |
|
|
r[d] = (ram[addr]<<8) + ram[addr+1]
|
412 |
|
|
else:
|
413 |
|
|
r[d] = _signed32((ram[addr]<<24) +(ram[addr+1]<<16)
|
414 |
|
|
+(ram[addr+2]<<8) +ram[addr+3])
|
415 |
|
|
#print 'load@r[%d]: %s' % (d,r[d])
|
416 |
|
|
|
417 |
|
|
def load(b, r, i=None, **kw):
|
418 |
|
|
loadi(i=r[b], r=r, **kw)
|
419 |
|
|
|
420 |
|
|
def storei(d, a, i, op, r, ram, **kw):
|
421 |
|
|
addr = r[a] + i
|
422 |
|
|
if addr<0:
|
423 |
|
|
if addr == -64:
|
424 |
|
|
sys.stdout.write(chr(r[d] & 0xff))
|
425 |
|
|
sys.stdout.flush()
|
426 |
|
|
#else:
|
427 |
|
|
#print 'store@%#x <- r[%d]=%d' % (addr&_umax, d, r[d])
|
428 |
|
|
return
|
429 |
|
|
if op == 0:
|
430 |
|
|
ram[addr] = r[d] & 0xff
|
431 |
|
|
elif op == 1:
|
432 |
|
|
ram[addr] = (r[d] >> 8) & 0xff
|
433 |
|
|
ram[addr+1] = r[d] & 0xff
|
434 |
|
|
else:
|
435 |
|
|
ram[addr] = (r[d] >> 24) & 0xff
|
436 |
|
|
ram[addr+1] = (r[d] >> 16) & 0xff
|
437 |
|
|
ram[addr+2] = (r[d] >> 8) & 0xff
|
438 |
|
|
ram[addr+3] = r[d] & 0xff
|
439 |
|
|
|
440 |
|
|
def store(b, r, i=None, **kw):
|
441 |
|
|
storei(i=r[b], r=r, **kw)
|
442 |
|
|
|
443 |
|
|
def dec_store(opcode, **kw):
|
444 |
|
|
op = opcode & 0x03
|
445 |
|
|
kw.update(
|
446 |
|
|
op_name = ['sb', 'sh', 'sw'][op],
|
447 |
|
|
op = op,
|
448 |
|
|
)
|
449 |
|
|
if opcode & OPC_IMM:
|
450 |
|
|
storei(**kw)
|
451 |
|
|
log('\t\t{op_name}i\tr{d}({rd}), r{a}({ra}), {i}', kw)
|
452 |
|
|
else:
|
453 |
|
|
store(**kw)
|
454 |
|
|
log('\t\t{op_name}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
455 |
|
|
|
456 |
|
|
def dec_load(opcode, **kw):
|
457 |
|
|
op = opcode & 0x03
|
458 |
|
|
kw.update(
|
459 |
|
|
op_name = ['lbu', 'lhu', 'lw'][op],
|
460 |
|
|
op = op,
|
461 |
|
|
)
|
462 |
|
|
if opcode & OPC_IMM:
|
463 |
|
|
loadi(**kw)
|
464 |
|
|
log('\t\t{op_name}i\tr{d}({rd}), r{a}({ra}), {i}', kw)
|
465 |
|
|
else:
|
466 |
|
|
load(**kw)
|
467 |
|
|
log('\t\t{op_name}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
468 |
|
|
|
469 |
|
|
|
470 |
|
|
def dec_add(opcode, **kw):
|
471 |
|
|
kw.update(
|
472 |
|
|
k = ['','k'][bool(opcode & ADDSUB_K)],
|
473 |
|
|
c = ['','c'][bool(opcode & ADDSUB_C)],
|
474 |
|
|
)
|
475 |
|
|
if opcode & OPC_IMM:
|
476 |
|
|
addi(**kw)
|
477 |
|
|
log('\t\taddi{k}{c}\tr{d}({rd}), r{a}({ra}), {i}', kw)
|
478 |
|
|
else:
|
479 |
|
|
add(**kw)
|
480 |
|
|
log('\t\tadd{k}{c}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
481 |
|
|
|
482 |
|
|
def dec_sub(opcode, **kw):
|
483 |
|
|
i = kw['i']
|
484 |
|
|
kw.update(
|
485 |
|
|
k = ['','k'][bool(opcode & ADDSUB_K)],
|
486 |
|
|
c = ['','c'][bool(opcode & ADDSUB_C)],
|
487 |
|
|
u = ['','u'][bool(i & SUB_CMPU)],
|
488 |
|
|
)
|
489 |
|
|
if opcode & OPC_IMM:
|
490 |
|
|
rsubi(**kw)
|
491 |
|
|
log('\t\trsubi{k}{c}\tr{d}({rd}), r{a}({ra}), {i}', kw)
|
492 |
|
|
elif not i & SUB_CMP:
|
493 |
|
|
rsub(**kw)
|
494 |
|
|
log('\t\trsub{k}{c}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
495 |
|
|
else:
|
496 |
|
|
cmp(**kw)
|
497 |
|
|
log('\t\tcmp{u}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
498 |
|
|
|
499 |
|
|
def dec_logic(opcode, **kw):
|
500 |
|
|
op = opcode & 0x03
|
501 |
|
|
kw.update(
|
502 |
|
|
op=op,
|
503 |
|
|
op_name=['or', 'and', 'xor', 'andn'][op]
|
504 |
|
|
)
|
505 |
|
|
if opcode & OPC_IMM:
|
506 |
|
|
logici(**kw)
|
507 |
|
|
log('\t\t{op_name}i\tr{d}({rd}), r{a}({ra}), {i}', kw)
|
508 |
|
|
else:
|
509 |
|
|
logic(**kw)
|
510 |
|
|
log('\t\t{op_name}\tr{d}({rd}), r{a}({ra}), r{b}({rb})', kw)
|
511 |
|
|
|
512 |
|
|
EXT_MAPPING = dict(
|
513 |
|
|
sra = (0b0000001, 0b1111111, sra),
|
514 |
|
|
src = (0b0100001, 0b1111111, src),
|
515 |
|
|
srl = (0b1000001, 0b1111111, srl),
|
516 |
|
|
sext8 = (0b1100000, 0b1111111, sext8),
|
517 |
|
|
sext16= (0b1100001, 0b1111111, sext16),
|
518 |
|
|
)
|
519 |
|
|
|
520 |
|
|
def dec_extended(opcode, **kw):
|
521 |
|
|
i = kw['i']
|
522 |
|
|
for op_name, (value, mask, func) in EXT_MAPPING.items():
|
523 |
|
|
if (i & mask) == value:
|
524 |
|
|
func(**kw)
|
525 |
|
|
kw['op_name'] = op_name
|
526 |
|
|
log('\t\t{op_name}\tr{d}({rd}), r{a}({ra})', kw)
|
527 |
|
|
|
528 |
|
|
def dec_ret(**kw):
|
529 |
|
|
a = kw['a']
|
530 |
|
|
r = kw['r']
|
531 |
|
|
i = kw['i']
|
532 |
|
|
next = r[a] + i
|
533 |
|
|
log('\t\trtsd\tr{a}({ra}), {i}', kw)
|
534 |
|
|
return next, True
|
535 |
|
|
|
536 |
|
|
def dec_br(opcode, **kw):
|
537 |
|
|
a = kw['a']
|
538 |
|
|
dl = ['', 'd'][bool(a & 0b10000)]
|
539 |
|
|
kw.update(
|
540 |
|
|
ln = ['', 'l'][bool(a & 0b00100)],
|
541 |
|
|
ab = ['', 'a'][bool(a & 0b01000)],
|
542 |
|
|
dl = dl,
|
543 |
|
|
)
|
544 |
|
|
if opcode & OPC_IMM:
|
545 |
|
|
next = bri(**kw)
|
546 |
|
|
if kw['ln']:
|
547 |
|
|
log('\t\tbr{ab}li{dl}\tr{d}({rd}), {i}', kw)
|
548 |
|
|
else:
|
549 |
|
|
log('\t\tbr{ab}i{dl}\t{i}', kw)
|
550 |
|
|
else:
|
551 |
|
|
next = br(**kw)
|
552 |
|
|
if kw['ln']:
|
553 |
|
|
log('\t\tbr{ab}l{dl}\tr{d}({rd}), {i}', kw)
|
554 |
|
|
else:
|
555 |
|
|
log('\t\tbr{ab}{dl}\t{i}', kw)
|
556 |
|
|
return next, bool(dl)
|
557 |
|
|
|
558 |
|
|
def dec_bcc(opcode, **kw):
|
559 |
|
|
d = kw['d']
|
560 |
|
|
a = kw['a']
|
561 |
|
|
b = kw['b']
|
562 |
|
|
i = kw['i']
|
563 |
|
|
r = kw['r']
|
564 |
|
|
op = d & 0b111
|
565 |
|
|
dl = ['', 'd'][bool(d & 0b10000)]
|
566 |
|
|
kw.update(
|
567 |
|
|
op_name = ['beq', 'bne', 'blt', 'ble', 'bgt', 'bge'][op],
|
568 |
|
|
op = op,
|
569 |
|
|
dl = dl,
|
570 |
|
|
)
|
571 |
|
|
#print dl, d
|
572 |
|
|
if opcode & OPC_IMM:
|
573 |
|
|
next = bcci(**kw)
|
574 |
|
|
log('\t\t{op_name}i{dl}\tr{a}({ra}), {i}', kw)
|
575 |
|
|
else:
|
576 |
|
|
next = bcc(**kw)
|
577 |
|
|
log('\t\t{op_name}{dl}\tr{a}({ra}), r{b}({rb})', kw)
|
578 |
|
|
if next:
|
579 |
|
|
return next, bool(dl)
|
580 |
|
|
|
581 |
|
|
def dec_imm(i, imm, **kw):
|
582 |
|
|
imm[0] = i
|
583 |
|
|
kw.update(i=i)
|
584 |
|
|
log('\t\timm\t{i}', kw)
|
585 |
|
|
|
586 |
|
|
# value, mask
|
587 |
|
|
OPGROUP_MAPPING = dict(
|
588 |
|
|
DEC_ADD = ( 0b0, 0b110001, dec_add),
|
589 |
|
|
DEC_SUB = ( 0b1, 0b110001, dec_sub),
|
590 |
|
|
DEC_LOG = (0b100000, 0b110100, dec_logic),
|
591 |
|
|
DEC_IMM = (0b101100, 0b111111, dec_imm),
|
592 |
|
|
DEC_EXT = (0b100100, 0b111111, dec_extended),
|
593 |
|
|
DEC_RET = (0b101101, 0b111111, dec_ret),
|
594 |
|
|
DEC_BR = (0b100110, 0b110111, dec_br),
|
595 |
|
|
DEC_BCC = (0b100111, 0b110111, dec_bcc),
|
596 |
|
|
DEC_LD = (0b110000, 0b110100, dec_load),
|
597 |
|
|
DEC_ST = (0b110100, 0b110100, dec_store),
|
598 |
|
|
)
|
599 |
|
|
|
600 |
|
|
def decode(instruction, pc, r, m, imm, ram, steps):
|
601 |
|
|
opcode = (instruction >> OPC_SFT) & OPC_MSK
|
602 |
|
|
|
603 |
|
|
# Process immediate
|
604 |
|
|
i = instruction & IMM_MSK
|
605 |
|
|
if imm[0] is not None:
|
606 |
|
|
i += imm[0]<<16
|
607 |
|
|
imm[0] = None
|
608 |
|
|
i = _signed32(i)
|
609 |
|
|
else:
|
610 |
|
|
#if (i & 0x8000):
|
611 |
|
|
#i |= 0xffff0000
|
612 |
|
|
#else:
|
613 |
|
|
#i &= 0xffff
|
614 |
|
|
i = _signed16(i)
|
615 |
|
|
|
616 |
|
|
kw = dict(
|
617 |
|
|
instruction=instruction,
|
618 |
|
|
opcode = opcode,
|
619 |
|
|
d = (instruction >> RD_SFT) & REG_MSK,
|
620 |
|
|
a = (instruction >> RA_SFT) & REG_MSK,
|
621 |
|
|
b = (instruction >> RB_SFT) & REG_MSK,
|
622 |
|
|
i = i,
|
623 |
|
|
pc = pc,
|
624 |
|
|
r = r,
|
625 |
|
|
m = m,
|
626 |
|
|
imm = imm,
|
627 |
|
|
ram = ram,
|
628 |
|
|
steps = steps,
|
629 |
|
|
)
|
630 |
|
|
for value, mask, func in OPGROUP_MAPPING.values():
|
631 |
|
|
if (opcode & mask) == value:
|
632 |
|
|
log_spr(kw)
|
633 |
|
|
result = func(**kw)
|
634 |
|
|
log_gpr(kw)
|
635 |
|
|
return result
|
636 |
|
|
|
637 |
|
|
def fetch(ram, pc=0, max_steps=-1, single=False):
|
638 |
|
|
r = [0]*32 # gprf
|
639 |
|
|
m = [0]*32 # msr
|
640 |
|
|
imm = [None] # immediate
|
641 |
|
|
steps = 0
|
642 |
|
|
delayed = False
|
643 |
|
|
while steps != max_steps:
|
644 |
|
|
instruction = (ram[pc]<<24) +(ram[pc+1]<<16) +(ram[pc+2]<<8) +ram[pc+3]
|
645 |
|
|
kw = dict(
|
646 |
|
|
r=r,m=m,imm=imm,pc=pc,
|
647 |
|
|
ram=ram,
|
648 |
|
|
instruction=instruction,
|
649 |
|
|
steps=steps,
|
650 |
|
|
)
|
651 |
|
|
result = decode(**kw)
|
652 |
|
|
if result is not None:
|
653 |
|
|
next, delay = result
|
654 |
|
|
#print next, delay
|
655 |
|
|
|
656 |
|
|
if single:
|
657 |
|
|
raw_input('Press [Any-Key] to continue ;)')
|
658 |
|
|
steps += 1
|
659 |
|
|
|
660 |
|
|
if delayed:
|
661 |
|
|
pc = branch_target
|
662 |
|
|
delayed = False
|
663 |
|
|
#print 'delayed'
|
664 |
|
|
elif result is None:
|
665 |
|
|
pc += 4
|
666 |
|
|
delayed = False
|
667 |
|
|
#print 'normal'
|
668 |
|
|
elif delay:
|
669 |
|
|
pc += 4
|
670 |
|
|
delayed = True
|
671 |
|
|
branch_target = next
|
672 |
|
|
#print 'delay'
|
673 |
|
|
else:
|
674 |
|
|
pc = next
|
675 |
|
|
delayed = False
|
676 |
|
|
#print 'branch'
|
677 |
|
|
#print '%x, %s' % (pc, delay)
|
678 |
|
|
|
679 |
|
|
def read_vmem(filename, bank=4, width=8):
|
680 |
|
|
print filename
|
681 |
|
|
source = open(filename).readlines()
|
682 |
|
|
ram = []
|
683 |
|
|
for line in source:
|
684 |
|
|
value = int(line.strip(), 16)
|
685 |
|
|
for i in range(bank):
|
686 |
|
|
ram.append((value >> (width*(bank-1-i))) % (2**width))
|
687 |
|
|
return ram
|
688 |
|
|
|
689 |
|
|
|
690 |
|
|
|
691 |
|
|
import sys
|
692 |
|
|
if __name__ == '__main__':
|
693 |
|
|
MyBlazeEmulator(sys.argv[1])
|
694 |
|
|
|
695 |
|
|
### EOF ###
|
696 |
|
|
# vim:smarttab:sts=4:ts=4:sw=4:et:ai:tw=80:
|
697 |
|
|
|