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

Subversion Repositories thor

[/] [thor/] [trunk/] [software/] [emuThor/] [source/] [clsThor.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 "clsThor.h"
3 
#include "insn.h"
4 
 
5 
extern clsSystem system1;
6 
 
7 
void clsThor::Reset()
8 
{
9 
        pc = 0xFFFFFFFFFFFC0000LL;
10 
        tick = 0;
11 
        gp[0] = 0;
12 
        ca[0] = 0;
13 
}
14 
 
15 
// Compute d[Rn] address info
16 
void clsThor::dRn(int b1, int b2, int b3, int *Ra, int *Sg, __int64 *disp)
17 
{
18 
        if (Ra) *Ra = b1 & 0x3f;
19 
        if (Sg) *Sg = (b3 >> 5) & 7;
20 
        if (disp) *disp = ((b2 >> 4) & 0xF) | ((b3 & 0x1f) << 4);
21 
        if (*disp & 0x100)
22 
                *disp |= 0xFFFFFFFFFFFFFE00LL;
23 
        if (imm_prefix) {
24 
                *disp &= 0xFF;
25 
                *disp |= imm;
26 
        }
27 
}
28 
 
29 
void clsThor::Step()
30 
{
31 
        bool ex = true; // execute instruction
32 
        unsigned int opcode, func;
33 
        __int64 disp;
34 
        int Ra,Rb,Rc,Rt,Pn,Cr,Ct;
35 
        int Sprn,Sg;
36 
        int b1, b2, b3, b4;
37 
        int nn;
38 
        __int64 dat;
39 
 
40 
        gp[0] = 0;
41 
        ca[0] = 0;
42 
        if (imcd > 0) {
43 
                imcd--;
44 
                if (imcd==1)
45 
                        im = 0;
46 
        }
47 
        tick = tick + 1;
48 
        pred = ReadByte(pc);
49 
        pc++;
50 
        for (nn = 39; nn >= 0; nn--)
51 
                pcs[nn] = pcs[nn-1];
52 
        pcs[0] = pc;
53 
        switch (pred) {
54 
        case 0x00:      // BRK instruction
55 
                return;
56 
        case 0x10:      // NOP
57 
                return;
58 
        case 0x20:
59 
                imm = ReadByte(pc) << 8;
60 
                pc++;
61 
                if (imm & 0x8000LL)
62 
                        imm |= 0xFFFFFFFFFFFF0000LL;
63 
                imm_prefix = true;
64 
                return;
65 
        case 0x30:
66 
                imm = ReadByte(pc) << 8;
67 
                pc++;
68 
                imm |= ReadByte(pc) << 16;
69 
                pc++;
70 
                if (imm & 0x800000LL)
71 
                        imm |= 0xFFFFFFFFFF000000LL;
72 
                imm_prefix = true;
73 
                return;
74 
        case 0x40:
75 
                imm = ReadByte(pc) << 8;
76 
                pc++;
77 
                imm |= ReadByte(pc) << 16;
78 
                pc++;
79 
                imm |= ReadByte(pc) << 24;
80 
                pc++;
81 
                if (imm & 0x80000000LL)
82 
                        imm |= 0xFFFFFFFF00000000LL;
83 
                imm_prefix = true;
84 
                return;
85 
        case 0x50:
86 
                imm = ReadByte(pc) << 8;
87 
                pc++;
88 
                imm |= ReadByte(pc) << 16;
89 
                pc++;
90 
                imm |= ReadByte(pc) << 24;
91 
                pc++;
92 
                imm |= ReadByte(pc) << 32;
93 
                pc++;
94 
                if (imm & 0x8000000000LL)
95 
                        imm |= 0xFFFFFF0000000000LL;
96 
                imm_prefix = true;
97 
                return;
98 
        case 0x60:
99 
                imm = ReadByte(pc) << 8;
100 
                pc++;
101 
                imm |= ReadByte(pc) << 16;
102 
                pc++;
103 
                imm |= ReadByte(pc) << 24;
104 
                pc++;
105 
                imm |= ReadByte(pc) << 32;
106 
                pc++;
107 
                imm |= ReadByte(pc) << 40;
108 
                pc++;
109 
                if (imm & 0x800000000000LL)
110 
                        imm |= 0xFFFF000000000000LL;
111 
                imm_prefix = true;
112 
                return;
113 
        case 0x70:
114 
                imm = ReadByte(pc) << 8;
115 
                pc++;
116 
                imm |= ReadByte(pc) << 16;
117 
                pc++;
118 
                imm |= ReadByte(pc) << 24;
119 
                pc++;
120 
                imm |= ReadByte(pc) << 32;
121 
                pc++;
122 
                imm |= ReadByte(pc) << 40;
123 
                pc++;
124 
                imm |= ReadByte(pc) << 48;
125 
                pc++;
126 
                if (imm & 0x80000000000000LL)
127 
                        imm |= 0xFF00000000000000LL;
128 
                imm_prefix = true;
129 
                return;
130 
        case 0x80:
131 
                imm = ReadByte(pc) << 8;
132 
                pc++;
133 
                imm |= ReadByte(pc) << 16;
134 
                pc++;
135 
                imm |= ReadByte(pc) << 24;
136 
                pc++;
137 
                imm |= ReadByte(pc) << 32;
138 
                pc++;
139 
                imm |= ReadByte(pc) << 40;
140 
                pc++;
141 
                imm |= ReadByte(pc) << 48;
142 
                pc++;
143 
                imm |= ReadByte(pc) << 56;
144 
                pc++;
145 
                imm_prefix = true;
146 
                return;
147 
        default: {
148 
                int rv;
149 
 
150 
                rv = pr[pred>>4];
151 
                switch(pred & 15) {
152 
                case PF: ex = false; break;
153 
                case PT: ex = true; break;
154 
                case PEQ: ex = rv & 1; break;
155 
                case PNE: ex = !(rv & 1); break;
156 
                case PLE: ex = (rv & 1)||(rv & 2); break;
157 
                case PGT: ex = !((rv & 1)||(rv & 2)); break;
158 
                case PGE: ex = (rv & 2)==0; break;
159 
                case PLT: ex = (rv & 2)!=0; break;
160 
                case PLEU: ex = (rv & 1)||(rv & 4); break;
161 
                case PGTU: ex = !((rv & 1)||(rv & 4)); break;
162 
                case PGEU: ex = (rv & 4)==0; break;
163 
                case PLTU: ex = (rv & 4)!=0; break;
164 
                default:        ex = false;
165 
                }
166 
                }
167 
        }
168 
        opcode = ReadByte(pc);
169 
        pc++;
170 
        if ((opcode & 0xF0)==0x00) {    // TST
171 
                b1 = ReadByte(pc);
172 
                pc++;
173 
                if (ex) {
174 
                        Ra = b1 & 0x3f;
175 
                        Pn = opcode & 0x0f;
176 
                        pr[Pn] = 0;
177 
                        if (gp[Ra]==0)
178 
                                pr[Pn] |= 1;
179 
                        if ((signed)gp[Ra] < (signed)0)
180 
                                pr[Pn] |= 2;
181 
                }
182 
                imm_prefix = false;
183 
                return;
184 
        }
185 
        else if ((opcode & 0xF0)==0x10) {       // CMP
186 
                b1 = ReadByte(pc);
187 
                pc++;
188 
                b2 = ReadByte(pc);
189 
                pc++;
190 
                if (ex) {
191 
                        Ra = b1 & 0x3f;
192 
                        Rb = ((b1 & 0xC0) >> 6) | ((b2 & 0x0f)<<2);
193 
                        Pn = opcode & 0x0f;
194 
                        pr[Pn] = 0;
195 
                        if (gp[Ra]==gp[Rb])
196 
                                pr[Pn] |= 1;
197 
                        if ((signed)gp[Ra] < (signed)gp[Rb])
198 
                                pr[Pn] |= 2;
199 
                        if (gp[Ra] < gp[Rb])
200 
                                pr[Pn] |= 4;
201 
                }
202 
                imm_prefix = false;
203 
                return;
204 
        }
205 
        else if ((opcode & 0xF0)==0x20) {       // CMPI
206 
                b1 = ReadByte(pc);
207 
                pc++;
208 
                b2 = ReadByte(pc);
209 
                pc++;
210 
                if (ex) {
211 
                        Ra = b1 & 0x3f;
212 
                        if (imm_prefix) {
213 
                                imm |= ((b2 << 2) & 0xFF) | ((b1 >> 6) & 3);
214 
                        }
215 
                        else {
216 
                                imm = ((b2 << 2) & 0x3FF) | ((b1 >> 6) & 3);
217 
                                if (imm & 0x200)
218 
                                        imm |= 0xFFFFFFFFFFFFFE00LL;
219 
                        }
220 
                        Pn = opcode & 0x0f;
221 
                        pr[Pn] = 0;
222 
                        if (gp[Ra]==imm)
223 
                                pr[Pn] |= 1;
224 
                        if ((signed)gp[Ra] < (signed)imm)
225 
                                pr[Pn] |= 2;
226 
                        if (gp[Ra] < imm)
227 
                                pr[Pn] |= 4;
228 
                }
229 
                imm_prefix = false;
230 
                return;
231 
        }
232 
        else if ((opcode & 0xF0)==0x30) {       // BR
233 
                disp = ReadByte(pc);
234 
                pc++;
235 
                if (ex) {
236 
                        disp = disp | ((opcode & 0x0F) << 8);
237 
                        if (disp & 0x800)
238 
                                disp |= 0xFFFFFFFFFFFFF000LL;
239 
                        pc = pc + disp;
240 
                }
241 
                imm_prefix = false;
242 
                return;
243 
        }
244 
        else {
245 
                switch(opcode) {
246 
                case ADDUI:
247 
                        b1 = ReadByte(pc);
248 
                        pc++;
249 
                        b2 = ReadByte(pc);
250 
                        pc++;
251 
                        b3 = ReadByte(pc);
252 
                        pc++;
253 
                        if (ex) {
254 
                                Ra = b1 & 0x3f;
255 
                                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
256 
                                if (imm_prefix) {
257 
                                        imm |= ((b3 << 4)&0xF0) | ((b2 >> 4) & 0xF);
258 
                                }
259 
                                else {
260 
                                        imm = (b3 << 4) | ((b2 >> 4) & 0xF);
261 
                                        if (imm & 0x800)
262 
                                                imm |= 0xFFFFFFFFFFFFF000LL;
263 
                                }
264 
                                gp[Rt] = gp[Ra] + imm;
265 
                                gp[0] = 0;
266 
                        }
267 
                        imm_prefix = false;
268 
                        return;
269 
 
270 
                case ADDUIS:
271 
                        b1 = ReadByte(pc);
272 
                        pc++;
273 
                        b2 = ReadByte(pc);
274 
                        pc++;
275 
                        if (ex) {
276 
                                Ra = b1 & 0x3f;
277 
                                Rt = Ra;
278 
                                if (imm_prefix) {
279 
                                        imm |= ((b2 << 2)&0xFC) | ((b1 >> 6) & 0x3);
280 
                                }
281 
                                else {
282 
                                        imm = ((b2 << 2)&0x3FC) | ((b1 >> 6) & 0x3);
283 
                                        if (imm & 0x200)
284 
                                                imm |= 0xFFFFFFFFFFFFFE00LL;
285 
                                }
286 
                                gp[Rt] = gp[Ra] + imm;
287 
                                gp[0] = 0;
288 
                        }
289 
                        imm_prefix = false;
290 
                        return;
291 
 
292 
                case JSR:
293 
                        b1 = ReadByte(pc);
294 
                        pc++;
295 
                        b2 = ReadByte(pc);
296 
                        pc++;
297 
                        b3 = ReadByte(pc);
298 
                        pc++;
299 
                        b4 = ReadByte(pc);
300 
                        pc++;
301 
                        if (ex) {
302 
                                Ct = b1 & 0x0F;
303 
                                Cr = (b1 & 0xF0) >> 4;
304 
                                if (Ct != 0)
305 
                                        ca[Ct] = pc;
306 
                                disp = (b3 << 16) | (b2 << 8) | b1;
307 
                                if (disp & 0x800000)
308 
                                        disp |= 0xFFFFFFFFFF000000LL;
309 
                                if (imm_prefix) {
310 
                                        disp &= 0xFF;
311 
                                        disp |= imm;
312 
                                }
313 
                                ca[15] = pc;
314 
                                pc = disp + ca[Cr];
315 
                        }
316 
                        imm_prefix = false;
317 
                        return;
318 
 
319 
                case JSRS:
320 
                        b1 = ReadByte(pc);
321 
                        pc++;
322 
                        b2 = ReadByte(pc);
323 
                        pc++;
324 
                        b3 = ReadByte(pc);
325 
                        pc++;
326 
                        if (ex) {
327 
                                Ct = b1 & 0x0F;
328 
                                Cr = (b1 & 0xF0) >> 4;
329 
                                ca[Ct] = pc;
330 
                                ca[0] = 0;
331 
                                disp = (b3 << 8) | b2;
332 
                                if (disp & 0x8000)
333 
                                        disp |= 0xFFFFFFFFFFFF0000LL;
334 
                                if (imm_prefix) {
335 
                                        disp &= 0xFFLL;
336 
                                        disp |= imm;
337 
                                }
338 
                                ca[15] = pc;
339 
                                pc = disp + ca[Cr] - 5;
340 
                        }
341 
                        imm_prefix = false;
342 
                        return;
343 
 
344 
                case JSRR:
345 
                        b1 = ReadByte(pc);
346 
                        pc++;
347 
                        if (ex) {
348 
                                Ct = b1 & 0x0F;
349 
                                Cr = (b1 & 0xF0) >> 4;
350 
                                if (Ct != 0)
351 
                                        ca[Ct] = pc;
352 
                                disp = 0;
353 
                                if (imm_prefix) {
354 
                                        disp &= 0xFF;
355 
                                        disp |= imm;
356 
                                }
357 
                                ca[15] = pc;
358 
                                pc = disp + ca[Cr];
359 
                        }
360 
                        imm_prefix = false;
361 
                        return;
362 
 
363 
                case LDIS:
364 
                        b1 = ReadByte(pc);
365 
                        pc++;
366 
                        b2 = ReadByte(pc);
367 
                        pc++;
368 
                        if (ex) {
369 
                                Sprn = b1 & 0x3f;
370 
                                if (imm_prefix) {
371 
                                        imm |= ((b2 << 2) & 0xFF) | ((b1 >> 6) & 3);
372 
                                }
373 
                                else {
374 
                                        imm = ((b2 << 2) & 0x3FF) | ((b1 >> 6) & 3);
375 
                                        if (imm & 0x200)
376 
                                                imm |= 0xFFFFFFFFFFFFFE00LL;
377 
                                }
378 
                                if (Sprn < 16) {
379 
                                        pr[Sprn] = imm & 0xF;
380 
                                }
381 
                                else if (Sprn < 32) {
382 
                                        ca[Sprn-16] = imm;
383 
                                        ca[0] = 0;
384 
                                        ca[15] = pc;
385 
                                }
386 
                                else if (Sprn < 40) {
387 
                                        seg_base[Sprn-32] = imm & 0xFFFFFFFFFFFFF000LL;
388 
                                }
389 
                                else if (Sprn < 48) {
390 
                                        seg_limit[Sprn-40] = imm & 0xFFFFFFFFFFFFF000LL;
391 
                                }
392 
                                else {
393 
                                        switch(Sprn) {
394 
                                        case 51:        lc = imm; break;
395 
                                        case 52:
396 
                                                for (nn = 0; nn < 16; nn++) {
397 
                                                        pr[nn] = (imm >> (nn * 4)) & 0xF;
398 
                                                }
399 
                                                break;
400 
                                        case 60:        bir = imm & 0xFFLL; break;
401 
                                        case 61:
402 
                                                switch(bir) {
403 
                                                case 0: dbad0 = imm; break;
404 
                                                case 1: dbad1 = imm; break;
405 
                                                case 2: dbad2 = imm; break;
406 
                                                case 3: dbad3 = imm; break;
407 
                                                case 4: dbctrl = imm; break;
408 
                                                case 5: dbstat = imm; break;
409 
                                                }
410 
                                        }
411 
                                }
412 
                        }
413 
                        imm_prefix = false;
414 
                        return;
415 
 
416 
                case LDI:
417 
                        b1 = ReadByte(pc);
418 
                        pc++;
419 
                        b2 = ReadByte(pc);
420 
                        pc++;
421 
                        if (ex) {
422 
                                Rt = b1 & 0x3f;
423 
                                if (imm_prefix) {
424 
                                        imm |= ((b2 << 2) & 0xFF) | ((b1 >> 6) & 3);
425 
                                }
426 
                                else {
427 
                                        imm = ((b2 << 2) & 0x3FF) | ((b1 >> 6) & 3);
428 
                                        if (imm & 0x200)
429 
                                                imm |= 0xFFFFFFFFFFFFFE00LL;
430 
                                }
431 
                                gp[Rt] = imm;
432 
                        }
433 
                        imm_prefix = false;
434 
                        return;
435 
 
436 
                case LH:
437 
                        b1 = ReadByte(pc);
438 
                        pc++;
439 
                        b2 = ReadByte(pc);
440 
                        pc++;
441 
                        b3 = ReadByte(pc);
442 
                        pc++;
443 
                        if (ex) {
444 
                                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
445 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
446 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
447 
                                dat = system1->Read(ea);
448 
                                if (ea & 4)
449 
                                        dat = (dat >> 32);
450 
                                if (ea & 2)
451 
                                        dat = (dat >> 16);
452 
                                dat &= 0xFFFF;
453 
                                if (dat & 0x8000LL)
454 
                                        dat |= 0xFFFFFFFFFFFF0000LL;
455 
                                gp[Rt] = dat;
456 
                                gp[0] = 0;
457 
                        }
458 
                        imm_prefix = false;
459 
                        return;
460 
 
461 
                case LLA:
462 
                        b1 = ReadByte(pc);
463 
                        pc++;
464 
                        b2 = ReadByte(pc);
465 
                        pc++;
466 
                        b3 = ReadByte(pc);
467 
                        pc++;
468 
                        if (ex) {
469 
                                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
470 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
471 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
472 
                                gp[Rt] = ea;
473 
                                gp[0] = 0;
474 
                        }
475 
                        imm_prefix = false;
476 
                        return;
477 
 
478 
                case LOGIC:
479 
                        b1 = ReadByte(pc);
480 
                        pc++;
481 
                        b2 = ReadByte(pc);
482 
                        pc++;
483 
                        b3 = ReadByte(pc);
484 
                        pc++;
485 
                        if (ex) {
486 
                                Ra = b1 & 0x3f;
487 
                                Rb = ((b2 << 2) & 0x3c) | (b1 >> 6);
488 
                                Rt = (b2 >> 4) | ((b3 & 0x3) << 4);
489 
                                func = b3 >> 2;
490 
                                switch(func) {
491 
                                case OR:
492 
                                        gp[Rt] = gp[Ra] | gp[Rb];
493 
                                        gp[0] = 0;
494 
                                        break;
495 
                                }
496 
                        }
497 
                        imm_prefix = 0;
498 
                        return;
499 
 
500 
                case LOOP:
501 
                        disp = ReadByte(pc);
502 
                        pc++;
503 
                        if (ex) {
504 
                                if (disp & 0x80LL)
505 
                                        disp |= 0xFFFFFFFFFFFFFF00LL;
506 
                                if (lc > 0) {
507 
                                        lc--;
508 
                                        pc = pc + disp;
509 
                                }
510 
                        }
511 
                        imm_prefix = false;
512 
                        return;
513 
 
514 
                case MFSPR:
515 
                        b1 = ReadByte(pc);
516 
                        pc++;
517 
                        b2 = ReadByte(pc);
518 
                        pc++;
519 
                        if (ex) {
520 
                                Sprn = b1 & 0x3f;
521 
                                Rt = ((b2 & 0xF) << 2) | ((b1 >> 6) & 3);
522 
                                if (Sprn < 16) {
523 
                                        gp[Rt] = pr[Sprn];
524 
                                        gp[0] = 0;
525 
                                }
526 
                                else if (Sprn < 32) {
527 
                                        Sprn -= 16;
528 
                                        gp[Rt] = ca[Sprn];
529 
                                        gp[0] = 0;
530 
                                }
531 
                                else if (Sprn < 40) {
532 
                                        gp[Rt] = seg_base[Sprn-32];
533 
                                        gp[0] = 0;
534 
                                }
535 
                                else if (Sprn < 48) {
536 
                                        gp[Rt] = seg_limit[Sprn-32];
537 
                                        gp[0] = 0;
538 
                                }
539 
                                else {
540 
                                        switch(Sprn) {
541 
                                        case 50:        gp[Rt] = tick; gp[0] = 0; break;
542 
                                        case 51:        gp[Rt] = lc; gp[0] = 0; break;
543 
                                        case 52:
544 
                                                gp[Rt] = 0;
545 
                                                for (nn = 0; nn < 16; nn++) {
546 
                                                        gp[Rt] |= pr[nn] << (nn * 4);
547 
                                                }
548 
                                                gp[0] = 0;
549 
                                                break;
550 
                                        case 60:        gp[Rt] = bir; gp[0] = 0; break;
551 
                                        case 61:
552 
                                                switch(bir) {
553 
                                                case 0: gp[Rt] = dbad0; gp[0] = 0; break;
554 
                                                case 1: gp[Rt] = dbad1;  gp[0] = 0; break;
555 
                                                case 2: gp[Rt] = dbad2;  gp[0] = 0; break;
556 
                                                case 3: gp[Rt] = dbad3;  gp[0] = 0; break;
557 
                                                case 4: gp[Rt] = dbctrl;  gp[0] = 0; break;
558 
                                                case 5: gp[Rt] = dbstat;  gp[0] = 0; break;
559 
                                                }
560 
                                        }
561 
                                }
562 
                        }
563 
                        imm_prefix = false;
564 
                        return;
565 
 
566 
                case MOV:
567 
                        b1 = ReadByte(pc);
568 
                        pc++;
569 
                        b2 = ReadByte(pc);
570 
                        pc++;
571 
                        if (ex) {
572 
                                Ra = b1 & 0x3f;
573 
                                Rt = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
574 
                                gp[Rt] = gp[Ra];
575 
                                gp[0] = 0;
576 
                        }
577 
                        imm_prefix = false;
578 
                        return;
579 
 
580 
                case MTSPR:
581 
                        b1 = ReadByte(pc);
582 
                        pc++;
583 
                        b2 = ReadByte(pc);
584 
                        pc++;
585 
                        if (ex) {
586 
                                Ra = b1 & 0x3f;
587 
                                Sprn = ((b2 & 0xF) << 2) | ((b1 >> 6) & 3);
588 
                                if (Sprn < 16)
589 
                                        pr[Sprn] = gp[Ra];
590 
                                else if (Sprn < 32) {
591 
                                        Sprn -= 16;
592 
                                        ca[Sprn] = gp[Ra];
593 
                                        ca[0] = 0;
594 
                                        ca[15] = pc;
595 
                                }
596 
                                else if (Sprn < 40) {
597 
                                        seg_base[Sprn-32] = gp[Ra] & 0xFFFFFFFFFFFFF000LL;
598 
                                }
599 
                                else if (Sprn < 48) {
600 
                                        seg_limit[Sprn-32] = gp[Ra] & 0xFFFFFFFFFFFFF000LL;
601 
                                }
602 
                                else {
603 
                                        switch(Sprn) {
604 
                                        case 51:        lc = gp[Ra]; break;
605 
                                        case 52:
606 
                                                for (nn = 0; nn < 16; nn++) {
607 
                                                        pr[nn] = (gp[Ra] >> (nn * 4)) & 0xF;
608 
                                                }
609 
                                                break;
610 
                                        case 60:        bir = gp[Ra] & 0xFFLL; break;
611 
                                        case 61:
612 
                                                switch(bir) {
613 
                                                case 0: dbad0 = gp[Ra]; break;
614 
                                                case 1: dbad1 = gp[Ra]; break;
615 
                                                case 2: dbad2 = gp[Ra]; break;
616 
                                                case 3: dbad3 = gp[Ra]; break;
617 
                                                case 4: dbctrl = gp[Ra]; break;
618 
                                                case 5: dbstat = gp[Ra]; break;
619 
                                                }
620 
                                        }
621 
                                }
622 
                        }
623 
                        imm_prefix = false;
624 
                        return;
625 
 
626 
                case RR:
627 
                        b1 = ReadByte(pc);
628 
                        pc++;
629 
                        b2 = ReadByte(pc);
630 
                        pc++;
631 
                        b3 = ReadByte(pc);
632 
                        pc++;
633 
                        if (ex) {
634 
                                Ra = b1 & 0x3f;
635 
                                Rb = ((b2 << 2) & 0x3c) | (b1 >> 6);
636 
                                Rt = (b2 >> 4) | ((b3 & 0x3) << 4);
637 
                                func = b3 >> 2;
638 
                                switch(func) {
639 
                                case _2ADDU:
640 
                                        gp[Rt] = (gp[Ra] << 1) + gp[Rb];
641 
                                        gp[0] = 0;
642 
                                        break;
643 
                                case _4ADDU:
644 
                                        gp[Rt] = (gp[Ra] << 2) + gp[Rb];
645 
                                        gp[0] = 0;
646 
                                        break;
647 
                                case _8ADDU:
648 
                                        gp[Rt] = (gp[Ra] << 3) + gp[Rb];
649 
                                        gp[0] = 0;
650 
                                        break;
651 
                                case _16ADDU:
652 
                                        gp[Rt] = (gp[Ra] << 4) + gp[Rb];
653 
                                        gp[0] = 0;
654 
                                        break;
655 
                                }
656 
                        }
657 
                        imm_prefix = 0;
658 
                        return;
659 
 
660 
                case RTS:
661 
                        b1 = ReadByte(pc);
662 
                        pc++;
663 
                        if (ex) {
664 
                                Cr = (b1 & 0xF0) >> 4;
665 
                                pc = ca[Cr] + (b1 & 0x0F);
666 
                        }
667 
                        imm_prefix = 0;
668 
                        return;
669 
 
670 
                case RTSQ:
671 
                        if (ex) {
672 
                                pc = ca[1];
673 
                        }
674 
                        imm_prefix = 0;
675 
                        return;
676 
 
677 
                case SB:
678 
                        b1 = ReadByte(pc);
679 
                        pc++;
680 
                        b2 = ReadByte(pc);
681 
                        pc++;
682 
                        b3 = ReadByte(pc);
683 
                        pc++;
684 
                        if (ex) {
685 
                                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
686 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
687 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
688 
                                system1->Write(ea,gp[Rb],(0x1 << (ea & 7)) & 0xFF);
689 
                        }
690 
                        imm_prefix = false;
691 
                        return;
692 
 
693 
                case SC:
694 
                        b1 = ReadByte(pc);
695 
                        pc++;
696 
                        b2 = ReadByte(pc);
697 
                        pc++;
698 
                        b3 = ReadByte(pc);
699 
                        pc++;
700 
                        if (ex) {
701 
                                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
702 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
703 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
704 
                                system1->Write(ea,gp[Rb],(0x3 << (ea & 7)) & 0xFF);
705 
                        }
706 
                        imm_prefix = false;
707 
                        return;
708 
 
709 
                case SH:
710 
                        b1 = ReadByte(pc);
711 
                        pc++;
712 
                        b2 = ReadByte(pc);
713 
                        pc++;
714 
                        b3 = ReadByte(pc);
715 
                        pc++;
716 
                        if (ex) {
717 
                                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
718 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
719 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
720 
                                system1->Write(ea,gp[Rb],(0xF << (ea & 7)) & 0xFF);
721 
                        }
722 
                        imm_prefix = false;
723 
                        return;
724 
 
725 
                case SHIFT:
726 
                        b1 = ReadByte(pc);
727 
                        pc++;
728 
                        b2 = ReadByte(pc);
729 
                        pc++;
730 
                        b3 = ReadByte(pc);
731 
                        pc++;
732 
                        if (ex) {
733 
                                Ra = b1 & 0x3f;
734 
                                Rb = ((b2 << 2) & 0x3c) | (b1 >> 6);
735 
                                Rt = (b2 >> 4) | ((b3 & 0x3) << 4);
736 
                                func = b3 >> 2;
737 
                                switch(func) {
738 
                                case SHL:
739 
                                        gp[Rt] = (gp[Ra] << (gp[Rb] & 0x3f));
740 
                                        gp[0] = 0;
741 
                                        break;
742 
                                case SHLI:
743 
                                        gp[Rt] = (gp[Ra] << Rb);
744 
                                        gp[0] = 0;
745 
                                        break;
746 
                                }
747 
                        }
748 
                        imm_prefix = false;
749 
                        return;
750 
 
751 
                case STP:
752 
                        b1 = ReadByte(pc);
753 
                        pc++;
754 
                        b2 = ReadByte(pc);
755 
                        pc++;
756 
                        imm_prefix = false;
757 
                        return;
758 
 
759 
                case SW:
760 
                        b1 = ReadByte(pc);
761 
                        pc++;
762 
                        b2 = ReadByte(pc);
763 
                        pc++;
764 
                        b3 = ReadByte(pc);
765 
                        pc++;
766 
                        if (ex) {
767 
                                Rb = ((b2 & 0xF) << 2) | (( b1 >> 6) & 3);
768 
                                dRn(b1,b2,b3,&Ra,&Sg,&disp);
769 
                                ea = (unsigned __int64) disp + seg_base[Sg] + gp[Ra];
770 
                                system1->Write(ea,gp[Rb],(0xFF << (ea & 7)) & 0xFF);
771 
                        }
772 
                        imm_prefix = false;
773 
                        return;
774 
 
775 
                }
776 
        }
777 
}

powered by: WebSVN 2.1.0

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