OpenCores
URL https://opencores.org/ocsvn/thor/thor/trunk

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [emuThor/] [source/] [clsDisassem.cpp] - Blame information for rev 30

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 30 robfinch 
#include "stdafx.h"
2 
#include "insn.h"
3 
#include "clsSystem.h"
4 
#include "clsDisassem.h"
5 
 
6 
extern clsSystem system1;
7 
 
8 
std::string clsDisassem::SprName(int rg)
9 
{
10 
        char buf[100];
11 
 
12 
        buf[0] = '\0';
13 
        if (rg < 16)
14 
                sprintf(buf, "p%d", rg);
15 
        else if (rg < 32)
16 
                sprintf(buf, "c%d", rg-16);
17 
        else if (rg < 48) {
18 
                switch(rg) {
19 
                case 32:        sprintf(buf, "zs"); break;
20 
                case 33:        sprintf(buf, "ds"); break;
21 
                case 34:        sprintf(buf, "es"); break;
22 
                case 35:        sprintf(buf, "fs"); break;
23 
                case 36:        sprintf(buf, "gs"); break;
24 
                case 37:        sprintf(buf, "hs"); break;
25 
                case 38:        sprintf(buf, "ss"); break;
26 
                case 39:        sprintf(buf, "cs"); break;
27 
                case 40:        sprintf(buf, "zs.lmt"); break;
28 
                case 41:        sprintf(buf, "ds.lmt"); break;
29 
                case 42:        sprintf(buf, "es.lmt"); break;
30 
                case 43:        sprintf(buf, "fs.lmt"); break;
31 
                case 44:        sprintf(buf, "gs.lmt"); break;
32 
                case 45:        sprintf(buf, "hs.lmt"); break;
33 
                case 46:        sprintf(buf, "ss.lmt"); break;
34 
                case 47:        sprintf(buf, "cs.lmt"); break;
35 
                }
36 
        }
37 
        return std::string(buf);
38 
}
39 
 
40 
std::string clsDisassem::PredCond(int cnd)
41 
{
42 
        switch(cnd) {
43 
        case PF: return "PF  ";
44 
        case PT: return "PT  ";
45 
        case PEQ: return "PEQ ";
46 
        case PNE: return "PNE ";
47 
        case PLE: return "PLE ";
48 
        case PGT: return "PGT ";
49 
        case PGE: return "PGE ";
50 
        case PLT: return "PLT ";
51 
        case PLEU: return "PLEU";
52 
        case PGTU: return "PGTU";
53 
        case PGEU: return "PGEU";
54 
        case PLTU: return "PLTU";
55 
        default: return "????";
56 
        }
57 
}
58 
 
59 
// Compute d[Rn] address info
60 
std::string clsDisassem::dRn(int b1, int b2, int b3, int *Ra, int *Sg, __int64 *disp)
61 
{
62 
        char buf[100];
63 
 
64 
        if (!Ra || !disp || !Sg)
65 
                return "<error>";
66 
        *Ra = b1 & 0x3f;
67 
        *Sg = (b3 >> 5) & 7;
68 
        *disp = ((b2 >> 4) & 0xF) | ((b3 & 0x1f) << 4);
69 
        if (*disp & 0x100)
70 
                *disp |= 0xFFFFFFFFFFFFFE00LL;
71 
        if (imm_prefix) {
72 
                *disp &= 0xFF;
73 
                *disp |= imm;
74 
        }
75 
        sprintf(buf, "$%I64X[r%d]", *disp, *Ra);
76 
        return std::string(buf);
77 
}
78 
 
79 
std::string clsDisassem::Disassem(int ad, int *nb)
80 
{
81 
        int byt;
82 
        int opcode, func;
83 
        int n;
84 
        __int64 val, disp;
85 
        int rv;
86 
        int b1, b2, b3, b4;
87 
        int Ra,Rb,Rc,Rt,Sprn,Sg;
88 
        int Cr,Ct;
89 
        int Pn;
90 
        char buf[100];
91 
        std::string str;
92 
 
93 
        buf[0] = '\0';
94 
        byt = system1.ReadByte(ad);
95 
        ad++;
96 
        if (byt==0x00) {
97 
                if (nb) *nb = 1;
98 
                return std::string("        BRK");
99 
        }
100 
        if (byt==0x10) {
101 
                if (nb) *nb = 1;
102 
                return std::string("        NOP");
103 
        }
104 
        if (byt==0x20) {
105 
                val = system1.ReadByte(ad);
106 
                ad++;
107 
                if (val & 0x80LL)
108 
                        val |= 0xFFFFFFFFFFFFFF00LL;
109 
                sprintf(buf, "        IMM %02LLX",val);
110 
                if (nb) *nb = 2;
111 
                imm = val << 8;
112 
                imm_prefix = true;
113 
                return std::string(buf);
114 
        }
115 
        if (byt==0x30) {
116 
                val = system1.ReadByte(ad);
117 
                ad++;
118 
                val += (system1.ReadByte(ad) << 8);
119 
                ad++;
120 
                if (val & 0x8000LL)
121 
                        val |= 0xFFFFFFFFFFFF0000LL;
122 
                sprintf(buf, "        IMM %04LLX",val);
123 
                if (nb) *nb = 3;
124 
                imm = val << 8;
125 
                imm_prefix = true;
126 
                return std::string(buf);
127 
        }
128 
        if (byt==0x40) {
129 
                val = system1.ReadByte(ad);
130 
                ad++;
131 
                val += (system1.ReadByte(ad) << 8);
132 
                ad++;
133 
                val += (system1.ReadByte(ad) << 16);
134 
                ad++;
135 
                if (val & 0x800000LL)
136 
                        val |= 0xFFFFFFFFFF000000LL;
137 
                sprintf(buf, "        IMM %06LLX",val);
138 
                imm = val << 8;
139 
                if (nb) *nb = 4;
140 
                imm_prefix = true;
141 
                return std::string(buf);
142 
        }
143 
        if (byt==0x50) {
144 
                val = system1.ReadByte(ad);
145 
                ad++;
146 
                val += (system1.ReadByte(ad) << 8);
147 
                ad++;
148 
                val += (system1.ReadByte(ad) << 16);
149 
                ad++;
150 
                val += (system1.ReadByte(ad) << 24);
151 
                ad++;
152 
                if (val & 0x80000000LL)
153 
                        val |= 0xFFFFFFFF00000000LL;
154 
                sprintf(buf, "        IMM %08LLX",val);
155 
                if (nb) *nb = 5;
156 
                imm = val << 8;
157 
                imm_prefix = true;
158 
                return std::string(buf);
159 
        }
160 
        if (byt==0x60) {
161 
                val = system1.ReadByte(ad);
162 
                ad++;
163 
                val += (system1.ReadByte(ad) << 8);
164 
                ad++;
165 
                val += (system1.ReadByte(ad) << 16);
166 
                ad++;
167 
                val += (system1.ReadByte(ad) << 24);
168 
                ad++;
169 
                val += (system1.ReadByte(ad) << 32);
170 
                ad++;
171 
                if (val & 0x8000000000LL)
172 
                        val |= 0xFFFFFF0000000000LL;
173 
                sprintf(buf, "        IMM %010LLX",val);
174 
                if (nb) *nb = 6;
175 
                imm = val << 8;
176 
                imm_prefix = true;
177 
                return std::string(buf);
178 
        }
179 
        if (byt==0x70) {
180 
                val = system1.ReadByte(ad);
181 
                ad++;
182 
                val += (system1.ReadByte(ad) << 8);
183 
                ad++;
184 
                val += (system1.ReadByte(ad) << 16);
185 
                ad++;
186 
                val += (system1.ReadByte(ad) << 24);
187 
                ad++;
188 
                val += (system1.ReadByte(ad) << 32);
189 
                ad++;
190 
                val += (system1.ReadByte(ad) << 40);
191 
                ad++;
192 
                if (val & 0x800000000000LL)
193 
                        val |= 0xFFFF000000000000LL;
194 
                sprintf(buf, "        IMM %012LLX",val);
195 
                if (nb) *nb = 7;
196 
                imm = val << 8;
197 
                imm_prefix = true;
198 
                return std::string(buf);
199 
        }
200 
        if (byt==0x80) {
201 
                val = system1.ReadByte(ad);
202 
                ad++;
203 
                val += (system1.ReadByte(ad) << 8);
204 
                ad++;
205 
                val += (system1.ReadByte(ad) << 16);
206 
                ad++;
207 
                val += (system1.ReadByte(ad) << 24);
208 
                ad++;
209 
                val += (system1.ReadByte(ad) << 32);
210 
                ad++;
211 
                val += (system1.ReadByte(ad) << 40);
212 
                ad++;
213 
                val += (system1.ReadByte(ad) << 48);
214 
                ad++;
215 
                if (val & 0x80000000000000LL)
216 
                        val |= 0xFF00000000000000LL;
217 
                sprintf(buf, "        IMM %014LLX",val);
218 
                if (nb) *nb = 8;
219 
                imm = val << 8;
220 
                imm_prefix = true;
221 
                return std::string(buf);
222 
        }
223 
        if (byt != 0x01)
224 
                sprintf(buf, "p%d.%s ", (byt & 0xF0) >> 4, PredCond(byt & 0xF).c_str());
225 
        opcode = system1.ReadByte(ad);
226 
        ad++;
227 
        if ((opcode & 0xF0)==0x00) {
228 
                b1 = system1.ReadByte(ad);
229 
                ad++;
230 
                Ra = b1 & 0x3f;
231 
                Pn = opcode & 0x0f;
232 
                sprintf(&buf[strlen(buf)], "TST p%d,r%d", Pn, Ra);
233 
                if (nb) *nb = 3;
234 
                imm_prefix = false;
235 
                return std::string(buf);
236 
        }
237 
        if ((opcode & 0xF0)==0x20) {
238 
                b1 = system1.ReadByte(ad);
239 
                ad++;
240 
                b2 = system1.ReadByte(ad);
241 
                ad++;
242 
                Ra = b1 & 0x3f;
243 
                Pn = opcode & 0x0f;
244 
                val = (b2 << 2) | (b1 >> 6);
245 
                if (imm_prefix)
246 
                        val = imm | (val & 0xFF);
247 
                else {
248 
                        if (val & 0x200)
249 
                                val |= 0xFFFFFFFFFFFFFE00LL;
250 
                }
251 
                sprintf(&buf[strlen(buf)], " CMPI p%d,r%d,#$%LLX", Pn, Ra, val);
252 
                if (nb) *nb = 4;
253 
                imm_prefix = false;
254 
                return std::string(buf);
255 
        }
256 
        if ((opcode & 0xF0)==0x30) {
257 
                b1 = system1.ReadByte(ad);
258 
                ad++;
259 
                disp = (b1 << 4) | (opcode & 0xF);
260 
                if (disp & 0x800)
261 
                        disp |= 0xFFFFFFFFFFFFF000LL;
262 
                sprintf(&buf[strlen(buf)], " BR $%LLX", disp + cpu1.pc);
263 
                if (nb) *nb = 3;
264 
                imm_prefix = false;
265 
                return std::string(buf);
266 
        }
267 
 
268 
        switch(opcode) {
269 
 
270 
        case ADDUI:
271 
                b1 = system1.ReadByte(ad);
272 
                ad++;
273 
                b2 = system1.ReadByte(ad);
274 
                ad++;
275 
                b3 = system1.ReadByte(ad);
276 
                ad++;
277 
                Ra = b1 & 0x3f;
278 
                Rt = ((b2 & 0xf) << 2) | (b1 >> 6);
279 
                val = (b3 << 4) | (b2 >> 4);
280 
                sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%08LLX", Rt, Ra, val);
281 
                if (nb) *nb = 5;
282 
                imm_prefix = false;
283 
                return std::string(buf);
284 
 
285 
        case ADDUIS:
286 
                b1 = system1.ReadByte(ad);
287 
                ad++;
288 
                b2 = system1.ReadByte(ad);
289 
                ad++;
290 
                Ra = b1 & 0x3f;
291 
                Rt = Ra;
292 
                val = (b2 << 2) | (b1 >> 6);
293 
                sprintf(&buf[strlen(buf)], " ADDUI r%d,r%d,#$%08LLX", Rt, Ra, val);
294 
                if (nb) *nb = 4;
295 
                imm_prefix = false;
296 
                return std::string(buf);
297 
 
298 
        case JSR:
299 
                b1 = system1.ReadByte(ad);
300 
                ad++;
301 
                b2 = system1.ReadByte(ad);
302 
                ad++;
303 
                b3 = system1.ReadByte(ad);
304 
                ad++;
305 
                b4 = system1.ReadByte(ad);
306 
                ad++;
307 
                Cr = b1 >> 4;
308 
                Ct = b1 & 0xF;
309 
                if (imm_prefix)
310 
                        disp = imm | b2;
311 
                else {
312 
                        disp = (b4 << 16) | (b3 << 8) | b2;
313 
                        if (disp & 0x800000LL)
314 
                                disp |= 0xFFFFFFFFFF000000LL;
315 
                }
316 
                if (nb) *nb = 6;
317 
                imm_prefix = false;
318 
                sprintf(&buf[strlen(buf)], " JSR c%d,$%LLX[c%d]", Ct, disp, Cr);
319 
                return std::string(buf);
320 
 
321 
        case JSRS:
322 
                b1 = system1.ReadByte(ad);
323 
                ad++;
324 
                b2 = system1.ReadByte(ad);
325 
                ad++;
326 
                b3 = system1.ReadByte(ad);
327 
                ad++;
328 
                Cr = b1 >> 4;
329 
                Ct = b1 & 0xF;
330 
                if (imm_prefix)
331 
                        disp = imm | b2;
332 
                else {
333 
                        disp = (b3 << 8) | b2;
334 
                        if (disp & 0x8000LL)
335 
                                disp |= 0xFFFFFFFFFFFF0000LL;
336 
                }
337 
                if (nb) *nb = 5;
338 
                imm_prefix = false;
339 
                sprintf(&buf[strlen(buf)], " JSR c%d,$%LLX", Ct, disp);
340 
                if (Cr==15)
341 
                        sprintf(&buf[strlen(buf)], "[c%d]  ($%LLX)", Cr, cpu1.pc + disp);
342 
                else
343 
                        sprintf(&buf[strlen(buf)], "[c%d]", Cr);
344 
                return std::string(buf);
345 
 
346 
        case LDI:
347 
                b1 = system1.ReadByte(ad);
348 
                ad++;
349 
                b2 = system1.ReadByte(ad);
350 
                ad++;
351 
                Rt = b1 & 0x3f;
352 
                val = (b2 << 2) | (b1 >> 6);
353 
                if (imm_prefix)
354 
                        val = imm | (val & 0xFF);
355 
                else {
356 
                        if (val & 0x200)
357 
                                val |= 0xFFFFFFFFFFFFFE00LL;
358 
                }
359 
                sprintf(&buf[strlen(buf)], " LDI r%d,#$%08LLX", Rt, val);
360 
                if (nb) *nb = 4;
361 
                imm_prefix = false;
362 
                return std::string(buf);
363 
 
364 
        case LDIS:
365 
                b1 = system1.ReadByte(ad);
366 
                ad++;
367 
                b2 = system1.ReadByte(ad);
368 
                ad++;
369 
                Sprn = b1 & 0x3f;
370 
                val = (b2 << 2) | (b1 >> 6);
371 
                if (imm_prefix)
372 
                        val = imm | (val & 0xFF);
373 
                else {
374 
                        if (val & 0x200)
375 
                                val |= 0xFFFFFFFFFFFFFE00LL;
376 
                }
377 
                sprintf(&buf[strlen(buf)], " LDIS %s,#$%08LLX", SprName(Sprn).c_str(), val);
378 
                if (nb) *nb = 4;
379 
                imm_prefix = false;
380 
                return std::string(buf);
381 
 
382 
        case LH:
383 
                b1 = ReadByte(ad);
384 
                ad++;
385 
                b2 = ReadByte(ad);
386 
                ad++;
387 
                b3 = ReadByte(ad);
388 
                ad++;
389 
                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
390 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
391 
                sprintf(&buf[strlen(buf)]," LH r%d,%s", Rt, str.c_str());
392 
                if (nb) *nb = 5;
393 
                imm_prefix = false;
394 
                return std::string(buf);
395 
 
396 
        case LLA:
397 
                b1 = ReadByte(ad);
398 
                ad++;
399 
                b2 = ReadByte(ad);
400 
                ad++;
401 
                b3 = ReadByte(ad);
402 
                ad++;
403 
                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
404 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
405 
                sprintf(&buf[strlen(buf)]," LLA r%d,%s", Rt, str.c_str());
406 
                if (nb) *nb = 5;
407 
                imm_prefix = false;
408 
                return std::string(buf);
409 
 
410 
        case LOGIC:
411 
                b1 = system1.ReadByte(ad);
412 
                ad++;
413 
                b2 = system1.ReadByte(ad);
414 
                ad++;
415 
                b3 = system1.ReadByte(ad);
416 
                ad++;
417 
                Ra = b1 & 0x3f;
418 
                Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
419 
                Rt = ((b3 & 3) << 4) | (b2 >> 4);
420 
                func = b3 >> 2;
421 
                switch(func) {
422 
                case OR:
423 
                        sprintf(&buf[strlen(buf)], " OR r%d,r%d,r%d", Rt, Ra, Rb);
424 
                        break;
425 
                }
426 
                if (nb) *nb = 5;
427 
                imm_prefix = false;
428 
                return std::string(buf);
429 
 
430 
        case LOOP:
431 
                disp = system1.ReadByte(ad);
432 
                ad++;
433 
                if (disp & 0x80LL)
434 
                        disp |= 0xFFFFFFFFFFFFFF00LL;
435 
                sprintf(&buf[strlen(buf)], " LOOP $%LLX", disp + ad);
436 
                if (nb) *nb = 3;
437 
                imm_prefix = false;
438 
                return std::string(buf);
439 
 
440 
        case MFSPR:
441 
                b1 = system1.ReadByte(ad);
442 
                ad++;
443 
                b2 = system1.ReadByte(ad);
444 
                ad++;
445 
                Sprn = b1 & 0x3f;
446 
                Rt = ((b2 & 0x0f) << 2) | (b1 >> 6);
447 
                sprintf(&buf[strlen(buf)], " MFSPR r%d,%s", Rt, SprName(Sprn).c_str());
448 
                if (nb) *nb = 4;
449 
                imm_prefix = false;
450 
                return std::string(buf);
451 
 
452 
        case MOV:
453 
                b1 = ReadByte(ad);
454 
                ad++;
455 
                b2 = ReadByte(ad);
456 
                ad++;
457 
                Ra = b1 & 0x3f;
458 
                Rt = ((b2 & 0xF) << 2) | (b1 >> 6);
459 
                sprintf(&buf[strlen(buf)]," MOV r%d,r%d", Rt, Ra);
460 
                if (nb) *nb = 4;
461 
                imm_prefix = false;
462 
                return std::string(buf);
463 
 
464 
        case MTSPR:
465 
                b1 = system1.ReadByte(ad);
466 
                ad++;
467 
                b2 = system1.ReadByte(ad);
468 
                ad++;
469 
                Ra = b1 & 0x3f;
470 
                Sprn = ((b2 & 0x0f) << 2) | (b1 >> 6);
471 
                sprintf(&buf[strlen(buf)], " MTSPR %s,r%d", SprName(Sprn).c_str(), Ra);
472 
                if (nb) *nb = 4;
473 
                imm_prefix = false;
474 
                return std::string(buf);
475 
 
476 
        case RR:
477 
                b1 = system1.ReadByte(ad);
478 
                ad++;
479 
                b2 = system1.ReadByte(ad);
480 
                ad++;
481 
                b3 = system1.ReadByte(ad);
482 
                ad++;
483 
                Ra = b1 & 0x3f;
484 
                Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
485 
                Rt = ((b3 & 3) << 4) | (b2 >> 4);
486 
                func = b3 >> 2;
487 
                switch(func) {
488 
                case _2ADDU:
489 
                        sprintf(&buf[strlen(buf)], " _2ADDU r%d,r%d,r%d", Rt, Ra, Rb);
490 
                        break;
491 
                case _4ADDU:
492 
                        sprintf(&buf[strlen(buf)], " _4ADDU r%d,r%d,r%d", Rt, Ra, Rb);
493 
                        break;
494 
                case _8ADDU:
495 
                        sprintf(&buf[strlen(buf)], " _8ADDU r%d,r%d,r%d", Rt, Ra, Rb);
496 
                        break;
497 
                case _16ADDU:
498 
                        sprintf(&buf[strlen(buf)], " _16ADDU r%d,r%d,r%d", Rt, Ra, Rb);
499 
                        break;
500 
                }
501 
                if (nb) *nb = 5;
502 
                imm_prefix = false;
503 
                return std::string(buf);
504 
 
505 
        case RTS:
506 
                b1 = system1.ReadByte(ad);
507 
                ad++;
508 
                Cr = b1 >> 4;
509 
                sprintf(&buf[strlen(buf)], " RTS $%X[c%d]", b1 & 0xF, Cr);
510 
                if (nb) *nb = 3;
511 
                imm_prefix = false;
512 
                return std::string(buf);
513 
 
514 
        case RTSQ:
515 
                sprintf(&buf[strlen(buf)], " RTS");
516 
                if (nb) *nb = 2;
517 
                imm_prefix = false;
518 
                return std::string(buf);
519 
 
520 
        case SB:
521 
                b1 = ReadByte(ad);
522 
                ad++;
523 
                b2 = ReadByte(ad);
524 
                ad++;
525 
                b3 = ReadByte(ad);
526 
                ad++;
527 
                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
528 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
529 
                sprintf(&buf[strlen(buf)]," SB r%d,%s", Rb, str.c_str());
530 
                if (nb) *nb = 5;
531 
                imm_prefix = false;
532 
                return std::string(buf);
533 
 
534 
        case SC:
535 
                b1 = ReadByte(ad);
536 
                ad++;
537 
                b2 = ReadByte(ad);
538 
                ad++;
539 
                b3 = ReadByte(ad);
540 
                ad++;
541 
                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
542 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
543 
                sprintf(&buf[strlen(buf)]," SC r%d,%s", Rb, str.c_str());
544 
                if (nb) *nb = 5;
545 
                imm_prefix = false;
546 
                return std::string(buf);
547 
 
548 
        case SH:
549 
                b1 = ReadByte(ad);
550 
                ad++;
551 
                b2 = ReadByte(ad);
552 
                ad++;
553 
                b3 = ReadByte(ad);
554 
                ad++;
555 
                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
556 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
557 
                sprintf(&buf[strlen(buf)]," SH r%d,%s", Rb, str.c_str());
558 
                if (nb) *nb = 5;
559 
                imm_prefix = false;
560 
                return std::string(buf);
561 
 
562 
        case SHIFT:
563 
                b1 = system1.ReadByte(ad);
564 
                ad++;
565 
                b2 = system1.ReadByte(ad);
566 
                ad++;
567 
                b3 = system1.ReadByte(ad);
568 
                ad++;
569 
                Ra = b1 & 0x3f;
570 
                Rb = ((b2 & 0x0f) << 2) | (b1 >> 6);
571 
                Rt = ((b3 & 3) << 4) | (b2 >> 4);
572 
                func = b3 >> 2;
573 
                switch(func) {
574 
                case SHL:
575 
                        sprintf(&buf[strlen(buf)], " SHL r%d,r%d,r%d", Rt, Ra, Rb);
576 
                        break;
577 
                case SHLI:
578 
                        sprintf(&buf[strlen(buf)], " SHLI r%d,r%d,#$%X", Rt, Ra, Rb);
579 
                        break;
580 
                }
581 
                if (nb) *nb = 5;
582 
                imm_prefix = false;
583 
                return std::string(buf);
584 
 
585 
        case STP:
586 
                b1 = ReadByte(ad);
587 
                ad++;
588 
                b2 = ReadByte(ad);
589 
                ad++;
590 
                sprintf(&buf[strlen(buf)]," STP #$%04X", (int)((b2<<8)|b1));
591 
                if (nb) *nb = 4;
592 
                imm_prefix = false;
593 
                return std::string(buf);
594 
 
595 
        case SW:
596 
                b1 = ReadByte(ad);
597 
                ad++;
598 
                b2 = ReadByte(ad);
599 
                ad++;
600 
                b3 = ReadByte(ad);
601 
                ad++;
602 
                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
603 
                str = dRn(b1,b2,b3,&Ra,&Sg,&disp);
604 
                sprintf(&buf[strlen(buf)]," SW r%d,%s", Rb, str.c_str());
605 
                if (nb) *nb = 5;
606 
                imm_prefix = false;
607 
                return std::string(buf);
608 
 
609 
        }
610 
        *nb = 1;
611 
        return std::string("");
612 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.