![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68030ops.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0|
Return to m68030ops.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0 |
1.1 root 1: //
2: // nono
1.1.1.2 root 3: // Copyright (C) 2020 nono project
4: // Licensed under nono-license.txt
1.1 root 5: //
6:
7: // %0000_000000_mmmrrr ORI.B #<imm>,<ea>
8: // %0000_000000_111100 ORI.B #<imm>,CCR
9: OP_DEF(ori_b)
10: {
11: uint n = RegIR & 0x3f;
12:
13: uint32 src = m68030_fetch_16(cpu) & 0xff;
14: if (n < 8) {
15: // ORI.B #<imm>,Dn
16: CYCLE(2);
17: uint32 dst = (RegD(n) & 0xff) | src;
18: acc_move_8(cpu, dst);
19: RegD(n) = (RegD(n) & 0xffffff00) | dst;
20: } else if (n == 0b111100) {
21: // ORI.B #<imm>,SR
22: CYCLE2(12, 14);
23: CCR.Set(CCR.Get() | src);
24: } else {
25: // ORI.B #<imm>,<ea>
26: CYCLE2(3, 4);
27: uint32 ea = cea_data_8(cpu);
28: uint32 dst = m68030_read_8(cpu, ea);
29: dst |= src;
30: acc_move_8(cpu, dst);
31: m68030_write_8(cpu, ea, dst);
32: }
33: }
34:
35: // %0000_000001_mmmrrr ORI.W #<imm>,<ea>
36: // %0000_000001_111100 ORI.W #<imm>,SR
37: OP_DEF(ori_w)
38: {
39: uint n = RegIR & 0x3f;
40:
41: if (n < 8) {
42: // ORI.W #<imm>,Dn
43: CYCLE(2);
44: uint32 src = m68030_fetch_16(cpu);
45: uint32 dst = (RegD(n) & 0xffff) | src;
46: acc_move_16(cpu, dst);
47: RegD(n) = (RegD(n) & 0xffff0000) | dst;
48: } else if (n == 0b111100) {
49: // ORI.W #<imm>,SR
50: SUPERVISOR_OP;
51: CYCLE2(12, 14);
52: uint32 src = m68030_fetch_16(cpu);
53: m68030_set_sr(cpu, RegSR | src);
54: } else {
55: // ORI.W #<imm>,<ea>
56: CYCLE2(3, 4);
57: uint32 src = m68030_fetch_16(cpu);
58: uint32 ea = cea_data_16(cpu);
59: uint32 dst = m68030_read_16(cpu, ea);
60: dst |= src;
61: acc_move_16(cpu, dst);
62: m68030_write_16(cpu, ea, dst);
63: }
64: }
65:
66: // %0000_000010_mmmrrr ORI.L #<imm>,<ea>
67: OP_DEF(ori_l)
68: {
69: uint n = RegIR & 0x3f;
70:
71: uint32 src = m68030_fetch_32(cpu);
72: if (n < 8) {
73: // ORI.L #<imm>,Dn
74: CYCLE(2);
75: RegD(n) |= src;
76: acc_move_32(cpu, RegD(n));
77: } else {
78: // ORI.L #<imm>,<ea>
79: CYCLE2(3, 4);
80: uint32 ea = cea_data_32(cpu);
81: uint32 dst = m68030_read_32(cpu, ea);
82: dst |= src;
83: acc_move_32(cpu, dst);
84: m68030_write_32(cpu, ea, dst);
85: }
86: }
87:
88: // %0000_000011_mmmrrr CMP2/CHK2.B <ea>,Rn
89: OP_DEF(cmp2chk2_b)
90: {
91: RegIR2 = m68030_fetch_16(cpu);
92: uint32 compare;
93: uint32 ea = cea_ctrl(cpu);
94: uint32 lower;
95: uint32 upper;
96:
97: if ((RegIR2 & 0x8000) == 0) {
98: // compare が Dn
99: compare = (int32)(int8)(RegR(RegIR2 >> 12) & 0xff);
100: } else {
101: // compare が An
102: compare = RegR(RegIR2 >> 12);
103: }
104:
105: // 本当は PC 相対ならプログラム空間アクセス、
106: // それ以外はデータ空間アクセスだが、ここでは区別しない。
107: lower = (int32)(int8)m68030_read_8(cpu, ea);
108: upper = (int32)(int8)m68030_read_8(cpu, ea + 1);
109:
110: acc_chk2cmp2_32(cpu, compare, lower, upper);
111:
112: // サイクル数はこれは実際には全部最大値
113: if ((RegIR2 & 0x0800)) {
114: // CHK2 で条件を満たしていれば例外
115: if (RegCondCS) {
116: CYCLE2(40, 42);
117: m68030_exception(cpu, M68K_EXCEP_CHK);
118: } else {
119: CYCLE(18);
120: }
121: } else {
122: // CMP2
123: CYCLE(20);
124: }
125: }
126:
127: // MOVEP.[WL] (d,Ay),Dx と
128: // MOVEP.[WL] Dx,(d,Ay) の共通部分。
1.1.1.2 root 129: static void
1.1 root 130: ops_movep(m68kcpu *cpu)
131: {
132: uint32 disp = (int32)(int16)m68030_fetch_16(cpu);
133: uint32 ea = RegAY + disp;
134: bool size_long = ((RegIR & 0x40) != 0);
135: bool reg2mem = ((RegIR & 0x80) != 0);
136:
137: CYCLE(14);
138:
139: if (reg2mem) {
140: // Dx -> memory
141: uint32 dx = RegDX;
142: if (size_long) {
143: m68030_write_8(cpu, ea, (dx >> 24));
144: ea += 2;
145: m68030_write_8(cpu, ea, (dx >> 16) & 0xff);
146: ea += 2;
147: }
148: m68030_write_8(cpu, ea, (dx >> 8) & 0xff);
149: ea += 2;
150: m68030_write_8(cpu, ea, (dx & 0xff));
151: } else {
152: // memory -> Dx
153: uint32 dx = 0;
154: if (size_long) {
155: dx = m68030_read_8(cpu, ea);
156: dx <<= 8;
157: ea += 2;
158: dx |= m68030_read_8(cpu, ea);
159: dx <<= 8;
160: ea += 2;
161: }
162: // word
163: dx |= m68030_read_8(cpu, ea);
164: dx <<= 8;
165: ea += 2;
166: dx |= m68030_read_8(cpu, ea);
167:
168: if (size_long) {
169: RegDX = dx;
170: } else {
171: RegDX = (RegDX & 0xffff0000) | (dx & 0xffff);
172: }
173: }
174: }
175:
176: // %0000_xxx100_000yyy BTST.L Dx,Dy
177: // %0000_xxx100_001yyy MOVEP.W (d,Ay),Dx
178: // %0000_xxx100_mmmrrr BTST.B Dx,<ea>
179: OP_DEF(btst_dn_ea)
180: {
181: uint n = RegIR & 0x3f;
182:
183: if (n < 8) {
184: // BTST.L Dx,Dy
185: CYCLE(4);
186: uint bit = (RegDX & 31);
187: acc_btst(cpu, RegDY, bit);
188: } else if (n < 16) {
189: // MOVEP.W (d,Ay),Dx
190: ops_movep(cpu);
191: } else {
192: // BTST.B Dx,<ea>
193: CYCLE(4);
194: uint bit = (RegDX & 7);
195: uint32 data = fea_data_8(cpu);
196: acc_btst(cpu, data, bit);
197: }
198: }
199:
200: // %0000_xxx101_000yyy BCHG.L Dx,Dy
201: // %0000_xxx101_001yyy MOVEP.L (d,Ay),Dx
202: // %0000_xxx101_mmmrrr BCHG.B Dx,<ea>
203: OP_DEF(bchg_dn_ea)
204: {
205: uint n = RegIR & 0x3f;
206:
207: if (n < 8) {
208: // BCHG.L Dx,Dy
209: CYCLE(6);
210: uint bit = (RegDX & 31);
211: RegDY = acc_bchg(cpu, RegDY, bit);
212: } else if (n < 16) {
213: // MOVEP.L (d,Ay),Dx
214: ops_movep(cpu);
215: } else {
216: // BCHG.B Dx,<ea>
217: CYCLE(6);
218: uint bit = (RegDX & 7);
219: uint32 ea = cea_data_8(cpu);
220: uint32 data = m68030_read_8(cpu, ea);
221: data = acc_bchg(cpu, data, bit);
222: m68030_write_8(cpu, ea, data);
223: }
224: }
225:
226: // %0000_xxx110_000yyy BCLR.L Dx,Dy
227: // %0000_xxx110_001yyy MOVEP.W Dx,(d,Ay)
228: // %0000_xxx110_mmmrrr BCLR.B Dx,<ea>
229: OP_DEF(bclr_dn_ea)
230: {
231: uint n = RegIR & 0x3f;
232:
233: if (n < 8) {
234: // BCLR.L Dx,Dy
235: CYCLE(6);
236: uint bit = (RegDX & 31);
237: RegDY = acc_bclr(cpu, RegDY, bit);
238: } else if (n < 16) {
239: // MOVEP.W Dx,(d,Ay)
240: ops_movep(cpu);
241: } else {
242: // BCLR.B Dx,<ea>
243: CYCLE(6);
244: uint bit = (RegDX & 7);
245: uint32 ea = cea_data_8(cpu);
246: uint32 data = m68030_read_8(cpu, ea);
247: data = acc_bclr(cpu, data, bit);
248: m68030_write_8(cpu, ea, data);
249: }
250: }
251:
252: // %0000_xxx111_000yyy BSET.L Dx,Dy
253: // %0000_xxx111_001yyy MOVEP.L Dx,(d,Ay)
254: // %0000_xxx111_mmmrrr BSET.B Dx,<ea>
255: OP_DEF(bset_dn_ea)
256: {
257: uint n = RegIR & 0x3f;
258:
259: if (n < 8) {
260: // BSET.L Dx,Dy
261: CYCLE(6);
262: uint bit = (RegDX & 31);
263: RegDY = acc_bset(cpu, RegDY, bit);
264: } else if (n < 16) {
265: // MOVEP.L Dx,(d,Ay)
266: ops_movep(cpu);
267: } else {
268: // BSET.B Dx,<ea>
269: CYCLE(6);
270: uint bit = (RegDX & 7);
271: uint32 ea = cea_data_8(cpu);
272: uint32 data = m68030_read_8(cpu, ea);
273: data = acc_bset(cpu, data, bit);
274: m68030_write_8(cpu, ea, data);
275: }
276: }
277:
278: // %0000_001000_mmmrrr ANDI.B #<imm>,<ea>
279: // %0000_001000_111100 ANDI.B #<imm>,CCR
280: OP_DEF(andi_b)
281: {
282: uint n = RegIR & 0x3f;
283:
284: uint32 src = m68030_fetch_16(cpu) & 0xff;
285: if (n < 8) {
286: // ANDI.B #<imm>,Dn
287: CYCLE(2);
288: uint32 dst = RegD(n) & 0xff;
289: dst &= src;
290: acc_move_8(cpu, dst);
291: RegD(n) = (RegD(n) & 0xffffff00) | dst;
292: } else if (n == 0b111100) {
293: // ANDI.B #<imm>,CCR
294: CYCLE2(12, 14);
295: CCR.Set(CCR.Get() & src);
296: } else {
297: // ANDI.B #<imm>,<ea>
298: CYCLE2(3, 4);
299: uint32 ea = cea_data_8(cpu);
300: uint32 dst = m68030_read_8(cpu, ea);
301: dst &= src;
302: acc_move_8(cpu, dst);
303: m68030_write_8(cpu, ea, dst);
304: }
305: }
306:
307: // %0000_001001_mmmrrr ANDI.W #<imm>,<ea>
308: // %0000_001001_111100 ANDI.W #<imm>,SR
309: OP_DEF(andi_w)
310: {
311: uint n = RegIR & 0x3f;
312:
313: if (n < 8) {
314: // ANDI.W #<imm>,Dn
315: CYCLE(2);
316: uint32 src = m68030_fetch_16(cpu);
317: uint32 dst = RegD(n) & 0xffff;
318: dst &= src;
319: acc_move_16(cpu, dst);
320: RegD(n) = (RegD(n) & 0xffff0000) | dst;
321: } else if (n == 0b111100) {
322: // ANDI.W #<imm>,SR
323: SUPERVISOR_OP;
324: CYCLE2(12, 14);
325: uint32 src = m68030_fetch_16(cpu);
326: m68030_set_sr(cpu, RegSR & src);
327: } else {
328: // ANDI.W #<imm>,<ea>
329: CYCLE2(3, 4);
330: uint32 src = m68030_fetch_16(cpu);
331: uint32 ea = cea_data_16(cpu);
332: uint32 dst = m68030_read_16(cpu, ea);
333: dst &= src;
334: acc_move_16(cpu, dst);
335: m68030_write_16(cpu, ea, dst);
336: }
337: }
338:
339: // %0000_001010_mmmrrr ANDI.L #<imm>,<ea>
340: OP_DEF(andi_l)
341: {
342: uint n = RegIR & 0x3f;
343:
344: uint32 src = m68030_fetch_32(cpu);
345: if (n < 8) {
346: // ANDI.L #<imm>,Dn
347: CYCLE(2);
348: RegD(n) &= src;
349: acc_move_32(cpu, RegD(n));
350: } else {
351: // ANDI.L #<imm>,<ea>
352: CYCLE2(3, 4);
353: uint32 ea = cea_data_32(cpu);
354: uint32 dst = m68030_read_32(cpu, ea);
355: dst &= src;
356: acc_move_32(cpu, dst);
357: m68030_write_32(cpu, ea, dst);
358: }
359: }
360:
361: // %0000_001011_mmmrrr CMP2/CHK2.W <ea>,Rn
362: OP_DEF(cmp2chk2_w)
363: {
364: RegIR2 = m68030_fetch_16(cpu);
365: uint32 compare;
366: uint32 ea = cea_ctrl(cpu);
367: uint32 lower;
368: uint32 upper;
369:
370: if ((RegIR2 & 0x8000) == 0) {
371: // compare が Dn
372: compare = (int32)(int16)(RegR(RegIR2 >> 12) & 0xffff);
373: } else {
374: // compare が An
375: compare = RegR(RegIR2 >> 12);
376: }
377:
378: // 本当は PC 相対ならプログラム空間アクセス、
379: // それ以外はデータ空間アクセスだが、ここでは区別しない。
380: lower = (int32)(int16)m68030_read_16(cpu, ea);
381: upper = (int32)(int16)m68030_read_16(cpu, ea + 2);
382:
383: acc_chk2cmp2_32(cpu, compare, lower, upper);
384:
385: // サイクル数はこれは実際には全部最大値
386: if ((RegIR2 & 0x0800)) {
387: // CHK2 で条件を満たしていれば例外
388: if (RegCondCS) {
389: CYCLE2(40, 42);
390: m68030_exception(cpu, M68K_EXCEP_CHK);
391: } else {
392: CYCLE(18);
393: }
394: } else {
395: // CMP2
396: CYCLE(20);
397: }
398: }
399:
400: // %0000_010000_mmmrrr SUBI.B #<imm>,<ea>
401: OP_DEF(subi_b)
402: {
403: uint n = RegIR & 0x3f;
404:
405: uint32 src = m68030_fetch_16(cpu) & 0xff;
406: if (n < 8) {
407: // SUBI.B #<imm>,Dn
408: CYCLE(2);
409: uint32 dst = RegD(n) & 0xff;
410: dst = acc_sub_8(cpu, src, dst);
411: RegD(n) = (RegD(n) & 0xffffff00) | dst;
412: } else {
413: // SUBI.B #<imm>,<ea>
414: CYCLE2(3, 4);
415: uint32 ea = cea_data_8(cpu);
416: uint32 dst = m68030_read_8(cpu, ea);
417: dst = acc_sub_8(cpu, src, dst);
418: m68030_write_8(cpu, ea, dst);
419: }
420: }
421:
422: // %0000_010001_mmmrrr SUBI.W #<imm>,<ea>
423: OP_DEF(subi_w)
424: {
425: uint n = RegIR & 0x3f;
426:
427: uint32 src = m68030_fetch_16(cpu);
428: if (n < 8) {
429: // SUBI.W #<imm>,Dn
430: CYCLE(2);
431: uint32 dst = RegD(n) & 0xffff;
432: dst = acc_sub_16(cpu, src, dst);
433: RegD(n) = (RegD(n) & 0xffff0000) | dst;
434: } else {
435: // SUBI.W #<imm>,<ea>
436: CYCLE2(3, 4);
437: uint32 ea = cea_data_16(cpu);
438: uint32 dst = m68030_read_16(cpu, ea);
439: dst = acc_sub_16(cpu, src, dst);
440: m68030_write_16(cpu, ea, dst);
441: }
442: }
443:
444: // %0000_010010_mmmrrr SUBI.L #<imm>,<ea>
445: OP_DEF(subi_l)
446: {
447: uint n = RegIR & 0x3f;
448:
449: uint32 src = m68030_fetch_32(cpu);
450: if (n < 8) {
451: // SUBI.L #<imm>,Dn
452: CYCLE(2);
453: RegD(n) = acc_sub_32(cpu, src, RegD(n));
454: } else {
455: // SUBI.L #<imm>,<ea>
456: CYCLE2(3, 4);
457: uint32 ea = cea_data_32(cpu);
458: uint32 dst = m68030_read_32(cpu, ea);
459: dst = acc_sub_32(cpu, src, dst);
460: m68030_write_32(cpu, ea, dst);
461: }
462: }
463:
464: // %0000_010011_mmmrrr CMP2/CHK2.L <ea>,Rn
465: OP_DEF(cmp2chk2_l)
466: {
467: RegIR2 = m68030_fetch_16(cpu);
468: uint32 compare = RegR(RegIR2 >> 12);
469: uint32 ea = cea_ctrl(cpu);
470: uint32 lower;
471: uint32 upper;
472:
473: // 本当は PC 相対ならプログラム空間アクセス、
474: // それ以外はデータ空間アクセスだが、ここでは区別しない。
475: lower = m68030_read_32(cpu, ea);
476: upper = m68030_read_32(cpu, ea + 4);
477:
478: acc_chk2cmp2_32(cpu, compare, lower, upper);
479:
480: // サイクル数はこれは実際には全部最大値
481: if ((RegIR2 & 0x0800)) {
482: // CHK2 で条件を満たしていれば例外
483: if (RegCondCS) {
484: CYCLE2(40, 42);
485: m68030_exception(cpu, M68K_EXCEP_CHK);
486: } else {
487: CYCLE(18);
488: }
489: } else {
490: // CMP2
491: CYCLE(20);
492: }
493: }
494:
495: // %0000_011000_mmmrrr ADDI.B #<imm>,<ea>
496: OP_DEF(addi_b)
497: {
498: uint n = RegIR & 0x3f;
499:
500: uint32 src = m68030_fetch_16(cpu) & 0xff;
501: if (n < 8) {
502: // ADDI.B #<imm>,Dn
503: CYCLE(2);
504: uint32 dst = RegD(n) & 0xff;
505: dst = acc_add_8(cpu, src, dst);
506: RegD(n) = (RegD(n) & 0xffffff00) | dst;
507: } else {
508: // ADDI.B #<imm>,<ea>
509: CYCLE2(3, 4);
510: uint32 ea = cea_data_8(cpu);
511: uint32 dst = m68030_read_8(cpu, ea);
512: dst = acc_add_8(cpu, src, dst);
513: m68030_write_8(cpu, ea, dst);
514: }
515: }
516:
517: // %0000_011001_mmmrrr ADDI.W #<imm>,<ea>
518: OP_DEF(addi_w)
519: {
520: uint n = RegIR & 0x3f;
521:
522: uint32 src = m68030_fetch_16(cpu);
523: if (n < 8) {
524: // ADDI.W #<imm>,Dn
525: CYCLE(2);
526: uint32 dst = RegD(n) & 0xffff;
527: dst = acc_add_16(cpu, src, dst);
528: RegD(n) = (RegD(n) & 0xffff0000) | dst;
529: } else {
530: // ADDI.W #<imm>,<ea>
531: CYCLE2(3, 4);
532: uint32 ea = cea_data_16(cpu);
533: uint32 dst = m68030_read_16(cpu, ea);
534: dst = acc_add_16(cpu, src, dst);
535: m68030_write_16(cpu, ea, dst);
536: }
537: }
538:
539: // %0000_011010_mmmrrr ADDI.L #<imm>,<ea>
540: OP_DEF(addi_l)
541: {
542: uint n = RegIR & 0x3f;
543:
544: uint32 src = m68030_fetch_32(cpu);
545: if (n < 8) {
546: // ADDI.L #<imm>,Dn
547: CYCLE(2);
548: RegD(n) = acc_add_32(cpu, src, RegD(n));
549: } else {
550: // ADDI.L #<imm>,<ea>
551: CYCLE2(3, 4);
552: uint32 ea = cea_data_32(cpu);
553: uint32 dst = m68030_read_32(cpu, ea);
554: dst = acc_add_32(cpu, src, dst);
555: m68030_write_32(cpu, ea, dst);
556: }
557: }
558:
1.1.1.3 ! root 559: // %0000_011011_00nnnn RTM Rn
! 560: // %0000_011011_mmmrrr CALLM #<imm>,<ea>
! 561: OP_DEF(callm)
! 562: {
! 563: op_illegal(cpu);
! 564: }
! 565:
1.1 root 566: // %0000_100000_000yyy BTST.L #<imm>,Dy
567: // %0000_100000_mmmrrr BTST.B #<imm>,<ea>
568: OP_DEF(btst_imm_ea)
569: {
570: uint n = RegIR & 0x3f;
571:
572: if (n < 8) {
573: // BTST.L #<imm>,Dy
574: CYCLE(4);
575: uint bit = m68030_fetch_16(cpu) & 31;
576: acc_btst(cpu, RegDY, bit);
577: } else if (n == 0x3c) {
578: // BTST.B #<imm>,<ea> の <ea> には #imm はない
579: op_illegal(cpu);
580: } else {
581: // BTST.B #<imm>,<ea>
582: CYCLE(4);
583: uint bit = m68030_fetch_16(cpu) & 7;
584: uint32 data = fea_data_8(cpu);
585: acc_btst(cpu, data, bit);
586: }
587: }
588:
589: // %0000_100001_000yyy BCHG.L #<imm>,Dy
590: // %0000_100001_mmmrrr BCHG.B #<imm>,<ea>
591: OP_DEF(bchg_imm_ea)
592: {
593: uint n = RegIR & 0x3f;
594:
595: if (n < 8) {
596: // BCHG.L #<imm>,Dy
597: CYCLE(6);
598: uint bit = m68030_fetch_16(cpu) & 31;
599: RegDY = acc_bchg(cpu, RegDY, bit);
600: } else if (n == 0x3c) {
601: // BCHG.B #<imm>,<ea> の <ea> には #imm はない
602: op_illegal(cpu);
603: } else {
604: // BCHG.B #<imm>,<ea>
605: CYCLE(6);
606: uint bit = m68030_fetch_16(cpu) & 7;
607: uint32 ea = cea_data_8(cpu);
608: uint32 data = m68030_read_8(cpu, ea);
609: data = acc_bchg(cpu, data, bit);
610: m68030_write_8(cpu, ea, data);
611: }
612: }
613:
614: // %0000_100010_000yyy BCLR.L #<imm>,Dy
615: // %0000_100010_mmmrrr BCLR.B #<imm>,<ea>
616: OP_DEF(bclr_imm_ea)
617: {
618: uint n = RegIR & 0x3f;
619:
620: if (n < 8) {
621: // BCLR.L #<imm>,Dy
622: CYCLE(6);
623: uint bit = m68030_fetch_16(cpu) & 31;
624: RegDY = acc_bclr(cpu, RegDY, bit);
625: } else if (n == 0x3c) {
626: // BCLR.B #<imm>,<ea> の <ea> には #imm はない
627: op_illegal(cpu);
628: } else {
629: // BCLR.B #<imm>,<ea>
630: CYCLE(6);
631: uint bit = m68030_fetch_16(cpu) & 7;
632: uint32 ea = cea_data_8(cpu);
633: uint32 data = m68030_read_8(cpu, ea);
634: data = acc_bclr(cpu, data, bit);
635: m68030_write_8(cpu, ea, data);
636: }
637: }
638:
639: // %0000_100011_000yyy BSET.L #<imm>,Dy
640: // %0000_100011_mmmrrr BSET.B #<imm>,<ea>
641: OP_DEF(bset_imm_ea)
642: {
643: uint n = RegIR & 0x3f;
644:
645: if (n < 8) {
646: // BSET.L #<imm>,Dy
647: CYCLE(6);
648: uint bit = m68030_fetch_16(cpu) & 31;
649: RegDY = acc_bset(cpu, RegDY, bit);
650: } else if (n == 0x3c) {
651: // BSET.B #<imm>,<ea> の <ea> には #imm はない
652: op_illegal(cpu);
653: } else {
654: // BSET.B #<imm>,<ea>
655: CYCLE(6);
656: uint bit = m68030_fetch_16(cpu) & 7;
657: uint32 ea = cea_data_8(cpu);
658: uint32 data = m68030_read_8(cpu, ea);
659: data = acc_bset(cpu, data, bit);
660: m68030_write_8(cpu, ea, data);
661: }
662: }
663:
664: // %0000_101000_mmmrrr EORI.B #<imm>,<ea>
665: // %0000_101000_111100 EORI.B #<imm>,CCR
666: OP_DEF(eori_b)
667: {
668: uint n = RegIR & 0x3f;
669:
670: uint32 src = m68030_fetch_16(cpu) & 0xff;
671: if (n < 8) {
672: // EORI.B #<imm>,Dn
673: CYCLE(2);
674: uint32 dst = (RegD(n) & 0xff) ^ src;
675: acc_move_8(cpu, dst);
676: RegD(n) = (RegD(n) & 0xffffff00) | dst;
677: } else if (n == 0b111100) {
678: // EORI.B #<imm>,SR
679: CYCLE2(12, 14);
680: CCR.Set(CCR.Get() ^ src);
681: } else {
682: // EORI.B #<imm>,<ea>
683: CYCLE2(3, 4);
684: uint32 ea = cea_data_8(cpu);
685: uint32 dst = m68030_read_8(cpu, ea);
686: dst ^= src;
687: acc_move_8(cpu, dst);
688: m68030_write_8(cpu, ea, dst);
689: }
690: }
691:
692: // %0000_101001_mmmrrr EORI.W #<imm>,<ea>
693: // %0000_101001_111100 EORI.W #<imm>,SR
694: OP_DEF(eori_w)
695: {
696: uint n = RegIR & 0x3f;
697:
698: if (n < 8) {
699: // EORI.W #<imm>,Dn
700: CYCLE(2);
701: uint32 src = m68030_fetch_16(cpu);
702: uint32 dst = (RegD(n) & 0xffff) ^ src;
703: acc_move_16(cpu, dst);
704: RegD(n) = (RegD(n) & 0xffff0000) | dst;
705: } else if (n == 0b111100) {
706: // EORI.W #<imm>,SR
707: SUPERVISOR_OP;
708: CYCLE2(12, 14);
709: uint32 src = m68030_fetch_16(cpu);
710: m68030_set_sr(cpu, RegSR ^ src);
711: } else {
712: // EORI.W #<imm>,<ea>
713: CYCLE2(3, 4);
714: uint32 src = m68030_fetch_16(cpu);
715: uint32 ea = cea_data_16(cpu);
716: uint32 dst = m68030_read_16(cpu, ea);
717: dst ^= src;
718: acc_move_16(cpu, dst);
719: m68030_write_16(cpu, ea, dst);
720: }
721: }
722:
723: // %0000_101010_mmmrrr EORI.L #<imm>,<ea>
724: OP_DEF(eori_l)
725: {
726: uint n = RegIR & 0x3f;
727:
728: uint32 src = m68030_fetch_32(cpu);
729: if (n < 8) {
730: // EORI.L #<imm>,Dn
731: CYCLE(2);
732: RegD(n) ^= src;
733: acc_move_32(cpu, RegD(n));
734: } else {
735: // EORI.L #<imm>,<ea>
736: CYCLE2(3, 4);
737: uint32 ea = cea_data_32(cpu);
738: uint32 dst = m68030_read_32(cpu, ea);
739: dst ^= src;
740: acc_move_32(cpu, dst);
741: m68030_write_32(cpu, ea, dst);
742: }
743: }
744:
745: // %0000_101011_mmmrrr CAS.B Dc,Du,<ea>
746: OP_DEF(cas_b)
747: {
748: RegIR2 = m68030_fetch_16(cpu);
749: uint c = RegIR2 & 7;
750: uint u = (RegIR2 >> 6) & 7;
751: uint32 dc = RegD(c) & 0xff;
752: uint32 du = RegD(u) & 0xff;
753: uint ea = cea_data_8(cpu);
754: uint32 dst = m68030_read_8(cpu, ea);
755:
756: acc_cmp_8(cpu, dc, dst);
757: if (CCR.IsZ()) {
758: // 等しければ、Du -> dst
759: CYCLE(13);
760: m68030_write_8(cpu, ea, du);
761: } else {
762: // そうでなければ、dst -> Dc
763: CYCLE(11);
764: RegD(c) = (RegD(c) & 0xffffff00) | dst;
765: }
766: }
767:
768: // %0000_110000_mmmrrr CMPI.B #<imm>,<ea>
769: OP_DEF(cmpi_b)
770: {
771: uint n = RegIR & 0x3f;
772:
773: // CMPI はデータアドレッシングだが #imm がないことに注意
774: if (n == 0x3c) {
775: op_illegal(cpu);
776: return;
777: }
778: CYCLE(2);
779: uint32 src = m68030_fetch_16(cpu) & 0xff;
780: uint32 dst = fea_data_8(cpu);
781: acc_cmp_8(cpu, src, dst);
782: }
783:
784: // %0000_110001_mmmrrr CMPI.W #<imm>,<ea>
785: OP_DEF(cmpi_w)
786: {
787: uint n = RegIR & 0x3f;
788:
789: // CMPI はデータアドレッシングだが #imm がないことに注意
790: if (n == 0x3c) {
791: op_illegal(cpu);
792: return;
793: }
794: CYCLE(2);
795: uint32 src = m68030_fetch_16(cpu);
796: uint32 dst = fea_data_16(cpu);
797: acc_cmp_16(cpu, src, dst);
798: }
799:
800: // %0000_110010_mmmrrr CMPI.L #<imm>,<ea>
801: OP_DEF(cmpi_l)
802: {
803: uint n = RegIR & 0x3f;
804:
805: // CMPI はデータアドレッシングだが #imm がないことに注意
806: if (n == 0x3c) {
807: op_illegal(cpu);
808: return;
809: }
810: CYCLE(2);
811: uint32 src = m68030_fetch_32(cpu);
812: uint32 dst = fea_data_32(cpu);
813: acc_cmp_32(cpu, src, dst);
814: }
815:
816: // %0000_110011_mmmrrr CAS.W Dc,Du,<ea>
817: // %0000_110011_111100 CAS2.W Dc1:Dc2,Du1:Du2,(Rn1):(Rn2)
818: OP_DEF(cas_w)
819: {
820: uint n = RegIR & 0x3f;
821:
822: if (n == 0x3c) {
823: // CAS2.W Dc1:Dc2,Du1:Du2,(Rn1):(Rn2)
824: RegIR2 = m68030_fetch_16(cpu);
825: uint32 ir3 = m68030_fetch_16(cpu);
826: uint c1 = RegIR2 & 7;
827: uint u1 = (RegIR2 >> 6) & 7;
828: uint r1 = RegIR2 >> 12;
829: uint c2 = ir3 & 7;
830: uint u2 = (ir3 >> 6) & 7;
831: uint r2 = ir3 >> 12;
832: uint32 dc1 = RegD(c1) & 0xffff;
833: uint32 du1 = RegD(u1) & 0xffff;
834: uint32 ea1 = RegR(r1);
835: uint32 dc2 = RegD(c2) & 0xffff;
836: uint32 du2 = RegD(u2) & 0xffff;
837: uint32 ea2 = RegR(r2);
838:
839: uint32 dst1 = m68030_read_16(cpu, ea1);
840: uint32 dst2 = m68030_read_16(cpu, ea2);
841: acc_cmp_16(cpu, dc1, dst1);
842: if (CCR.IsZ()) {
843: acc_cmp_16(cpu, dc2, dst2);
844: if (CCR.IsZ()) {
845: // 更新オペランド -> デスティネーション
846: CYCLE2(0, 2); // これは成功時の追加分
847: m68030_write_16(cpu, ea1, du1);
848: m68030_write_16(cpu, ea2, du2);
849: }
850: }
851: // デスティネーション -> 比較オペランド
852: CYCLE(24); // 本当はこれは最大値
853: RegD(c1) = (RegD(c1) & 0xffff0000) | dst1;
854: RegD(c2) = (RegD(c2) & 0xffff0000) | dst2;
855: } else {
856: // CAS.W Dc,Du,<ea>
857: RegIR2 = m68030_fetch_16(cpu);
858: uint c = RegIR2 & 7;
859: uint u = (RegIR2 >> 6) & 7;
860: uint32 dc = RegD(c) & 0xffff;
861: uint32 du = RegD(u) & 0xffff;
862: uint ea = cea_data_16(cpu);
863: uint32 dst = m68030_read_16(cpu, ea);
864:
865: acc_cmp_16(cpu, dc, dst);
866: if (CCR.IsZ()) {
867: // 等しければ、Du -> dst
868: CYCLE(13);
869: m68030_write_16(cpu, ea, du);
870: } else {
871: // そうでなければ、dst -> Dc
872: CYCLE(11);
873: RegD(c) = (RegD(c) & 0xffff0000) | dst;
874: }
875: }
876: }
877:
878: // %0000_111000_mmmrrr MOVES.B <ea>,Rn
879: // %0000_111000_mmmrrr MOVES.B Rn,<ea>
880: OP_DEF(moves_b)
881: {
882: SUPERVISOR_OP;
883:
884: RegIR2 = m68030_fetch_16(cpu);
885: uint n = RegIR2 >> 12;
886: uint ea;
887: uint32 data;
888:
889: if ((RegIR & 0x3f) < 16) {
890: op_illegal(cpu);
891: return;
892: }
893:
894: ea = cea_data_8(cpu);
895: if ((RegIR2 & 0x0800) == 0) {
896: // <ea>,Rn
897: CYCLE(7);
898: data = m68030_read_8_fc(cpu, ea);
899: if (n < 8) { // Dn
900: RegD(n) = (RegD(n) & 0xffffff00) | data;
901: } else { // An
902: RegR(n) = (int32)(int8)data;
903: }
904: } else {
905: // Rn,<ea>
906: CYCLE2(5, 6);
907: data = RegR(n) & 0xff;
908: m68030_write_8_fc(cpu, ea, data);
909: }
910: }
911:
912: // %0000_111001_mmmrrr MOVES.W <ea>,Rn
913: // %0000_111001_mmmrrr MOVES.W Rn,<ea>
914: OP_DEF(moves_w)
915: {
916: SUPERVISOR_OP;
917:
918: RegIR2 = m68030_fetch_16(cpu);
919: uint n = RegIR2 >> 12;
920: uint ea;
921: uint32 data;
922:
923: if ((RegIR & 0x3f) < 16) {
924: op_illegal(cpu);
925: return;
926: }
927:
928: ea = cea_data_16(cpu);
929: if ((RegIR2 & 0x0800) == 0) {
930: // <ea>,Rn
931: CYCLE(7);
932: data = m68030_read_16_fc(cpu, ea);
933: if (n < 8) { // Dn
934: RegD(n) = (RegD(n) & 0xffff0000) | data;
935: } else { // An
936: RegR(n) = (int32)(int16)data;
937: }
938: } else {
939: // Rn,<ea>
940: CYCLE2(5, 6);
941: data = RegR(n) & 0xffff;
942: m68030_write_16_fc(cpu, ea, data);
943: }
944: }
945:
946: // %0000_111010_mmmrrr MOVES.L <ea>,Rn
947: // %0000_111010_mmmrrr MOVES.L Rn,<ea>
948: OP_DEF(moves_l)
949: {
950: SUPERVISOR_OP;
951:
952: RegIR2 = m68030_fetch_16(cpu);
953: uint n = RegIR2 >> 12;
954: uint ea;
955: uint32 data;
956:
957: if ((RegIR & 0x3f) < 16) {
958: op_illegal(cpu);
959: return;
960: }
961:
962: ea = cea_data_32(cpu);
963: if ((RegIR2 & 0x0800) == 0) {
964: // <ea>,Rn
965: CYCLE(7);
966: data = m68030_read_32_fc(cpu, ea);
967: RegR(n) = data;
968: } else {
969: // Rn,<ea>
970: CYCLE2(5, 6);
971: data = RegR(n);
972: m68030_write_32_fc(cpu, ea, data);
973: }
974: }
975:
976: // %0000_111011_mmmrrr CAS.L Dc,Du,<ea>
977: // %0000_111011_111100 CAS2.L Dc1:Dc2,Du1:Du2,(Rn1):(Rn2)
978: OP_DEF(cas_l)
979: {
980: uint n = RegIR & 0x3f;
981:
982: if (n == 0x3c) {
983: // CAS2.L Dc1:Dc2,Du1:Du2,(Rn1):(Rn2)
984: RegIR2 = m68030_fetch_16(cpu);
985: uint32 ir3 = m68030_fetch_16(cpu);
986: uint c1 = RegIR2 & 7;
987: uint u1 = (RegIR2 >> 6) & 7;
988: uint r1 = RegIR2 >> 12;
989: uint c2 = ir3 & 7;
990: uint u2 = (ir3 >> 6) & 7;
991: uint r2 = ir3 >> 12;
992: uint32 dc1 = RegD(c1);
993: uint32 du1 = RegD(u1);
994: uint32 ea1 = RegR(r1);
995: uint32 dc2 = RegD(c2);
996: uint32 du2 = RegD(u2);
997: uint32 ea2 = RegR(r2);
998:
999: uint32 dst1 = m68030_read_32(cpu, ea1);
1000: uint32 dst2 = m68030_read_32(cpu, ea2);
1001: acc_cmp_32(cpu, dc1, dst1);
1002: if (CCR.IsZ()) {
1003: acc_cmp_32(cpu, dc2, dst2);
1004: if (CCR.IsZ()) {
1005: // 更新オペランド -> デスティネーション
1006: CYCLE2(0, 2); // これは成功時の追加分
1007: m68030_write_32(cpu, ea1, du1);
1008: m68030_write_32(cpu, ea2, du2);
1009: }
1010: }
1011: // デスティネーション -> 比較オペランド
1012: CYCLE(24); // 本当はこれは最大値
1013: RegD(c1) = dst1;
1014: RegD(c2) = dst2;
1015: } else {
1016: // CAS.L Dc,Du,<ea>
1017: RegIR2 = m68030_fetch_16(cpu);
1018: uint c = RegIR2 & 7;
1019: uint u = (RegIR2 >> 6) & 7;
1020: uint32 dc = RegD(c);
1021: uint32 du = RegD(u);
1022: uint ea = cea_data_32(cpu);
1023: uint32 dst = m68030_read_32(cpu, ea);
1024:
1025: acc_cmp_32(cpu, dc, dst);
1026: if (CCR.IsZ()) {
1027: // 等しければ、Du -> dst
1028: CYCLE(13);
1029: m68030_write_32(cpu, ea, du);
1030: } else {
1031: // そうでなければ、dst -> Dc
1032: CYCLE(11);
1033: RegD(c) = dst;
1034: }
1035: }
1036: }
1037:
1038: // %0001_xxx000_mmmrrr MOVE.B <ea>,Dx
1039: OP_DEF(move_b_ea_dn)
1040: {
1041: CYCLE(2);
1042: uint32 data = fea_all_8(cpu);
1043: acc_move_8(cpu, data);
1044: RegDX = (RegDX & 0xffffff00) | data;
1045: }
1046:
1047: // %0001_xxx010_mmmrrr MOVE.B <ea>,(Ax)
1048: OP_DEF(move_b_ea_anin)
1049: {
1050: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1051: CYCLE2(4, 5);
1052: uint32 data = fea_all_8(cpu);
1053: uint32 ea = cea_anin(cpu, RegIRX);
1054: acc_move_8(cpu, data);
1055: m68030_write_8(cpu, ea, data);
1056: }
1057:
1058: // %0001_xxx011_mmmrrr MOVE.B <ea>,(Ax)+
1059: OP_DEF(move_b_ea_anpi)
1060: {
1061: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1062: CYCLE2(4, 5);
1063: uint32 data = fea_all_8(cpu);
1064: uint32 ea = cea_anpi_8(cpu, RegIRX);
1065: acc_move_8(cpu, data);
1066: m68030_write_8(cpu, ea, data);
1067: }
1068:
1069: // %0001_xxx100_mmmrrr MOVE.B <ea>,-(Ax)
1070: OP_DEF(move_b_ea_anpd)
1071: {
1072: // 実際にはソースがレジスタなら (4, 4)、メモリなら (4, 5)
1073: CYCLE2(4, 5);
1074: uint32 data = fea_all_8(cpu);
1075: uint32 ea = cea_anpd_8(cpu, RegIRX);
1076: acc_move_8(cpu, data);
1077: m68030_write_8(cpu, ea, data);
1078: }
1079:
1080: // %0001_xxx101_mmmrrr MOVE.B <ea>,d16(Ax)
1081: OP_DEF(move_b_ea_andi)
1082: {
1083: CYCLE2(4, 5);
1084: uint32 data = fea_all_8(cpu);
1085: uint32 ea = cea_andi(cpu, RegIRX);
1086: acc_move_8(cpu, data);
1087: m68030_write_8(cpu, ea, data);
1088: }
1089:
1090: // %0001_xxx110_mmmrrr MOVE.B <ea>,(Ax,IX)
1091: OP_DEF(move_b_ea_anix)
1092: {
1093: // XXX 実際にはdstのフォーマットによって(8,9)-(20,23)
1094: CYCLE2(16, 18);
1095: uint32 data = fea_all_8(cpu);
1096: uint32 ea = cea_anix(cpu, RegIRX);
1097: acc_move_8(cpu, data);
1098: m68030_write_8(cpu, ea, data);
1099: }
1100:
1101: // %0001_000111_mmmrrr MOVE.B <ea>,Abs.W
1102: OP_DEF(move_b_ea_absw)
1103: {
1104: CYCLE2(4, 5);
1105: uint32 data = fea_all_8(cpu);
1106: uint32 ea = cea_absw(cpu);
1107: acc_move_8(cpu, data);
1108: m68030_write_8(cpu, ea, data);
1109: }
1110:
1111: // %0001_001111_mmmrrr MOVE.B <ea>,Abs.L
1112: OP_DEF(move_b_ea_absl)
1113: {
1114: CYCLE2(6, 7);
1115: uint32 data = fea_all_8(cpu);
1116: uint32 ea = cea_absl(cpu);
1117: acc_move_8(cpu, data);
1118: m68030_write_8(cpu, ea, data);
1119: }
1120:
1121: // %0010_xxx000_mmmrrr MOVE.L <ea>,Dx
1122: OP_DEF(move_l_ea_dn)
1123: {
1124: CYCLE(2);
1125: uint32 data = fea_all_32(cpu);
1126: acc_move_32(cpu, data);
1127: RegDX = data;
1128: }
1129:
1130: // %0010_xxx001_mmmrrr MOVEA.L <ea>,Ax
1131: OP_DEF(movea_l)
1132: {
1133: CYCLE(2);
1134: uint32 data = fea_all_32(cpu);
1135: RegAX = data;
1136: }
1137:
1138: // %0010_xxx010_mmmrrr MOVE.L <ea>,(Ax)
1139: OP_DEF(move_l_ea_anin)
1140: {
1141: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1142: CYCLE2(4, 5);
1143: uint32 data = fea_all_32(cpu);
1144: uint32 ea = cea_anin(cpu, RegIRX);
1145: acc_move_32(cpu, data);
1146: m68030_write_32(cpu, ea, data);
1147: }
1148:
1149: // %0010_xxx011_mmmrrr MOVE.L <ea>,(Ax)+
1150: OP_DEF(move_l_ea_anpi)
1151: {
1152: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1153: CYCLE2(4, 5);
1154: uint32 data = fea_all_32(cpu);
1155: uint32 ea = cea_anpi_32(cpu, RegIRX);
1156: acc_move_32(cpu, data);
1157: m68030_write_32(cpu, ea, data);
1158: }
1159:
1160: // %0010_xxx100_mmmrrr MOVE.L <ea>,-(Ax)
1161: OP_DEF(move_l_ea_anpd)
1162: {
1163: // 実際にはソースがレジスタなら (4, 4)、メモリなら (4, 5)
1164: CYCLE2(4, 5);
1165: uint32 data = fea_all_32(cpu);
1166: uint32 ea = cea_anpd_32(cpu, RegIRX);
1167: acc_move_32(cpu, data);
1168: m68030_write_32(cpu, ea, data);
1169: }
1170:
1171: // %0010_xxx101_mmmrrr MOVE.L <ea>,d16(Ax)
1172: OP_DEF(move_l_ea_andi)
1173: {
1174: CYCLE2(4, 5);
1175: uint32 data = fea_all_32(cpu);
1176: uint32 ea = cea_andi(cpu, RegIRX);
1177: acc_move_32(cpu, data);
1178: m68030_write_32(cpu, ea, data);
1179: }
1180:
1181: // %0010_xxx110_mmmrrr MOVE.L <ea>,(Ax,IX)
1182: OP_DEF(move_l_ea_anix)
1183: {
1184: // XXX 実際にはdstのフォーマットによって(8,9)-(20,23)
1185: CYCLE2(16, 18);
1186: uint32 data = fea_all_32(cpu);
1187: uint32 ea = cea_anix(cpu, RegIRX);
1188: acc_move_32(cpu, data);
1189: m68030_write_32(cpu, ea, data);
1190: }
1191:
1192: // %0010_000111_mmmrrr MOVE.L <ea>,Abs.W
1193: OP_DEF(move_l_ea_absw)
1194: {
1195: CYCLE2(4, 5);
1196: uint32 data = fea_all_32(cpu);
1197: uint32 ea = cea_absw(cpu);
1198: acc_move_32(cpu, data);
1199: m68030_write_32(cpu, ea, data);
1200: }
1201:
1202: // %0010_001111_mmmrrr MOVE.L <ea>,Abs.L
1203: OP_DEF(move_l_ea_absl)
1204: {
1205: CYCLE2(6, 7);
1206: uint32 data = fea_all_32(cpu);
1207: uint32 ea = cea_absl(cpu);
1208: acc_move_32(cpu, data);
1209: m68030_write_32(cpu, ea, data);
1210: }
1211:
1212: // %0011_xxx000_mmmrrr MOVE.W <ea>,Dx
1213: OP_DEF(move_w_ea_dn)
1214: {
1215: CYCLE(2);
1216: uint32 data = fea_all_16(cpu);
1217: acc_move_16(cpu, data);
1218: RegDX = (RegDX & 0xffff0000) | data;
1219: }
1220:
1221: // %0011_xxx001_mmmrrr MOVEA.W <ea>,Ax
1222: OP_DEF(movea_w)
1223: {
1224: CYCLE(2);
1225: uint32 data = (int32)(int16)fea_all_16(cpu);
1226: RegAX = data;
1227: }
1228:
1229: // %0011_xxx010_mmmrrr MOVE.W <ea>,(Ax)
1230: OP_DEF(move_w_ea_anin)
1231: {
1232: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1233: CYCLE2(4, 5);
1234: uint32 data = fea_all_16(cpu);
1235: uint32 ea = cea_anin(cpu, RegIRX);
1236: acc_move_16(cpu, data);
1237: m68030_write_16(cpu, ea, data);
1238: }
1239:
1240: // %0011_xxx011_mmmrrr MOVE.W <ea>,(Ax)+
1241: OP_DEF(move_w_ea_anpi)
1242: {
1243: // 実際にはソースがレジスタなら (3, 4)、メモリなら (4, 5)
1244: CYCLE2(4, 5);
1245: uint32 data = fea_all_16(cpu);
1246: uint32 ea = cea_anpi_16(cpu, RegIRX);
1247: acc_move_16(cpu, data);
1248: m68030_write_16(cpu, ea, data);
1249: }
1250:
1251: // %0011_xxx100_mmmrrr MOVE.W <ea>,-(Ax)
1252: OP_DEF(move_w_ea_anpd)
1253: {
1254: // 実際にはソースがレジスタなら (4, 4)、メモリなら (4, 5)
1255: CYCLE2(4, 5);
1256: uint32 data = fea_all_16(cpu);
1257: uint32 ea = cea_anpd_16(cpu, RegIRX);
1258: acc_move_16(cpu, data);
1259: m68030_write_16(cpu, ea, data);
1260: }
1261:
1262: // %0011_xxx101_mmmrrr MOVE.W <ea>,d16(Ax)
1263: OP_DEF(move_w_ea_andi)
1264: {
1265: CYCLE2(4, 5);
1266: uint32 data = fea_all_16(cpu);
1267: uint32 ea = cea_andi(cpu, RegIRX);
1268: acc_move_16(cpu, data);
1269: m68030_write_16(cpu, ea, data);
1270: }
1271:
1272: // %0011_xxx110_mmmrrr MOVE.W <ea>,(Ax,IX)
1273: OP_DEF(move_w_ea_anix)
1274: {
1275: // XXX 実際にはdstのフォーマットによって(8,9)-(20,23)
1276: CYCLE2(16, 18);
1277: uint32 data = fea_all_16(cpu);
1278: uint32 ea = cea_anix(cpu, RegIRX);
1279: acc_move_16(cpu, data);
1280: m68030_write_16(cpu, ea, data);
1281: }
1282:
1283: // %0011_000111_mmmrrr MOVE.W <ea>,Abs.W
1284: OP_DEF(move_w_ea_absw)
1285: {
1286: CYCLE2(4, 5);
1287: uint32 data = fea_all_16(cpu);
1288: uint32 ea = cea_absw(cpu);
1289: acc_move_16(cpu, data);
1290: m68030_write_16(cpu, ea, data);
1291: }
1292:
1293: // %0011_001111_mmmrrr MOVE.W <ea>,Abs.L
1294: OP_DEF(move_w_ea_absl)
1295: {
1296: CYCLE2(6, 7);
1297: uint32 data = fea_all_16(cpu);
1298: uint32 ea = cea_absl(cpu);
1299: acc_move_16(cpu, data);
1300: m68030_write_16(cpu, ea, data);
1301: }
1302:
1303: // %0100_000000_mmmrrr NEGX.B <ea>
1304: OP_DEF(negx_b)
1305: {
1306: uint n = RegIR & 0x3f;
1307:
1308: if (n < 8) {
1309: // NEGX.B Dn
1310: CYCLE(2);
1311: uint32 data = RegD(n) & 0xff;
1312: data = acc_subx_8(cpu, data, 0);
1313: RegD(n) = (RegD(n) & 0xffffff00) | data;
1314: } else if (n < 16) {
1315: op_illegal(cpu);
1316: } else {
1317: // NEGX.B <ea>
1318: CYCLE2(3, 4);
1319: uint32 ea = cea_data_8(cpu);
1320: uint32 data = m68030_read_8(cpu, ea);
1321: data = acc_subx_8(cpu, data, 0);
1322: m68030_write_8(cpu, ea, data);
1323: }
1324: }
1325:
1326: // %0100_000001_mmmrrr NEGX.W <ea>
1327: OP_DEF(negx_w)
1328: {
1329: uint n = RegIR & 0x3f;
1330:
1331: if (n < 8) {
1332: // NEGX.W Dn
1333: CYCLE(2);
1334: uint32 data = RegD(n) & 0xffff;
1335: data = acc_subx_16(cpu, data, 0);
1336: RegD(n) = (RegD(n) & 0xffff0000) | data;
1337: } else if (n < 16) {
1338: op_illegal(cpu);
1339: } else {
1340: // NEGX.W <ea>
1341: CYCLE2(3, 4);
1342: uint32 ea = cea_data_16(cpu);
1343: uint32 data = m68030_read_16(cpu, ea);
1344: data = acc_subx_16(cpu, data, 0);
1345: m68030_write_16(cpu, ea, data);
1346: }
1347: }
1348:
1349: // %0100_000010_mmmrrr NEGX.L <ea>
1350: OP_DEF(negx_l)
1351: {
1352: uint n = RegIR & 0x3f;
1353:
1354: if (n < 8) {
1355: // NEGX.L Dn
1356: CYCLE(2);
1357: RegD(n) = acc_subx_32(cpu, RegD(n), 0);
1358: } else if (n < 16) {
1359: op_illegal(cpu);
1360: } else {
1361: // NEGX.L <ea>
1362: CYCLE2(3, 4);
1363: uint32 ea = cea_data_32(cpu);
1364: uint32 data = m68030_read_32(cpu, ea);
1365: data = acc_subx_32(cpu, data, 0);
1366: m68030_write_32(cpu, ea, data);
1367: }
1368: }
1369:
1370: // %0100_000011_mmmrrr MOVE.W SR,<ea>
1371: OP_DEF(move_sr_ea)
1372: {
1373: SUPERVISOR_OP;
1374:
1375: uint n = RegIR & 0x3f;
1376: if (n < 8) {
1377: // MOVE.W SR,Dn
1378: CYCLE(4);
1379: RegD(n) = (RegD(n) & 0xffff0000) | RegSR;
1380: } else {
1381: // MOVE.W SR,<ea>
1382: CYCLE2(4, 5);
1383: uint32 ea = cea_data_16(cpu);
1384: m68030_write_16(cpu, ea, RegSR);
1385: }
1386: }
1387:
1388: // %0100_xxx100_mmmrrr CHK.L <ea>,Dx
1389: OP_DEF(chk_l)
1390: {
1391: uint32 dst = RegDX;
1392: acc_move_32(cpu, dst);
1393: if (CCR.IsN()) {
1394: // これは最大値で次の条件式が成立した時の値なので、
1395: // 実際にはこれより小さい確定した値のはずだけど。
1396: CYCLE2(28, 30);
1397: m68030_exception(cpu, M68K_EXCEP_CHK);
1398: return;
1399: }
1400: // 本当はこうじゃないけど、とりあえず
1401: uint32 src = fea_data_32(cpu);
1402: if ((int32)dst > (int32)src) {
1403: CYCLE2(28, 30);
1404: CCR.ClrN();
1405: m68030_exception(cpu, M68K_EXCEP_CHK);
1406: return;
1407: }
1408: CYCLE(8);
1409: }
1410:
1411: // %0100_xxx110_mmmrrr CHK.W <ea>,Dx
1412: OP_DEF(chk_w)
1413: {
1414: uint32 dst = RegDX & 0xffff;
1415: acc_move_16(cpu, dst);
1416: if (CCR.IsN()) {
1417: // これは最大値で次の条件式が成立した時の値なので、
1418: // 実際にはこれより小さい確定した値のはずだけど。
1419: CYCLE2(28, 30);
1420: m68030_exception(cpu, M68K_EXCEP_CHK);
1421: return;
1422: }
1423: // 本当はこうじゃないけど、とりあえず
1424: uint32 src = fea_data_16(cpu);
1425: if ((int16)dst > (int16)src) {
1426: CYCLE2(28, 30);
1427: CCR.ClrN();
1428: m68030_exception(cpu, M68K_EXCEP_CHK);
1429: return;
1430: }
1431: CYCLE(8);
1432: }
1433:
1434: // %0100_xxx111_mmmrrr LEA.L <ea>,Ax
1435: // %0100_100111_000yyy EXTB.L Dy
1436: OP_DEF(lea)
1437: {
1438: uint n = RegIR & 0x3f;
1439:
1440: if (n < 8) {
1441: // EXTB.L Dy
1442: CYCLE(4);
1443: RegDY = (int32)(int8)(RegDY & 0xff);
1444: acc_move_32(cpu, RegDY);
1445: } else {
1446: // LEA.L <ea>,Ax
1447: CYCLE(2);
1448: RegAX = cea_ctrl(cpu);
1449: }
1450: }
1451:
1452: // %0100_001000_mmmrrr CLR.B <ea>
1453: OP_DEF(clr_b)
1454: {
1455: uint n = RegIR & 0x3f;
1456:
1457: if (n < 8) {
1458: // CLR.B Dn
1459: CYCLE(2);
1460: RegDY &= 0xffffff00;
1461: acc_move_8(cpu, 0);
1462: } else {
1463: // CLR.B <ea>
1464: CYCLE2(3, 4);
1465: uint32 ea = cea_data_8(cpu);
1466: acc_move_8(cpu, 0);
1467: m68030_write_8(cpu, ea, 0);
1468: }
1469: }
1470:
1471: // %0100_001001_mmmrrr CLR.W <ea>
1472: OP_DEF(clr_w)
1473: {
1474: uint n = RegIR & 0x3f;
1475:
1476: if (n < 8) {
1477: // CLR.W Dn
1478: CYCLE(2);
1479: RegDY &= 0xffff0000;
1480: acc_move_16(cpu, 0);
1481: } else {
1482: // CLR.W <ea>
1483: CYCLE2(3, 4);
1484: uint32 ea = cea_data_16(cpu);
1485: acc_move_16(cpu, 0);
1486: m68030_write_16(cpu, ea, 0);
1487: }
1488: }
1489:
1490: // %0100_001010_mmmrrr CLR.L <ea>
1491: OP_DEF(clr_l)
1492: {
1493: uint n = RegIR & 0x3f;
1494:
1495: if (n < 8) {
1496: // CLR.L Dn
1497: CYCLE(2);
1498: RegDY = 0;
1499: acc_move_32(cpu, 0);
1500: } else {
1501: // CLR.L <ea>
1502: CYCLE2(3, 4);
1503: uint32 ea = cea_data_32(cpu);
1504: acc_move_32(cpu, 0);
1505: m68030_write_32(cpu, ea, 0);
1506: }
1507: }
1508:
1509: // %0100_001011_mmmrrr MOVE.W CCR,<ea>
1510: OP_DEF(move_ccr_ea)
1511: {
1512: uint n = RegIR & 0x3f;
1513:
1514: // 転送は16ビットで行われ、上位バイトと未実装ビットは %0 になる。
1515: if (n < 8) {
1516: // MOVE.W CCR,Dn
1517: CYCLE(4);
1518: RegD(n) = (RegD(n) & 0xffff0000) | CCR.Get();
1519: } else if (n < 16) {
1520: // MOVE.W CCR,An はない
1521: op_illegal(cpu);
1522: } else {
1523: // MOVE.W CCR,<ea>
1524: CYCLE2(4, 5);
1525: uint32 ea = cea_data_16(cpu);
1526: m68030_write_16(cpu, ea, CCR.Get());
1527: }
1528: }
1529:
1530: // %0100_010000_mmmrrr NEG.B <ea>
1531: OP_DEF(neg_b)
1532: {
1533: uint n = RegIR & 0x3f;
1534:
1535: if (n < 8) {
1536: // NEG.B Dn
1537: CYCLE(2);
1538: uint32 data = acc_sub_8(cpu, RegD(n) & 0xff, 0);
1539: RegD(n) = (RegD(n) & 0xffffff00) | data;
1540: } else {
1541: // NEG.B <ea>
1542: CYCLE2(3, 4);
1543: uint32 ea = cea_data_8(cpu);
1544: uint32 data = m68030_read_8(cpu, ea);
1545: data = acc_sub_8(cpu, data, 0);
1546: m68030_write_8(cpu, ea, data);
1547: }
1548: }
1549:
1550: // %0100_010001_mmmrrr NEG.W <ea>
1551: OP_DEF(neg_w)
1552: {
1553: uint n = RegIR & 0x3f;
1554:
1555: if (n < 8) {
1556: // NEG.W Dn
1557: CYCLE(2);
1558: uint32 data = acc_sub_16(cpu, RegD(n) & 0xffff, 0);
1559: RegD(n) = (RegD(n) & 0xffff0000) | data;
1560: } else {
1561: // NEG.W <ea>
1562: CYCLE2(3, 4);
1563: uint32 ea = cea_data_16(cpu);
1564: uint32 data = m68030_read_16(cpu, ea);
1565: data = acc_sub_16(cpu, data, 0);
1566: m68030_write_16(cpu, ea, data);
1567: }
1568: }
1569:
1570: // %0100_010010_mmmrrr NEG.L <ea>
1571: OP_DEF(neg_l)
1572: {
1573: uint n = RegIR & 0x3f;
1574:
1575: if (n < 8) {
1576: // NEG.L Dn
1577: CYCLE(2);
1578: RegD(n) = acc_sub_32(cpu, RegD(n), 0);
1579: } else {
1580: // NEG.L <ea>
1581: CYCLE2(3, 4);
1582: uint32 ea = cea_data_32(cpu);
1583: uint32 data = m68030_read_32(cpu, ea);
1584: data = acc_sub_32(cpu, data, 0);
1585: m68030_write_32(cpu, ea, data);
1586: }
1587: }
1588:
1589: // %0100_010011_mmmrrr MOVE.W <ea>,CCR
1590: OP_DEF(move_ea_ccr)
1591: {
1592: uint n = RegIR & 0x3f;
1593:
1594: if (n < 8) {
1595: // MOVE.W Dn,CCR
1596: CYCLE(4);
1597: uint32 data = RegD(n) & 0xff;
1598: CCR.Set(data);
1599: } else if (n < 16) {
1600: // MOVE.W An,CCR はない
1601: op_illegal(cpu);
1602: } else {
1603: // MOVE.W <ea>,CCR
1604: CYCLE(4);
1605: uint32 data = fea_data_16(cpu);
1606: CCR.Set(data);
1607: }
1608: }
1609:
1610: // %0100_011000_mmmrrr NOT.B <ea>
1611: OP_DEF(not_b)
1612: {
1613: uint n = RegIR & 0x3f;
1614:
1615: if (n < 8) {
1616: // NOT.B Dn
1617: CYCLE(2);
1618: uint32 data = (~RegD(n)) & 0xff;
1619: acc_move_8(cpu, data);
1620: RegD(n) = (RegD(n) & 0xffffff00) | data;
1621: } else {
1622: // NOT.B <ea>
1623: CYCLE2(3, 4);
1624: uint32 ea = cea_data_8(cpu);
1625: uint32 data = m68030_read_8(cpu, ea);
1626: data = (~data) & 0xff;
1627: acc_move_8(cpu, data);
1628: m68030_write_8(cpu, ea, data);
1629: }
1630: }
1631:
1632: // %0100_011001_mmmrrr NOT.W <ea>
1633: OP_DEF(not_w)
1634: {
1635: uint n = RegIR & 0x3f;
1636:
1637: if (n < 8) {
1638: // NOT.W Dn
1639: CYCLE(2);
1640: uint32 data = (~RegD(n)) & 0xffff;
1641: acc_move_16(cpu, data);
1642: RegD(n) = (RegD(n) & 0xffff0000) | data;
1643: } else {
1644: // NOT.W <ea>
1645: CYCLE2(3, 4);
1646: uint32 ea = cea_data_16(cpu);
1647: uint32 data = m68030_read_16(cpu, ea);
1648: data = (~data) & 0xffff;
1649: acc_move_16(cpu, data);
1650: m68030_write_16(cpu, ea, data);
1651: }
1652: }
1653:
1654: // %0100_011010_mmmrrr NOT.L <ea>
1655: OP_DEF(not_l)
1656: {
1657: uint n = RegIR & 0x3f;
1658:
1659: if (n < 8) {
1660: // NOT.L Dn
1661: CYCLE(2);
1662: RegD(n) = ~RegD(n);
1663: acc_move_32(cpu, RegD(n));
1664: } else {
1665: // NOT.L <ea>
1666: CYCLE2(3, 4);
1667: uint32 ea = cea_data_32(cpu);
1668: uint32 data = m68030_read_32(cpu, ea);
1669: data = ~data;
1670: acc_move_32(cpu, data);
1671: m68030_write_32(cpu, ea, data);
1672: }
1673: }
1674:
1675: // %0100_011011_mmmrrr MOVE.W <ea>,SR
1676: OP_DEF(move_ea_sr)
1677: {
1678: CYCLE2(8, 10);
1679: uint16 data = fea_data_16(cpu);
1680: m68030_set_sr(cpu, data);
1681: }
1682:
1683: // %0100_100000_mmmrrr NBCD.B <ea>
1684: // %0100_100000_001yyy LINK.L Ay,#<imm>
1685: OP_DEF(nbcd)
1686: {
1687: uint n = RegIR & 0x3f;
1688: int32 imm;
1689:
1690: if (n < 8) {
1691: // NBCD.B Dn
1692: CYCLE(6);
1693: uint32 dst = RegDY & 0xff;
1694: dst = acc_sbcd_8(cpu, dst, 0);
1695: RegDY = (RegDY & 0xffffff00) | dst;
1696: } else if (n == 0x0e) {
1697: // LINK.L A6,#<imm>
1698: CYCLE2(6, 7);
1699: // レジスタやスタックを変更する前にフェッチしないと、
1700: // ページフォルトで再実行できなくなる
1701: imm = m68030_fetch_32(cpu);
1702: // ページフォルトに備えて保存する
1703: m68030_save_reg_pd(cpu, 7);
1704: m68030_push_32(cpu, RegA(6));
1705: RegA(6) = RegA(7);
1706: RegA(7) += imm;
1707: } else if (n < 16) {
1708: // LINK.L An,#<imm>
1709: CYCLE2(6, 7);
1710: // レジスタやスタックを変更する前にフェッチしないと、
1711: // ページフォルトで再実行できなくなる
1712: imm = m68030_fetch_32(cpu);
1713: // ページフォルトに備えて保存する
1714: m68030_save_reg_pd(cpu, 7);
1715: m68030_push_32(cpu, RegAY);
1716: RegAY = RegA(7);
1717: RegA(7) += imm;
1718: } else {
1719: // NBCD.B <ea>
1720: CYCLE(6);
1721: uint32 ea = cea_data_8(cpu);
1722: uint32 dst = m68030_read_8(cpu, ea);
1723: dst = acc_sbcd_8(cpu, dst, 0);
1724: m68030_write_8(cpu, ea, dst);
1725: }
1726: }
1727:
1728: // %0100_100001_000yyy SWAP.W Dy
1729: // %0100_100001_001nnn BKPT #<imm>
1730: // %0100_100001_mmmrrr PEA.L <ea>
1731: OP_DEF(pea)
1732: {
1733: uint n = RegIR & 0x3f;
1734:
1735: if (n < 8) {
1736: // SWAP.W Dy
1737: CYCLE(4);
1738: RegD(n) = (RegD(n) << 16) | (RegD(n) >> 16);
1739: acc_move_32(cpu, RegD(n));
1740: } else if (n < 16) {
1741: // BKPT #<imm>
1742: // ブレークポイント・アクノリッジサイクルに応答するデバイスはないので
1743: // 常に不当命令にする。
1744: CYCLE(9); // ?
1745: op_illegal(cpu);
1746: } else {
1747: // PEA.L <ea>
1748: CYCLE(4);
1749: uint32 ea = cea_ctrl(cpu);
1750: // ページフォルトに備えて保存する
1751: m68030_save_reg_pd(cpu, 7);
1752: m68030_push_32(cpu, ea);
1753: }
1754: }
1755:
1756: // MOVEM.[WL] <list>,<ea> の共通部分。
1757: // bytesize は1レジスタ分のサイズ、.Wなら2、.Lなら4。
1758: template<int bytesize> void
1759: ops_movem_list_ea(m68kcpu *cpu)
1760: {
1761: uint32 ea;
1762: int regcount;
1763:
1764: // 不当な第1ワードを弾く
1765: #define INVALID(x) (0xffULL << (56 - ((x) * 8)))
1766: const uint64 valid =
1767: INVALID(0) // Dn
1768: | INVALID(1) // An
1769: | INVALID(3) // (An)+
1770: | 0x3fL; // (PC)...
1771: if ((int64)(valid << (RegIR & 0x3f)) < 0) {
1772: op_illegal(cpu);
1773: return;
1774: }
1775:
1776: // 第2ワードは EA が正当な場合のみ EA より先にフェッチ
1777: RegIR2 = m68030_fetch_16(cpu);
1778:
1779: // EA 取得。MOVEM だけ別対応
1780: // | M -WXZ | MOVEM list,<ea>
1781: // だが、不当 EA はすでに弾いてあるので cea_data でいい
1782: if (bytesize == 2) {
1783: ea = cea_data_16(cpu);
1784: } else {
1785: ea = cea_data_32(cpu);
1786: }
1787:
1788: regcount = 0;
1789: uint list = RegIR2;
1790: if (eamode(RegIR) == 4/*-(An)*/) {
1791: // -(An) の場合 reglist の格納順が逆(転送順は LSB から)
1792: // bit15 bit0
1793: // D0 D1 D2 D3 D4 D5 D6 D7 A0 A1 A2 A3 A4 A5 A6 A7
1794: while (list) {
1795: int ctz = __builtin_ctz(list);
1796: if (bytesize == 2) {
1797: m68030_write_16(cpu, ea, RegR(15 - ctz) & 0xffff);
1798: } else {
1799: m68030_write_32(cpu, ea, RegR(15 - ctz));
1800: }
1801: ea -= bytesize;
1802: regcount++;
1803: // 処理した最下位ビットを落とす
1804: list &= list - 1;
1805: }
1806: // ea は一つ行き過ぎるので補正
1807: RegAY = ea + bytesize;
1808: } else {
1809: // LSB 側から転送
1810: // bit15 bit0
1811: // A7 A6 A5 A4 A4 A2 A1 A0 D7 D6 D5 D4 D3 D2 D1 D0
1812: while (list) {
1813: int ctz = __builtin_ctz(list);
1814: if (bytesize == 2) {
1815: m68030_write_16(cpu, ea, RegR(ctz) & 0xffff);
1816: } else {
1817: m68030_write_32(cpu, ea, RegR(ctz));
1818: }
1819: ea += bytesize;
1820: regcount++;
1821: // 処理した最下位ビットを落とす
1822: list &= list - 1;
1823: }
1824: }
1825:
1826: CYCLE(4 + 2 * regcount);
1827: }
1828:
1829: // %0100_100010_000yyy EXT.W Dy
1830: // %0100_100010_mmmrrr MOVEM.W <list>,<ea>
1831: OP_DEF(movem_w_mem)
1832: {
1833: uint n = RegIR & 0x3f;
1834:
1835: if (n < 8) {
1836: // EXT.W Dy
1837: CYCLE(4);
1838: uint16 data = (int16)(int8)(RegDY & 0xff);
1839: acc_move_16(cpu, data);
1840: RegDY = (RegDY & 0xffff0000) | data;
1841: } else {
1842: // MOVEM.W <list>,<ea>
1843: ops_movem_list_ea<2>(cpu);
1844: }
1845: }
1846:
1847: // %0100_100011_000yyy EXT.L Dy
1848: // %0100_100011_mmmrrr MOVEM.L <list>,<ea>
1849: OP_DEF(movem_l_mem)
1850: {
1851: uint n = RegIR & 0x3f;
1852:
1853: if (n < 8) {
1854: // EXT.L Dy
1855: CYCLE(4);
1856: RegDY = (int32)(int16)(RegDY & 0x0000ffff);
1857: acc_move_32(cpu, RegDY);
1858: } else {
1859: // MOVEM.L <list>,<ea>
1860: ops_movem_list_ea<4>(cpu);
1861: }
1862: }
1863:
1864: // %0100_101000_mmmrrr TST.B <ea>
1865: OP_DEF(tst_b)
1866: {
1867: CYCLE(2);
1868: uint32 data = fea_all_8(cpu);
1869: acc_move_8(cpu, data);
1870: }
1871:
1872: // %0100_101001_mmmrrr TST.W <ea>
1873: OP_DEF(tst_w)
1874: {
1875: CYCLE(2);
1876: uint32 data = fea_all_16(cpu);
1877: acc_move_16(cpu, data);
1878: }
1879:
1880: // %0100_101010_mmmrrr TST.L <ea>
1881: OP_DEF(tst_l)
1882: {
1883: CYCLE(2);
1884: uint32 data = fea_all_32(cpu);
1885: acc_move_32(cpu, data);
1886: }
1887:
1888: // %0100_101011_mmmrrr TAS.B <ea>
1889: // %0100_101011_111100 ILLEGAL
1890: OP_DEF(tas)
1891: {
1892: uint n = RegIR & 0x3f;
1893:
1894: if (n < 8) {
1895: // TAS.B Dn
1896: // リード・モディファイ・ライトという概念はない
1897: CYCLE(4);
1898: uint32 data = RegD(n);
1899: acc_move_8(cpu, data);
1900: RegD(n) |= 0x80;
1901: } else if (n == 0x3c) {
1902: // ILLEGAL
1903: op_illegal(cpu);
1904: } else {
1905: // TAS.B <ea>
1906: // リード・モディファイ・ライトという概念はない
1907: CYCLE(12);
1908: uint32 ea = cea_data_8(cpu);
1909: uint32 data = m68030_read_8(cpu, ea);
1910: acc_move_8(cpu, data);
1911: m68030_write_8(cpu, ea, (data | 0x80));
1912: }
1913: }
1914:
1915: // %0100_110000_mmmrrr MUL{U,S}.L <ea>,Dl
1916: OP_DEF(mul)
1917: {
1918: // 2ワード目
1919: // %0LLL_Ss0000_000HHH
1920: // +++ || +++- Dh
1921: // | |+------------ %1:64bit, %0:32bit
1922: // | +------------- %1:MULS, %0:MULU
1923: // +---------------- Dl
1924: RegIR2 = m68030_fetch_16(cpu);
1925: int h = RegIR2 & 7;
1926: int l = (RegIR2 >> 12) & 7;
1927:
1928: CYCLE(44); // XXX これは本当は最大値だけど
1929: switch ((RegIR2 >> 10) & 3) {
1930: case 0:
1931: {
1932: // MULU.L <ea>,Dl
1933: uint32 src = fea_data_32(cpu);
1934: uint32 dst = RegD(l);
1935: RegD(l) = acc_mulu_32(cpu, src, dst);
1936: break;
1937: }
1938:
1939: case 1:
1940: {
1941: // MULU.L <ea>,Dh:Dl
1942: uint32 src = fea_data_32(cpu);
1943: uint32 dst = RegD(l);
1944: uint64 res = acc_mulu_64(cpu, src, dst);
1945: // h == l の時は未定義なので考えない。
1946: RegD(h) = res >> 32;
1947: RegD(l) = res;
1948: break;
1949: }
1950:
1951: case 2:
1952: {
1953: // MULS.L <ea>,Dl
1954: uint32 src = fea_data_32(cpu);
1955: uint32 dst = RegD(l);
1956: RegD(l) = acc_muls_32(cpu, src, dst);
1957: break;
1958: }
1959:
1960: case 3:
1961: {
1962: // MULS.L <ea>,Dh:Dl
1963: uint32 src = fea_data_32(cpu);
1964: uint32 dst = RegD(l);
1965: uint64 res = acc_muls_64(cpu, src, dst);
1966: // h == l の時は未定義なので考えない。
1967: RegD(h) = res >> 32;
1968: RegD(l) = res;
1969: break;
1970: }
1971:
1972: default:
1973: __unreachable();
1974: }
1975: }
1976:
1977: // %0100_110001_mmmrrr DIVU.L <ea>,Dq
1978: // %0100_110001_mmmrrr DIVU.L <ea>,Dr:Dq
1979: // %0100_110001_mmmrrr DIVUL.L <ea>,Dr:Dq
1980: // %0100_110001_mmmrrr DIVS.L <ea>,Dq
1981: // %0100_110001_mmmrrr DIVS.L <ea>,Dr:Dq
1982: // %0100_110001_mmmrrr DIVSL.L <ea>,Dr:Dq
1983: OP_DEF(div)
1984: {
1985: // 2ワード目
1986: // %0QQQ_Ss0000_000RRR
1987: // +++ || +++- Dr
1988: // | |+------------ %1:64bit, %0:32bit
1989: // | +------------- %1:DIVS, %0:DIVU
1990: // +---------------- Dq
1991: RegIR2 = m68030_fetch_16(cpu);
1992: int r = RegIR2 & 7;
1993: int q = (RegIR2 >> 12) & 7;
1994:
1995: switch ((RegIR2 >> 10) & 3) {
1996: case 0:
1997: {
1998: // DIVU.L <ea>,Dq
1999: // DIVUL.L <ea>,Dr:Dq
2000: CYCLE(78); // XXX これは本当は最大値だけど
2001: uint32 src = fea_data_32(cpu);
2002: uint32 dst = RegD(q);
2003: uint32 quo;
2004: uint32 rem;
2005: if (acc_divu_32_32(cpu, src, dst, &quo, &rem)) {
2006: // r == q の場合 quo が残るので、rem を先に書く
2007: RegD(r) = rem;
2008: RegD(q) = quo;
2009: }
2010: break;
2011: }
2012:
2013: case 1: // DIVU.L <ea>,Dr:Dq
2014: {
2015: CYCLE(78); // XXX これは本当は最大値だけど
2016: uint32 src = fea_data_32(cpu);
2017: uint64 dst = (((uint64)RegD(r)) << 32) | RegD(q);
2018: uint32 quo;
2019: uint32 rem;
2020: if (acc_divu_64_32(cpu, src, dst, &quo, &rem)) {
2021: RegD(r) = rem;
2022: RegD(q) = quo;
2023: }
2024: break;
2025: }
2026:
2027: case 2:
2028: {
2029: // DIVS.L <ea>,Dq
2030: // DIVSL.L <ea>,Dr:Dq
2031: CYCLE(90); // XXX これは本当は最大値だけど
2032: uint32 src = fea_data_32(cpu);
2033: uint32 dst = RegD(q);
2034: uint32 quo;
2035: uint32 rem;
2036: if (acc_divs_32_32(cpu, src, dst, &quo, &rem)) {
2037: // r == q の場合 quo が残るので、rem を先に書く
2038: RegD(r) = rem;
2039: RegD(q) = quo;
2040: }
2041: break;
2042: }
2043:
2044: case 3: // DIVSL.L
2045: {
2046: CYCLE(90); // XXX これは本当は最大値だけど
2047: uint32 src = fea_data_32(cpu);
2048: uint64 dst = (((uint64)RegD(r)) << 32) | RegD(q);
2049: uint32 quo;
2050: uint32 rem;
2051: if (acc_divs_64_32(cpu, src, dst, &quo, &rem)) {
2052: RegD(r) = rem;
2053: RegD(q) = quo;
2054: }
2055: break;
2056: }
2057:
2058: default:
2059: __unreachable();
2060: }
2061: }
2062:
2063: template<int bytesize> void
2064: ops_movem_ea_list(m68kcpu *cpu)
2065: {
2066: uint32 ea;
2067: int regcount;
2068: bool anpi = false;
2069:
2070: RegIR2 = m68030_fetch_16(cpu);
2071:
2072: // EA 取得。MOVEM だけ別対応
2073: // | M+ WXZP | MOVEM <ea>,list
2074: switch (eamode(RegIR)) {
2075: case 2: // (An)
2076: ea = cea_anin(cpu, eanum(RegIR));
2077: break;
2078: case 3: // (An)+
2079: if (bytesize == 2) {
2080: ea = cea_anpi_16(cpu, eanum(RegIR));
2081: } else {
2082: ea = cea_anpi_32(cpu, eanum(RegIR));
2083: }
2084: anpi = true;
2085: break;
2086: case 5: // d16(An)
2087: ea = cea_andi(cpu, eanum(RegIR));
2088: break;
2089: case 6: // (An,IX)
2090: ea = cea_anix(cpu, eanum(RegIR));
2091: break;
2092: case 7:
2093: switch (eanum(RegIR)) {
2094: case 0: // Abs.W
2095: ea = cea_absw(cpu);
2096: break;
2097: case 1: // Abs.L
2098: ea = cea_absl(cpu);
2099: break;
2100: case 2: // d16(PC)
2101: ea = cea_pcdi(cpu);
2102: break;
2103: case 3: // (PC,IX)
2104: ea = cea_pcix(cpu);
2105: break;
2106: default:
2107: op_illegal(cpu);
2108: return;
2109: }
2110: break;
2111: default:
2112: op_illegal(cpu);
2113: return;
2114: }
2115:
2116: // XXX レジスタリストに表れて、ea オペランドに出てくる
2117: // レジスタはデータレジスタIX も含めて全部保存しておく必要がある。
2118:
2119: regcount = 0;
2120: uint list = RegIR2;
2121: while (list) {
2122: uint32 data;
2123: if (bytesize == 2) {
2124: data = (int32)(int16)m68030_read_16(cpu, ea);
2125: } else {
2126: data = m68030_read_32(cpu, ea);
2127: }
2128: ea += bytesize;
2129: regcount++;
2130: int ctz = __builtin_ctz(list);
2131: RegR(ctz) = data;
2132: // clear LSB bits
2133: list &= ((~1U) << ctz);
2134: }
2135: // (An)+ なら An を更新
2136: if (anpi) {
2137: RegAY = ea;
2138: }
2139:
2140: CYCLE(8 + 4 * regcount);
2141: }
2142:
2143: // %0100_110010_mmmrrr MOVEM.W <ea>,<list>
2144: OP_DEF(movem_w)
2145: {
2146: ops_movem_ea_list<2>(cpu);
2147: }
2148:
2149: // %0100_110011_mmmrrr MOVEM.L <ea>,<list>
2150: OP_DEF(movem_l)
2151: {
2152: ops_movem_ea_list<4>(cpu);
2153: }
2154:
1.1.1.2 root 2155: static void
1.1 root 2156: ops_rte(m68kcpu *cpu)
2157: {
2158: SUPERVISOR_OP;
2159:
2160: // subr.cpp
2161: m68030_rte(cpu);
2162: }
2163:
2164: // MOVEC.L Rc,Rn
1.1.1.2 root 2165: static void
1.1 root 2166: ops_movec_rc_rn(m68kcpu *cpu)
2167: {
2168: SUPERVISOR_OP;
2169:
2170: CYCLE(6);
2171: RegIR2 = m68030_fetch_16(cpu);
2172: int n = RegIR2 >> 12;
2173: int c = RegIR2 & 0xfff;
2174: switch (c) {
2175: case 0x000:
2176: RegR(n) = RegSFC;
2177: return;
2178: case 0x001:
2179: RegR(n) = RegDFC;
2180: return;
2181: case 0x002:
2182: RegR(n) = RegCACR;
2183: return;
2184: case 0x800:
2185: RegR(n) = RegUSP;
2186: return;
2187: case 0x801:
2188: RegR(n) = RegVBR;
2189: return;
2190: case 0x802:
2191: RegR(n) = RegCAAR;
2192: return;
2193: case 0x803:
2194: if (cpu->reg.m) {
2195: RegR(n) = RegA(7);
2196: } else {
2197: RegR(n) = RegMSP;
2198: }
2199: return;
2200: case 0x804:
2201: if (cpu->reg.m) {
2202: RegR(n) = RegISP;
2203: } else {
2204: RegR(n) = RegA(7);
2205: }
2206: return;
2207: default:
2208: break;
2209: }
2210: op_illegal(cpu);
2211: }
2212:
2213: // MOVEC.L Rn,Rc
1.1.1.2 root 2214: static void
1.1 root 2215: ops_movec_rn_rc(m68kcpu *cpu)
2216: {
2217: SUPERVISOR_OP;
2218:
2219: RegIR2 = m68030_fetch_16(cpu);
2220: int n = RegIR2 >> 12;
2221: int c = RegIR2 & 0xfff;
2222: switch (c) {
2223: case 0x000:
2224: CYCLE(12);
2225: RegSFC = RegR(n);
2226: return;
2227: case 0x001:
2228: CYCLE(12);
2229: RegDFC = RegR(n);
2230: return;
2231: case 0x002:
2232: CYCLE(12);
2233: RegCACR = RegR(n);
2234: return;
2235: case 0x800:
2236: CYCLE(6);
2237: RegUSP = RegR(n);
2238: return;
2239: case 0x801:
2240: CYCLE(6);
2241: RegVBR = RegR(n);
2242: return;
2243: case 0x802:
2244: CYCLE(6);
2245: RegCAAR = RegR(n);
2246: return;
2247: case 0x803:
2248: CYCLE(6);
2249: if (cpu->reg.m) {
2250: RegA(7) = RegR(n);
2251: } else {
2252: RegMSP = RegR(n);
2253: }
2254: return;
2255: case 0x804:
2256: CYCLE(6);
2257: if (cpu->reg.m) {
2258: RegISP = RegR(n);
2259: } else {
2260: RegA(7) = RegR(n);
2261: }
2262: return;
2263: default:
2264: break;
2265: }
2266: op_illegal(cpu);
2267: }
2268:
2269: // %0100_111001_00nnnn TRAP #<vector>
2270: // %0100_111001_010yyy LINK.W Ay,#<imm>
2271: // %0100_111001_011yyy UNLK Ay
2272: // %0100_111001_100yyy MOVE.L Ay,USP
2273: // %0100_111001_101yyy MOVE.L USP,Ay
2274: // %0100_111001_110000 RESET
2275: // %0100_111001_110001 NOP
2276: // %0100_111001_110010 STOP #<imm>
2277: // %0100_111001_110011 RTE
2278: // %0100_111001_110100 RTD #<imm>
2279: // %0100_111001_110101 RTS
2280: // %0100_111001_110110 TRAPV
2281: // %0100_111001_110111 RTR
2282: // %0100_111001_111010 MOVEC.L Rc,Rn
2283: // %0100_111001_111011 MOVEC.L Rn,Rc
2284: OP_DEF(trap)
2285: {
2286: uint n = RegIR & 0x3f;
2287: int32 imm;
2288:
2289: switch (n) {
2290: case 0x00 ... 0x0f:// TRAP #<vector>
2291: CYCLE2(18, 20);
2292: // TRAP#N 例外
2293: m68030_exception(cpu, M68K_EXCEP_TRAP0 + n);
2294: return;
2295:
2296: case 0x10:
2297: case 0x11:
2298: case 0x12:
2299: case 0x13:
2300: case 0x14:
2301: case 0x15:
2302: case 0x17: // LINK.W Ay,#<imm>
2303: CYCLE2(4, 5);
2304: // レジスタやスタックを変更する前にフェッチとセーブをしないと、
2305: // ページフォルトで再実行できなくなる
2306: imm = (int32)(int16)m68030_fetch_16(cpu);
2307: m68030_save_reg_pd(cpu, 7);
2308: m68030_push_32(cpu, RegAY);
2309: RegAY = RegA(7);
2310: RegA(7) += imm;
2311: return;
2312: case 0x16: // LINK.W A6,#<imm>
2313: // LINK はほぼ A6 なのでこいつだけ展開してみる
2314: CYCLE2(4, 5);
2315: // レジスタやスタックを変更する前にフェッチとセーブをしないと、
2316: // ページフォルトで再実行できなくなる
2317: imm = (int32)(int16)m68030_fetch_16(cpu);
2318: m68030_save_reg_pd(cpu, 7);
2319: m68030_push_32(cpu, RegA(6));
2320: RegA(6) = RegA(7);
2321: RegA(7) += imm;
2322: return;
2323:
2324: case 0x18:
2325: case 0x19:
2326: case 0x1a:
2327: case 0x1b:
2328: case 0x1c:
2329: case 0x1d:
2330: case 0x1f: // UNLK Ay
2331: CYCLE(5);
2332: // ページフォルトに備えて保存する
2333: m68030_save_reg_pi(cpu, 7);
2334: RegA(7) = RegAY;
2335: RegAY = m68030_pop_32(cpu);
2336: return;
2337: case 0x1e: // UNLK A6
2338: // UNLK はほぼ A6 なのでこいつだけ展開してみる
2339: CYCLE(5);
2340: // ページフォルトに備えて保存する
2341: m68030_save_reg_pi(cpu, 7);
2342: RegA(7) = RegA(6);
2343: RegA(6) = m68030_pop_32(cpu);
2344: return;
2345:
2346: case 0x20:
2347: case 0x21:
2348: case 0x22:
2349: case 0x23:
2350: case 0x24:
2351: case 0x25:
2352: case 0x26:
2353: case 0x27: // MOVE.L Ay,USP
2354: SUPERVISOR_OP;
2355: CYCLE(4);
2356: RegUSP = RegAY;
2357: return;
2358:
2359: case 0x28:
2360: case 0x29:
2361: case 0x2a:
2362: case 0x2b:
2363: case 0x2c:
2364: case 0x2d:
2365: case 0x2e:
2366: case 0x2f: // MOVE.L USP,Ay
2367: SUPERVISOR_OP;
2368: CYCLE(4);
2369: RegAY = RegUSP;
2370: return;
2371:
2372: case 0x30: // RESET
2373: CYCLE(518);
2374: m68030_reset_inst(cpu);
2375: return;
2376:
2377: case 0x31: // NOP
2378: CYCLE(2);
2379: // XXX ほんとは何かするらしいけど
2380: return;
2381:
2382: case 0x32: // STOP #<imm>
2383: {
2384: SUPERVISOR_OP;
2385: CYCLE(8);
2386: uint32 data = m68030_fetch_16(cpu);
2387: m68030_set_sr(cpu, data);
2388: cpu->atomic_reqflag |= CPU_REQ_RELEASE | CPU_REQ_STOP;
2389: return;
2390: }
2391:
2392: case 0x33: // RTE
2393: ops_rte(cpu);
2394: return;
2395:
2396: case 0x34: // RTD #<imm>
2397: {
2398: CYCLE2(10, 12);
2399: // ページフォルトに備えて保存する
2400: m68030_save_reg_pi(cpu, 7);
2401: uint32 disp = m68030_fetch_16(cpu);
2402: m68030_jump(cpu, m68030_pop_32(cpu));
2403: RegA(7) += (int32)(int16)disp;
2404: return;
2405: }
2406:
2407: case 0x35: // RTS
2408: CYCLE2(9, 11);
2409: // ページフォルトに備えて保存する
2410: m68030_save_reg_pi(cpu, 7);
2411: m68030_jump(cpu, m68030_pop_32(cpu));
2412: return;
2413:
2414: case 0x36: // TRAPV
2415: if (CCR.IsV()) {
2416: CYCLE2(22, 24);
2417: m68030_exception(cpu, M68K_EXCEP_TRAPV);
2418: } else {
2419: CYCLE(4);
2420: }
2421: return;
2422:
2423: case 0x37: // RTR
2424: CYCLE2(12, 14);
2425: // ページフォルトに備えて保存する
2426: m68030_save_reg_pi(cpu, 7);
2427: CCR.Set(m68030_pop_16(cpu));
2428: m68030_jump(cpu, m68030_pop_32(cpu));
2429: return;
2430:
2431: case 0x3a: // MOVEC.L Rc,Rn
2432: ops_movec_rc_rn(cpu);
2433: return;
2434:
2435: case 0x3b: // MOVEC.L Rn,Rc
2436: ops_movec_rn_rc(cpu);
2437: return;
2438:
2439: default:
2440: op_illegal(cpu);
2441: return;
2442: }
2443: }
2444:
2445: // %0100_111010_mmmrrr JSR <ea>
2446: OP_DEF(jsr)
2447: {
2448: CYCLE2(4, 7);
2449: uint32 ea = cea_ctrl(cpu);
2450: // ページフォルトに備えて保存する
2451: m68030_save_reg_pd(cpu, 7);
2452: m68030_push_32(cpu, RegPC);
2453: m68030_jump(cpu, ea);
2454: }
2455:
2456: // %0100_111011_mmmrrr JMP <ea>
2457: OP_DEF(jmp)
2458: {
2459: CYCLE2(4, 6);
2460: // 実際には CEA ではなく JEA の実行時間を足すんだがまあいいか
2461: uint32 ea = cea_ctrl(cpu);
2462: m68030_jump(cpu, ea);
2463: }
2464:
2465: // %0101_qqq000_mmmrrr ADDQ.B #qqq,<ea>
2466: OP_DEF(addq_b)
2467: {
2468: uint n = RegIR & 0x3f;
2469:
2470: uint32 src = RegIRX;
2471: src = (src == 0) ? 8 : src;
2472: if (n < 8) {
2473: // ADDQ.B #qqq,Dn
2474: CYCLE(2);
2475: uint32 data = acc_add_8(cpu, src, RegD(n) & 0xff);
2476: RegD(n) = (RegD(n) & 0xffffff00) | data;
2477: } else {
2478: // ADDQ.B #qqq,<ea>
2479: CYCLE2(3, 4);
2480: uint32 ea = cea_data_8(cpu);
2481: uint32 data = m68030_read_8(cpu, ea);
2482: data = acc_add_8(cpu, src, data);
2483: m68030_write_8(cpu, ea, data);
2484: }
2485: }
2486:
2487: // %0101_qqq001_mmmrrr ADDQ.W #qqq,<ea>
2488: // %0101_qqq001_001yyy ADDQ.W #qqq,Ay (.Lと等価)
2489: OP_DEF(addq_w)
2490: {
2491: uint n = RegIR & 0x3f;
2492:
2493: uint32 src = RegIRX;
2494: src = (src == 0) ? 8 : src;
2495: if (n < 8) {
2496: // ADDQ.W #qqq,Dn
2497: CYCLE(2);
2498: uint32 data = acc_add_16(cpu, src, RegD(n) & 0xffff);
2499: RegD(n) = (RegD(n) & 0xffff0000) | data;
2500: } else if (n < 16) {
2501: // ADDQ.W #qqq,An は ADDQ.L と等価
2502: // フラグは変化しない
2503: CYCLE(2);
2504: RegR(n) += src;
2505: } else {
2506: // ADDQ.W #qqq,<ea>
2507: CYCLE2(3, 4);
2508: uint32 ea = cea_data_16(cpu);
2509: uint32 data = m68030_read_16(cpu, ea);
2510: data = acc_add_16(cpu, src, data);
2511: m68030_write_16(cpu, ea, data);
2512: }
2513: }
2514:
2515: // %0101_qqq010_mmmrrr ADDQ.L #qqq,<ea>
2516: // %0101_qqq010_001yyy ADDQ.L #qqq,Ay
2517: OP_DEF(addq_l)
2518: {
2519: uint n = RegIR & 0x3f;
2520:
2521: uint32 src = RegIRX;
2522: src = (src == 0) ? 8 : src;
2523: if (n < 8) {
2524: // ADDQ.L #qqq,Dn
2525: CYCLE(2);
2526: RegD(n) = acc_add_32(cpu, src, RegD(n));
2527: } else if (n < 16) {
2528: // ADDQ.L #qqq,An
2529: // フラグは変化しない
2530: CYCLE(2);
2531: RegR(n) += src;
2532: } else {
2533: // ADDQ.L #qqq,<ea>
2534: CYCLE2(3, 4);
2535: uint32 ea = cea_data_32(cpu);
2536: uint32 data = m68030_read_32(cpu, ea);
2537: data = acc_add_32(cpu, src, data);
2538: m68030_write_32(cpu, ea, data);
2539: }
2540: }
2541:
2542: // TRAPcc の共通部分。
2543: template<int cond>void
2544: ops_trapcc(m68kcpu *cpu)
2545: {
2546: // 条件成立すれば例外。成立しなければ何もしない。
2547: // いずれの場合もオペランドありの形態なら事前に読み飛ばしておくこと。
2548: if (cond_func(cpu, cond)) {
2549: CYCLE2(22, 24);
2550: m68030_exception(cpu, M68K_EXCEP_TRAPV);
2551: } else {
2552: // サイクルを消費するだけ
2553: CYCLE(4);
2554: }
2555: }
2556:
2557: // Scc ブロックの共通部分。
2558: template<int cond> void
2559: ops_scc(m68kcpu *cpu)
2560: {
2561: uint n = RegIR & 0x3f;
2562:
2563: switch (n) {
2564: case 0b000000 ... 0b000111: // Scc.B Dn
2565: CYCLE(4);
2566: if (cond_func(cpu, cond)) {
2567: RegDY |= 0xff;
2568: } else {
2569: RegDY &= ~0xff;
2570: }
2571: return;
2572:
2573: case 0b001000 ... 0b001111: // DBcc.W Dy,<label>
2574: if (cond_func(cpu, cond)) {
2575: // 真なら何もしない。disp を読み飛ばして次へ。
2576: CYCLE2(6, 8);
2577: m68030_fetch_16(cpu);
2578: } else {
2579: // 偽の場合
2580:
2581: // Dy.W を減算して(下位ワードに)書き戻し、Dy.W が -1 だったら
2582: // ループ終了。だが最適化のため、減算前の Dy.W が 0 の時は
2583: // 下位ワードを 0xffff にしてループ終了、そうでなければ Dy.L を
2584: // 減算するだけでいいはず。
2585:
2586: uint16 data = RegDY;
2587: if (data == 0) {
2588: // ループ終了。disp を読み飛ばす
2589: CYCLE2(10, 13);
2590: RegDY |= 0x0000ffff;
2591: m68030_fetch_16(cpu);
2592: } else {
2593: CYCLE2(6, 8);
2594: RegDY--;
2595: uint32 pc = RegPC;
2596: int32 disp = (int32)(int16)m68030_fetch_16(cpu);
2597: m68030_jump(cpu, pc + disp);
2598: }
2599: }
2600: return;
2601:
2602: case 0b010000 ... 0b010111: // Scc.B <ea>
2603: case 0b011000 ... 0b011111: // Scc.B <ea>
2604: case 0b100000 ... 0b100111: // Scc.B <ea>
2605: case 0b101000 ... 0b101111: // Scc.B <ea>
2606: case 0b110000 ... 0b110111: // Scc.B <ea>
2607: case 0b111000: // Scc.B <ea>
2608: case 0b111001: // Scc.B <ea>
2609: {
2610: CYCLE(5);
2611: // 条件成立可否に関わらず EA は取得しないといけない
2612: uint32 ea = cea_data_8(cpu);
2613: uint32 data;
2614: if (cond_func(cpu, cond)) {
2615: data = 0xff;
2616: } else {
2617: data = 0;
2618: }
2619: m68030_write_8(cpu, ea, data);
2620: return;
2621: }
2622:
2623: case 0b111010: // TRAPcc.W #<imm>
2624: // オペランドなしTRAPccに比べてすべてのケースで2サイクル多い
2625: CYCLE(2);
2626: m68030_fetch_16(cpu);
2627: ops_trapcc<cond>(cpu);
2628: return;
2629:
2630: case 0b111011: // TRAPcc.L #<imm>
2631: // オペランドなしTRAPccに比べてすべてのケースで4サイクル多い
2632: CYCLE(4);
2633: m68030_fetch_32(cpu);
2634: ops_trapcc<cond>(cpu);
2635: return;
2636:
2637: case 0b111100: // TRAPcc
2638: ops_trapcc<cond>(cpu);
2639: return;
2640:
2641: default:
2642: OP_FUNC(illegal);
2643: return;
2644: }
2645: }
2646:
2647: // %0101_000011_mmmrrr ST.B <ea>
2648: // %0101_000011_001yyy DBT.W Dy,<label>
2649: // %0101_000011_111010 TRAPT.W #<imm>
2650: // %0101_000011_111011 TRAPT.L #<imm>
2651: // %0101_000011_111100 TRAPT
2652: OP_DEF(st)
2653: {
2654: ops_scc<0>(cpu);
2655: }
2656:
2657: // %0101_qqq100_mmmrrr SUBQ.B #qqq,<ea>
2658: OP_DEF(subq_b)
2659: {
2660: uint n = RegIR & 0x3f;
2661:
2662: uint32 src = RegIRX;
2663: src = (src == 0) ? 8 : src;
2664: if (n < 8) {
2665: // SUBQ.B #qqq,Dn
2666: CYCLE(2);
2667: uint32 data = acc_sub_8(cpu, src, RegD(n) & 0xff);
2668: RegD(n) = (RegD(n) & 0xffffff00) | data;
2669: } else {
2670: // SUBQ.B #qqq,<ea>
2671: CYCLE2(3, 4);
2672: uint32 ea = cea_data_8(cpu);
2673: uint32 data = m68030_read_8(cpu, ea);
2674: data = acc_sub_8(cpu, src, data);
2675: m68030_write_8(cpu, ea, data);
2676: }
2677: }
2678:
2679: // %0101_qqq101_mmmrrr SUBQ.W #qqq,<ea>
2680: // %0101_qqq101_001yyy SUBQ.W #qqq,Ay (.Lと等価)
2681: OP_DEF(subq_w)
2682: {
2683: uint n = RegIR & 0x3f;
2684:
2685: uint32 src = RegIRX;
2686: src = (src == 0) ? 8 : src;
2687: if (n < 8) {
2688: // SUBQ.W #qqq,Dn
2689: CYCLE(2);
2690: uint32 data = acc_sub_16(cpu, src, RegD(n) & 0xffff);
2691: RegD(n) = (RegD(n) & 0xffff0000) | data;
2692: } else if (n < 16) {
2693: // SUBQ.W #qqq,An は SUBQ.L と等価
2694: // フラグは変化しない
2695: CYCLE(2);
2696: RegR(n) -= src;
2697: } else {
2698: // SUBQ.W #qqq,<ea>
2699: CYCLE2(3, 4);
2700: uint32 ea = cea_data_16(cpu);
2701: uint32 data = m68030_read_16(cpu, ea);
2702: data = acc_sub_16(cpu, src, data);
2703: m68030_write_16(cpu, ea, data);
2704: }
2705: }
2706:
2707: // %0101_qqq110_mmmrrr SUBQ.L #qqq,<ea>
2708: // %0101_qqq110_001yyy SUBQ.L #qqq,Ay
2709: OP_DEF(subq_l)
2710: {
2711: uint n = RegIR & 0x3f;
2712:
2713: uint32 src = RegIRX;
2714: src = (src == 0) ? 8 : src;
2715: if (n < 8) {
2716: // SUBQ.L #qqq,Dn
2717: CYCLE(2);
2718: RegD(n) = acc_sub_32(cpu, src, RegD(n));
2719: } else if (n < 16) {
2720: // SUBQ.L #qqq,An
2721: // フラグは変化しない
2722: CYCLE(2);
2723: RegR(n) -= src;
2724: } else {
2725: // SUBQ.L #qqq,<ea>
2726: CYCLE2(3, 4);
2727: uint32 ea = cea_data_32(cpu);
2728: uint32 data = m68030_read_32(cpu, ea);
2729: data = acc_sub_32(cpu, src, data);
2730: m68030_write_32(cpu, ea, data);
2731: }
2732: }
2733:
2734: // %0101_000111_mmmrrr SF.B <ea>
2735: // %0101_000111_001yyy DBRA.W Dy,<label>
2736: // %0101_000111_111010 TRAPF.W #<imm>
2737: // %0101_000111_111011 TRAPF.L #<imm>
2738: // %0101_000111_111100 TRAPF
2739: OP_DEF(sf)
2740: {
2741: ops_scc<1>(cpu);
2742: }
2743:
2744: // %0101_001011_mmmrrr SHI.B <ea>
2745: // %0101_001011_001yyy DBHI.W Dy,<label>
2746: // %0101_001011_111010 TRAPHI.W #<imm>
2747: // %0101_001011_111011 TRAPHI.L #<imm>
2748: // %0101_001011_111100 TRAPHI
2749: OP_DEF(shi)
2750: {
2751: ops_scc<2>(cpu);
2752: }
2753:
2754: // %0101_001111_mmmrrr SLS.B <ea>
2755: // %0101_001111_001yyy DBLS.W Dy,<label>
2756: // %0101_001111_111010 TRAPLS.W #<imm>
2757: // %0101_001111_111011 TRAPLS.L #<imm>
2758: // %0101_001111_111100 TRAPLS
2759: OP_DEF(sls)
2760: {
2761: ops_scc<3>(cpu);
2762: }
2763:
2764: // %0101_010011_mmmrrr SCC.B <ea>
2765: // %0101_010011_001yyy DBCC.W Dy,<label>
2766: // %0101_010011_111010 TRAPCC.W #<imm>
2767: // %0101_010011_111011 TRAPCC.L #<imm>
2768: // %0101_010011_111100 TRAPCC
2769: OP_DEF(scc)
2770: {
2771: ops_scc<4>(cpu);
2772: }
2773:
2774: // %0101_010111_mmmrrr SCS.B <ea>
2775: // %0101_010111_001yyy DBCS.W Dy,<label>
2776: // %0101_010111_111010 TRAPCS.W #<imm>
2777: // %0101_010111_111011 TRAPCS.L #<imm>
2778: // %0101_010111_111100 TRAPCS
2779: OP_DEF(scs)
2780: {
2781: ops_scc<5>(cpu);
2782: }
2783:
2784: // %0101_011011_mmmrrr SNE.B <ea>
2785: // %0101_011011_001yyy DBNE.W Dy,<label>
2786: // %0101_011011_111010 TRAPNE.W #<imm>
2787: // %0101_011011_111011 TRAPNE.L #<imm>
2788: // %0101_011011_111100 TRAPNE
2789: OP_DEF(sne)
2790: {
2791: ops_scc<6>(cpu);
2792: }
2793:
2794: // %0101_011111_mmmrrr SEQ.B <ea>
2795: // %0101_011111_001yyy DBEQ.W Dy,<label>
2796: // %0101_011111_111010 TRAPEQ.W #<imm>
2797: // %0101_011111_111011 TRAPEQ.L #<imm>
2798: // %0101_011111_111100 TRAPEQ
2799: OP_DEF(seq)
2800: {
2801: ops_scc<7>(cpu);
2802: }
2803:
2804: // %0101_100011_mmmrrr SVC.B <ea>
2805: // %0101_100011_001yyy DBVC.W Dy,<label>
2806: // %0101_100011_111010 TRAPVC.W #<imm>
2807: // %0101_100011_111011 TRAPVC.L #<imm>
2808: // %0101_100011_111100 TRAPVC
2809: OP_DEF(svc)
2810: {
2811: ops_scc<8>(cpu);
2812: }
2813:
2814: // %0101_100111_mmmrrr SVS.B <ea>
2815: // %0101_100111_001yyy DBVS.W Dy,<label>
2816: // %0101_100111_111010 TRAPVS.W #<imm>
2817: // %0101_100111_111011 TRAPVS.L #<imm>
2818: // %0101_100111_111100 TRAPVS
2819: OP_DEF(svs)
2820: {
2821: ops_scc<9>(cpu);
2822: }
2823:
2824: // %0101_101011_mmmrrr SPL.B <ea>
2825: // %0101_101011_001yyy DBPL.W Dy,<label>
2826: // %0101_101011_111010 TRAPPL.W #<imm>
2827: // %0101_101011_111011 TRAPPL.L #<imm>
2828: // %0101_101011_111100 TRAPPL
2829: OP_DEF(spl)
2830: {
2831: ops_scc<10>(cpu);
2832: }
2833:
2834: // %0101_101111_mmmrrr SMI.B <ea>
2835: // %0101_101111_001yyy DBMI.W Dy,<label>
2836: // %0101_101111_111010 TRAPMI.W #<imm>
2837: // %0101_101111_111011 TRAPMI.L #<imm>
2838: // %0101_101111_111100 TRAPMI
2839: OP_DEF(smi)
2840: {
2841: ops_scc<11>(cpu);
2842: }
2843:
2844: // %0101_110011_mmmrrr SGE.B <ea>
2845: // %0101_110011_001yyy DBGE.W Dy,<label>
2846: // %0101_110011_111010 TRAPGE.W #<imm>
2847: // %0101_110011_111011 TRAPGE.L #<imm>
2848: // %0101_110011_111100 TRAPGE
2849: OP_DEF(sge)
2850: {
2851: ops_scc<12>(cpu);
2852: }
2853:
2854: // %0101_110111_mmmrrr SLT.B <ea>
2855: // %0101_110111_001yyy DBLT.W Dy,<label>
2856: // %0101_110111_111010 TRAPLT.W #<imm>
2857: // %0101_110111_111011 TRAPLT.L #<imm>
2858: // %0101_110111_111100 TRAPLT
2859: OP_DEF(slt)
2860: {
2861: ops_scc<13>(cpu);
2862: }
2863:
2864: // %0101_111011_mmmrrr SGT.B <ea>
2865: // %0101_111011_001yyy DBGT.W Dy,<label>
2866: // %0101_111011_111010 TRAPGT.W #<imm>
2867: // %0101_111011_111011 TRAPGT.L #<imm>
2868: // %0101_111011_111100 TRAPGT
2869: OP_DEF(sgt)
2870: {
2871: ops_scc<14>(cpu);
2872: }
2873:
2874: // %0101_111111_mmmrrr SLE.B <ea>
2875: // %0101_111111_001yyy DBLE.W Dy,<label>
2876: // %0101_111111_111010 TRAPLE.W #<imm>
2877: // %0101_111111_111011 TRAPLE.L #<imm>
2878: // %0101_111111_111100 TRAPLE
2879: OP_DEF(sle)
2880: {
2881: ops_scc<15>(cpu);
2882: }
2883:
2884: // BRA/Bcc の共通部分
2885: template<int cond> void
2886: ops_bcc(m68kcpu *cpu)
2887: {
2888: int32 disp = (int32)(int8)(RegIR & 0xff);
2889: uint32 pc;
2890:
2891: // ブランチするかどうかでサイクルが変わるので先に条件を調べる
2892: if (cond_func(cpu, cond)) {
2893: // Bcc (taken)
2894: CYCLE2(6, 8);
2895: pc = RegPC;
2896: if (disp == -1) {
2897: // Bcc.L
2898: disp = (int32)m68030_fetch_32(cpu);
2899: } else if (disp == 0) {
2900: // Bcc.W
2901: disp = (int32)(int16)m68030_fetch_16(cpu);
2902: }
2903: m68030_jump(cpu, pc + disp);
2904: } else {
2905: if (disp == -1) {
2906: // Bcc.L (not taken)
2907: CYCLE(8);
2908: m68030_fetch_32(cpu);
2909: } else if (disp == 0) {
2910: // Bcc.W (not taken)
2911: CYCLE(6);
2912: m68030_fetch_16(cpu);
2913: } else {
2914: // Bcc.B (not taken)
2915: CYCLE(4);
2916: }
2917: }
2918: }
2919:
2920: // %0110_000000_000000 BRA.W <label>
2921: // %0110_0000nn_nnnnnn BRA.B <label>
2922: // %0110_000011_111111 BRA.L <label>
2923: OP_DEF(bra)
2924: {
2925: ops_bcc<0>(cpu);
2926: }
2927:
2928: // %0110_000100_000000 BSR.W <label>
2929: // %0110_0001nn_nnnnnn BSR.B <label>
2930: // %0110_000111_111111 BSR.L <label>
2931: OP_DEF(bsr)
2932: {
2933: CYCLE2(6, 9);
2934: uint32 pc = RegPC;
2935: int32 disp = (int32)(int8)(RegIR & 0xff);
2936: if (disp == -1) {
2937: // BSR.L <label>
2938: disp = (int32)m68030_fetch_32(cpu);
2939: } else if (disp == 0) {
2940: // BSR.W <label>
2941: disp = (int32)(int16)m68030_fetch_16(cpu);
2942: }
2943: // ページフォルトに備えて保存する
2944: m68030_save_reg_pd(cpu, 7);
2945: m68030_push_32(cpu, RegPC);
2946: m68030_jump(cpu, pc + disp);
2947: }
2948:
2949: // %0110_001000_000000 BHI.W <label>
2950: // %0110_0010nn_nnnnnn BHI.B <label>
2951: // %0110_001011_111111 BHI.L <label>
2952: OP_DEF(bhi)
2953: {
2954: ops_bcc<2>(cpu);
2955: }
2956:
2957: // %0110_001100_000000 BLS.W <label>
2958: // %0110_0011nn_nnnnnn BLS.B <label>
2959: // %0110_001111_111111 BLS.L <label>
2960: OP_DEF(bls)
2961: {
2962: ops_bcc<3>(cpu);
2963: }
2964:
2965: // %0110_010000_000000 BCC.W <label>
2966: // %0110_0100nn_nnnnnn BCC.B <label>
2967: // %0110_010011_111111 BCC.L <label>
2968: OP_DEF(bcc)
2969: {
2970: ops_bcc<4>(cpu);
2971: }
2972:
2973: // %0110_010100_000000 BCS.W <label>
2974: // %0110_0101nn_nnnnnn BCS.B <label>
2975: // %0110_010111_111111 BCS.L <label>
2976: OP_DEF(bcs)
2977: {
2978: ops_bcc<5>(cpu);
2979: }
2980:
2981: // %0110_011000_000000 BNE.W <label>
2982: // %0110_0110nn_nnnnnn BNE.B <label>
2983: // %0110_011011_111111 BNE.L <label>
2984: OP_DEF(bne)
2985: {
2986: ops_bcc<6>(cpu);
2987: }
2988:
2989: // %0110_011100_000000 BEQ.W <label>
2990: // %0110_0111nn_nnnnnn BEQ.B <label>
2991: // %0110_011111_111111 BEQ.L <label>
2992: OP_DEF(beq)
2993: {
2994: ops_bcc<7>(cpu);
2995: }
2996:
2997: // %0110_100000_000000 BVC.W <label>
2998: // %0110_1000nn_nnnnnn BVC.B <label>
2999: // %0110_100011_111111 BVC.L <label>
3000: OP_DEF(bvc)
3001: {
3002: ops_bcc<8>(cpu);
3003: }
3004:
3005: // %0110_100100_000000 BVS.W <label>
3006: // %0110_1001nn_nnnnnn BVS.B <label>
3007: // %0110_100111_111111 BVS.L <label>
3008: OP_DEF(bvs)
3009: {
3010: ops_bcc<9>(cpu);
3011: }
3012:
3013: // %0110_101000_000000 BPL.W <label>
3014: // %0110_1010nn_nnnnnn BPL.B <label>
3015: // %0110_101011_111111 BPL.L <label>
3016: OP_DEF(bpl)
3017: {
3018: ops_bcc<10>(cpu);
3019: }
3020:
3021: // %0110_101100_000000 BMI.W <label>
3022: // %0110_1011nn_nnnnnn BMI.B <label>
3023: // %0110_101111_111111 BMI.L <label>
3024: OP_DEF(bmi)
3025: {
3026: ops_bcc<11>(cpu);
3027: }
3028:
3029: // %0110_110000_000000 BGE.W <label>
3030: // %0110_1100nn_nnnnnn BGE.B <label>
3031: // %0110_110011_111111 BGE.L <label>
3032: OP_DEF(bge)
3033: {
3034: ops_bcc<12>(cpu);
3035: }
3036:
3037: // %0110_110100_000000 BLT.W <label>
3038: // %0110_1101nn_nnnnnn BLT.B <label>
3039: // %0110_110111_111111 BLT.L <label>
3040: OP_DEF(blt)
3041: {
3042: ops_bcc<13>(cpu);
3043: }
3044:
3045: // %0110_111000_000000 BGT.W <label>
3046: // %0110_1110nn_nnnnnn BGT.B <label>
3047: // %0110_111011_111111 BGT.L <label>
3048: OP_DEF(bgt)
3049: {
3050: ops_bcc<14>(cpu);
3051: }
3052:
3053: // %0110_111100_000000 BLE.W <label>
3054: // %0110_1111nn_nnnnnn BLE.B <label>
3055: // %0110_111111_111111 BLE.L <label>
3056: OP_DEF(ble)
3057: {
3058: ops_bcc<15>(cpu);
3059: }
3060:
3061: // %0111_xxx0nn_nnnnnn MOVEQ.L #<imm>,Dx
3062: OP_DEF(moveq)
3063: {
3064: CYCLE(2);
3065: RegDX = (int32)(int8)(RegIR & 0xff);
3066: acc_move_32(cpu, RegDX);
3067: }
3068:
3069: // %1000_xxx000_mmmrrr OR.B <ea>,Dx
3070: OP_DEF(or_b_ea_dn)
3071: {
3072: uint n = RegIR & 0x3f;
3073:
3074: CYCLE(2);
3075: int x = RegIRX;
3076: if (n < 8) {
3077: // OR.B Dn,Dx
3078: uint32 data = (RegD(x) | RegD(n)) & 0xff;
3079: acc_move_8(cpu, data);
3080: RegD(x) = (RegD(x) & 0xffffff00) | data;
3081: } else {
3082: // OR.B <ea>,Dx
3083: uint32 src = fea_data_8(cpu);
3084: uint32 data = (RegD(x) | src) & 0xff;
3085: acc_move_8(cpu, data);
3086: RegD(x) = (RegD(x) & 0xffffff00) | data;
3087: }
3088: }
3089:
3090: // %1000_xxx001_mmmrrr OR.W <ea>,Dx
3091: OP_DEF(or_w_ea_dn)
3092: {
3093: uint n = RegIR & 0x3f;
3094:
3095: CYCLE(2);
3096: int x = RegIRX;
3097: if (n < 8) {
3098: // OR.W Dn,Dx
3099: uint32 data = (RegD(x) | RegD(n)) & 0xffff;
3100: acc_move_16(cpu, data);
3101: RegD(x) = (RegD(x) & 0xffff0000) | data;
3102: } else {
3103: // OR.W <ea>,Dx
3104: uint32 src = fea_data_16(cpu);
3105: uint32 data = (RegD(x) | src) & 0xffff;
3106: acc_move_16(cpu, data);
3107: RegD(x) = (RegD(x) & 0xffff0000) | data;
3108: }
3109: }
3110:
3111: // %1000_xxx010_mmmrrr OR.L <ea>,Dx
3112: OP_DEF(or_l_ea_dn)
3113: {
3114: uint n = RegIR & 0x3f;
3115:
3116: CYCLE(2);
3117: int x = RegIRX;
3118: if (n < 8) {
3119: // OR.L Dn,Dx
3120: RegD(x) |= RegD(n);
3121: acc_move_32(cpu, RegD(x));
3122: } else {
3123: // OR.L <ea>,Dx
3124: uint32 src = fea_data_32(cpu);
3125: uint32 data = RegD(x) | src;
3126: acc_move_32(cpu, data);
3127: RegD(x) = data;
3128: }
3129: }
3130:
3131: // %1000_xxx011_mmmrrr DIVU.W <ea>,Dx
3132: OP_DEF(divu_w)
3133: {
3134: CYCLE(44); // XXX これは本当は最大値だけど
3135: uint16 src = fea_data_16(cpu);
3136: uint32 dst = RegDX;
3137: uint32 quo;
3138: uint32 rem;
3139: if (acc_divu_32_16(cpu, src, dst, &quo, &rem)) {
3140: RegDX = (rem << 16) | quo;
3141: }
3142: }
3143:
3144: // %1000_xxx100_000yyy SBCD.B Dy,Dx
3145: // %1000_xxx100_001yyy SBCD.B -(Ay),-(Ax)
3146: // %1000_xxx100_mmmrrr OR.B Dx,<ea>
3147: OP_DEF(or_b_dn_ea)
3148: {
3149: uint n = RegIR & 0x3f;
3150:
3151: if (n < 8) {
3152: // SBCD.B Dy,Dx
3153: CYCLE(4);
3154: uint32 src = RegDY & 0xff;
3155: uint32 dst = RegDX & 0xff;
3156: dst = acc_sbcd_8(cpu, src, dst);
3157: RegDX &= 0xffffff00;
3158: RegDX |= dst;
3159: } else if (n < 16) {
3160: // SBCD.B -(Ay),-(Ax)
3161: CYCLE2(13, 14);
3162: uint32 srcea = internal_ea_anpd_8(cpu, RegIRY);
3163: uint32 dstea = internal_ea_anpd_8(cpu, RegIRX);
3164: uint32 src = m68030_read_8(cpu, srcea);
3165: uint32 dst = m68030_read_8(cpu, dstea);
3166: dst = acc_sbcd_8(cpu, src, dst);
3167: m68030_write_8(cpu, dstea, dst);
3168: } else {
3169: // OR.B Dx,<ea>
3170: CYCLE2(3, 4);
3171: uint32 ea = cea_data_8(cpu);
3172: uint8 data = m68030_read_8(cpu, ea);
3173: data |= RegDX;
3174: acc_move_8(cpu, data);
3175: m68030_write_8(cpu, ea, data);
3176: }
3177: }
3178:
3179: // %1000_xxx101_000yyy PACK Dy,Dx,#<imm>
3180: // %1000_xxx101_001yyy PACK -(Ay),-(Ax),#<imm>
3181: // %1000_xxx101_mmmrrr OR.W Dx,<ea>
3182: OP_DEF(or_w_dn_ea)
3183: {
3184: uint n = RegIR & 0x3f;
3185:
3186: if (n < 8) {
3187: // PACK Dy,Dx,#<imm>
3188: CYCLE(6);
3189: uint32 imm = m68030_fetch_16(cpu);
3190: uint32 src = RegDY + imm;
3191: RegDX = (RegDX & 0xffffff00) | ((src >> 4) & 0x00f0) | (src & 0x000f);
3192: } else if (n < 16) {
3193: // PACK -(Ay),-(Ax),#<imm>
3194: CYCLE(11);
3195: uint32 imm = m68030_fetch_16(cpu);
3196: uint32 srcea;
3197: uint32 src;
3198: // -(Ay) を2回行う
3199: srcea = internal_ea_anpd_8(cpu, RegIRY);
3200: src = m68030_read_8(cpu, srcea);
3201: srcea = internal_ea_anpd_8(cpu, RegIRY);
3202: src |= (m68030_read_8(cpu, srcea) << 8);
3203: src += imm;
3204: uint32 dst = ((src >> 4) & 0x00f0) | (src & 0x000f);
3205: uint32 dstea = internal_ea_anpd_8(cpu, RegIRX);
3206: m68030_write_8(cpu, dstea, dst);
3207: } else {
3208: // OR.W Dx,<ea>
3209: CYCLE2(3, 4);
3210: uint32 ea = cea_data_16(cpu);
3211: uint16 data = m68030_read_16(cpu, ea);
3212: data |= RegDX;
3213: acc_move_16(cpu, data);
3214: m68030_write_16(cpu, ea, data);
3215: }
3216: }
3217:
3218: // %1000_xxx110_000yyy UNPK Dy,Dx,#<imm>
3219: // %1000_xxx110_001yyy UNPK -(Ay),-(Ax),#<imm>
3220: // %1000_xxx110_mmmrrr OR.L Dx,<ea>
3221: OP_DEF(or_l_dn_ea)
3222: {
3223: uint n = RegIR & 0x3f;
3224:
3225: if (n < 8) {
3226: // UNPK Dy,Dx,#<imm>
3227: CYCLE(8);
3228: uint32 imm = m68030_fetch_16(cpu);
3229: uint16 src = RegDY;
3230: src = ((src & 0x00f0) << 4) | (src & 0x000f);
3231: src += imm;
3232: RegDX = (RegDX & 0xffff0000) | src;
3233: } else if (n < 16) {
3234: // UNPK -(Ay),-(Ax),#<imm>
3235: CYCLE(11);
3236: uint32 imm = m68030_fetch_16(cpu);
3237: uint32 srcea = internal_ea_anpd_8(cpu, RegIRY);
3238: uint16 src = m68030_read_8(cpu, srcea);
3239: src = ((src & 0x00f0) << 4) | (src & 0x000f);
3240: src += imm;
3241: // -(Ax) を2回行う
3242: uint32 dstea;
3243: dstea = internal_ea_anpd_8(cpu, RegIRX);
3244: m68030_write_8(cpu, dstea, (src & 0xff));
3245: dstea = internal_ea_anpd_8(cpu, RegIRX);
3246: m68030_write_8(cpu, dstea, src >> 8);
3247: } else {
3248: // OR.L Dx,<ea>
3249: CYCLE2(3, 4);
3250: uint32 ea = cea_data_32(cpu);
3251: uint32 data = m68030_read_32(cpu, ea);
3252: data |= RegDX;
3253: acc_move_32(cpu, data);
3254: m68030_write_32(cpu, ea, data);
3255: }
3256: }
3257:
3258: // %1000_xxx111_mmmrrr DIVS.W <ea>,Dx
3259: OP_DEF(divs_w)
3260: {
3261: CYCLE(56); // XXX これは本当は最大値だけど
3262: uint16 src = fea_data_16(cpu);
3263: uint32 dst = RegDX;
3264: uint32 quo;
3265: uint32 rem;
3266: if (acc_divs_32_16(cpu, src, dst, &quo, &rem)) {
3267: RegDX = (rem << 16) | quo;
3268: }
3269: }
3270:
3271: // %1001_xxx000_mmmrrr SUB.B <ea>,Dx
3272: OP_DEF(sub_b_ea_dn)
3273: {
3274: CYCLE(2);
3275: uint32 src = fea_all_8(cpu);
3276: uint32 data = acc_sub_8(cpu, src, RegDX & 0xff);
3277: RegDX = (RegDX & 0xffffff00) | data;
3278: }
3279:
3280: // %1001_xxx001_mmmrrr SUB.W <ea>,Dx
3281: OP_DEF(sub_w_ea_dn)
3282: {
3283: CYCLE(2);
3284: uint32 src = fea_all_16(cpu);
3285: uint32 data = acc_sub_16(cpu, src, RegDX & 0xffff);
3286: RegDX = (RegDX & 0xffff0000) | data;
3287: }
3288:
3289: // %1001_xxx010_mmmrrr SUB.L <ea>,Dx
3290: OP_DEF(sub_l_ea_dn)
3291: {
3292: CYCLE(2);
3293: uint32 src = fea_all_32(cpu);
3294: RegDX = acc_sub_32(cpu, src, RegDX);
3295: }
3296:
3297: // %1001_xxx011_mmmrrr SUBA.W <ea>,Ax
3298: OP_DEF(suba_w)
3299: {
3300: CYCLE(4);
3301: uint32 src = (int32)(int16)fea_all_16(cpu);
3302: RegAX -= src;
3303: }
3304:
3305: // %1001_xxx100_000yyy SUBX.B Dy,Dx
3306: // %1001_xxx100_001yyy SUBX.B -(Ay),-(Ax)
3307: // %1001_xxx100_mmmrrr SUB.B Dx,<ea>
3308: OP_DEF(sub_b_dn_ea)
3309: {
3310: uint n = RegIR & 0x3f;
3311:
3312: if (n < 8) {
3313: // SUBX.B Dy,Dx
3314: CYCLE(2);
3315: uint32 src = RegDY & 0xff;
3316: uint32 dst = RegDX & 0xff;
3317: dst = acc_subx_8(cpu, src, dst);
3318: RegDX = (RegDX & 0xffffff00) | dst;
3319: } else if (n < 16) {
3320: // SUBX.B -(Ay),-(Ax)
3321: CYCLE2(9, 10);
3322: uint32 srcea = internal_ea_anpd_8(cpu, RegIRY);
3323: uint32 dstea = internal_ea_anpd_8(cpu, RegIRX);
3324: uint32 src = m68030_read_8(cpu, srcea);
3325: uint32 dst = m68030_read_8(cpu, dstea);
3326: dst = acc_subx_8(cpu, src, dst);
3327: m68030_write_8(cpu, dstea, dst);
3328: } else {
3329: // SUB.B Dx,<ea>
3330: CYCLE2(3, 4);
3331: uint32 ea = cea_data_8(cpu);
3332: uint32 data = m68030_read_8(cpu, ea);
3333: data = acc_sub_8(cpu, RegDX & 0xff, data);
3334: m68030_write_8(cpu, ea, data);
3335: }
3336: }
3337:
3338: // %1001_xxx101_000yyy SUBX.W Dy,Dx
3339: // %1001_xxx101_001yyy SUBX.W -(Ay),-(Ax)
3340: // %1001_xxx101_mmmrrr SUB.W Dx,<ea>
3341: OP_DEF(sub_w_dn_ea)
3342: {
3343: uint n = RegIR & 0x3f;
3344:
3345: if (n < 8) {
3346: // SUBX.W Dy,Dx
3347: CYCLE(2);
3348: uint32 src = RegDY & 0xffff;
3349: uint32 dst = RegDX & 0xffff;
3350: dst = acc_subx_16(cpu, src, dst);
3351: RegDX = (RegDX & 0xffff0000) | dst;
3352: } else if (n < 16) {
3353: // SUBX.W -(Ay),-(Ax)
3354: CYCLE2(9, 10);
3355: uint32 srcea = internal_ea_anpd_16(cpu, RegIRY);
3356: uint32 dstea = internal_ea_anpd_16(cpu, RegIRX);
3357: uint32 src = m68030_read_16(cpu, srcea);
3358: uint32 dst = m68030_read_16(cpu, dstea);
3359: dst = acc_subx_16(cpu, src, dst);
3360: m68030_write_16(cpu, dstea, dst);
3361: } else {
3362: // SUB.W Dx,<ea>
3363: CYCLE2(3, 4);
3364: uint32 ea = cea_data_16(cpu);
3365: uint32 data = m68030_read_16(cpu, ea);
3366: data = acc_sub_16(cpu, RegDX & 0xffff, data);
3367: m68030_write_16(cpu, ea, data);
3368: }
3369: }
3370:
3371: // %1001_xxx110_000yyy SUBX.L Dy,Dx
3372: // %1001_xxx110_001yyy SUBX.L -(Ay),-(Ax)
3373: // %1001_xxx110_mmmrrr SUB.L Dx,<ea>
3374: OP_DEF(sub_l_dn_ea)
3375: {
3376: uint n = RegIR & 0x3f;
3377:
3378: if (n < 8) {
3379: // SUBX.L Dy,Dx
3380: CYCLE(2);
3381: uint32 src = RegDY;
3382: uint32 dst = RegDX;
3383: RegDX = acc_subx_32(cpu, src, dst);
3384: } else if (n < 16) {
3385: // SUBX.L -(Ay),-(Ax)
3386: CYCLE2(9, 10);
3387: uint32 srcea = internal_ea_anpd_32(cpu, RegIRY);
3388: uint32 dstea = internal_ea_anpd_32(cpu, RegIRX);
3389: uint32 src = m68030_read_32(cpu, srcea);
3390: uint32 dst = m68030_read_32(cpu, dstea);
3391: dst = acc_subx_32(cpu, src, dst);
3392: m68030_write_32(cpu, dstea, dst);
3393: } else {
3394: // SUB.L Dx,<ea>
3395: CYCLE2(3, 4);
3396: uint32 ea = cea_data_32(cpu);
3397: uint32 data = m68030_read_32(cpu, ea);
3398: data = acc_sub_32(cpu, RegDX, data);
3399: m68030_write_32(cpu, ea, data);
3400: }
3401: }
3402:
3403: // %1001_xxx111_mmmrrr SUBA.L <ea>,Ax
3404: OP_DEF(suba_l)
3405: {
3406: CYCLE(2);
3407: uint32 src = fea_all_32(cpu);
3408: RegAX -= src;
3409: }
3410:
3411: // %1010_nnnnnn_nnnnnn A-Line
3412: OP_DEF(aline)
3413: {
3414: if (cpu->aline_callback) {
3415: if (cpu->aline_callback(cpu, cpu->aline_arg)) {
3416: return;
3417: }
3418: }
3419: // A系列命令例外
3420: m68030_exception(cpu, M68K_EXCEP_ALINE);
3421: }
3422:
3423: // %1011_xxx000_mmmrrr CMP.B <ea>,Dx
3424: OP_DEF(cmp_b)
3425: {
3426: CYCLE(2);
3427: uint32 src = fea_all_8(cpu);
3428: uint32 dst = RegDX & 0xff;
3429: acc_cmp_8(cpu, src, dst);
3430: }
3431:
3432: // %1011_xxx001_mmmrrr CMP.W <ea>,Dx
3433: OP_DEF(cmp_w)
3434: {
3435: CYCLE(2);
3436: uint32 src = fea_all_16(cpu);
3437: uint32 dst = RegDX & 0xffff;
3438: acc_cmp_16(cpu, src, dst);
3439: }
3440:
3441: // %1011_xxx010_mmmrrr CMP.L <ea>,Dx
3442: OP_DEF(cmp_l)
3443: {
3444: CYCLE(2);
3445: uint32 src = fea_all_32(cpu);
3446: acc_cmp_32(cpu, src, RegDX);
3447: }
3448:
3449: // %1011_xxx011_mmmrrr CMPA.W <ea>,Ax
3450: OP_DEF(cmpa_w)
3451: {
3452: CYCLE(4);
3453: uint32 src = (uint32)(int32)(int16)fea_all_16(cpu);
3454: acc_cmp_32(cpu, src, RegAX);
3455: }
3456:
3457: // %1011_xxx100_mmmrrr EOR.B Dx,<ea>
3458: // %1011_xxx100_001yyy CMPM.B (Ay)+,(Ax)+
3459: OP_DEF(eor_b)
3460: {
3461: uint n = RegIR & 0x3f;
3462:
3463: if (n < 8) {
3464: // EOR.B Dx,Dy
3465: CYCLE(2);
3466: uint32 data = (RegD(n) ^ RegDX) & 0xff;
3467: RegD(n) = (RegD(n) & 0xffffff00) | data;
3468: acc_move_8(cpu, data);
3469: } else if (n < 16) {
3470: // CMPM.B (Ay)+,(Ax)+
3471: CYCLE(8);
3472: uint32 srcea = internal_ea_anpi_8(cpu, RegIRY);
3473: uint32 dstea = internal_ea_anpi_8(cpu, RegIRX);
3474: uint32 src = m68030_read_8(cpu, srcea);
3475: uint32 dst = m68030_read_8(cpu, dstea);
3476: acc_cmp_8(cpu, src, dst);
3477: } else {
3478: // EOR.B Dx,<ea>
3479: CYCLE2(3, 4);
3480: uint32 ea = cea_data_8(cpu);
3481: uint32 data = m68030_read_8(cpu, ea);
3482: data ^= (RegDX & 0xff);
3483: m68030_write_8(cpu, ea, data);
3484: acc_move_8(cpu, data);
3485: }
3486: }
3487:
3488: // %1011_xxx101_mmmrrr EOR.W Dx,<ea>
3489: // %1011_xxx101_001yyy CMPM.W (Ay)+,(Ax)+
3490: OP_DEF(eor_w)
3491: {
3492: uint n = RegIR & 0x3f;
3493:
3494: if (n < 8) {
3495: // EOR.W Dx,Dy
3496: CYCLE(2);
3497: uint32 data = (RegD(n) ^ RegDX) & 0xffff;
3498: RegD(n) = (RegD(n) & 0xffff0000) | data;
3499: acc_move_16(cpu, data);
3500: } else if (n < 16) {
3501: // CMPM.W (Ay)+,(Ax)+
3502: CYCLE(8);
3503: uint32 srcea = internal_ea_anpi_16(cpu, RegIRY);
3504: uint32 dstea = internal_ea_anpi_16(cpu, RegIRX);
3505: uint32 src = m68030_read_16(cpu, srcea);
3506: uint32 dst = m68030_read_16(cpu, dstea);
3507: acc_cmp_16(cpu, src, dst);
3508: } else {
3509: // EOR.W Dx,<ea>
3510: CYCLE2(3, 4);
3511: uint32 ea = cea_data_16(cpu);
3512: uint32 data = m68030_read_16(cpu, ea);
3513: data ^= (RegDX & 0xffff);
3514: m68030_write_16(cpu, ea, data);
3515: acc_move_16(cpu, data);
3516: }
3517: }
3518:
3519: // %1011_xxx110_mmmrrr EOR.L Dx,<ea>
3520: // %1011_xxx110_001yyy CMPM.L (Ay)+,(Ax)+
3521: OP_DEF(eor_l)
3522: {
3523: uint n = RegIR & 0x3f;
3524:
3525: if (n < 8) {
3526: CYCLE(2);
3527: // EOR.L Dx,Dy
3528: RegD(n) ^= RegDX;
3529: acc_move_32(cpu, RegD(n));
3530: } else if (n < 16) {
3531: // CMPM.L (Ay)+,(Ax)+
3532: CYCLE(8);
3533: uint32 srcea = internal_ea_anpi_32(cpu, RegIRY);
3534: uint32 dstea = internal_ea_anpi_32(cpu, RegIRX);
3535: uint32 src = m68030_read_32(cpu, srcea);
3536: uint32 dst = m68030_read_32(cpu, dstea);
3537: acc_cmp_32(cpu, src, dst);
3538: } else {
3539: // EOR.L Dx,<ea>
3540: CYCLE2(3, 4);
3541: uint32 ea = cea_data_32(cpu);
3542: uint32 data = m68030_read_32(cpu, ea);
3543: data ^= RegDX;
3544: m68030_write_32(cpu, ea, data);
3545: acc_move_32(cpu, data);
3546: }
3547: }
3548:
3549: // %1011_xxx111_mmmrrr CMPA.L <ea>,Ax
3550: OP_DEF(cmpa_l)
3551: {
3552: CYCLE(4);
3553: uint32 src = fea_all_32(cpu);
3554: acc_cmp_32(cpu, src, RegAX);
3555: }
3556:
3557: // %1100_xxx000_mmmrrr AND.B <ea>,Dx
3558: OP_DEF(and_b_ea_dn)
3559: {
3560: CYCLE(2);
3561: uint32 src = fea_data_8(cpu);
3562: uint32 dst = (RegDX & 0x000000ff) & src;
3563: acc_move_8(cpu, dst);
3564: RegDX = (RegDX & 0xffffff00) | dst;
3565: }
3566:
3567: // %1100_xxx001_mmmrrr AND.W <ea>,Dx
3568: OP_DEF(and_w_ea_dn)
3569: {
3570: CYCLE(2);
3571: uint32 src = fea_data_16(cpu);
3572: uint32 dst = (RegDX & 0x0000ffff) & src;
3573: acc_move_16(cpu, dst);
3574: RegDX = (RegDX & 0xffff0000) | dst;
3575: }
3576:
3577: // %1100_xxx010_mmmrrr AND.L <ea>,Dx
3578: OP_DEF(and_l_ea_dn)
3579: {
3580: CYCLE(2);
3581: uint32 src = fea_data_32(cpu);
3582: RegDX = RegDX & src;
3583: acc_move_32(cpu, RegDX);
3584: }
3585:
3586: // %1100_xxx011_mmmrrr MULU.W <ea>,Dx
3587: OP_DEF(mulu_w)
3588: {
3589: CYCLE(28); // 実際にはこれは最大値
3590: uint32 src = fea_data_16(cpu);
3591: uint32 dst = RegDX & 0xffff;
3592: RegDX = acc_mulu_16(cpu, src, dst);
3593: }
3594:
3595: // %1100_xxx100_000yyy ABCD.B Dy,Dx
3596: // %1100_xxx100_001yyy ABCD.B -(Ay),-(Ax)
3597: // %1100_xxx100_mmmrrr AND.B Dx,<ea>
3598: OP_DEF(and_b_dn_ea)
3599: {
3600: uint n = RegIR & 0x3f;
3601:
3602: if (n < 8) {
3603: // ABCD.B Dy,Dx
3604: CYCLE(4);
3605: uint32 src = RegDY & 0xff;
3606: uint32 dst = RegDX & 0xff;
3607: dst = acc_abcd_8(cpu, src, dst);
3608: RegDX &= 0xffffff00;
3609: RegDX |= dst;
3610: return;
3611: } else if (n < 16) {
3612: // ABCD.B -(Ay),-(Ax)
3613: CYCLE2(13, 14);
3614: uint32 srcea = internal_ea_anpd_8(cpu, RegIRY);
3615: uint32 dstea = internal_ea_anpd_8(cpu, RegIRX);
3616: uint32 src = m68030_read_8(cpu, srcea);
3617: uint32 dst = m68030_read_8(cpu, dstea);
3618: dst = acc_abcd_8(cpu, src, dst);
3619: m68030_write_8(cpu, dstea, dst);
3620: return;
3621: } else {
3622: // AND.B Dx,<ea>
3623: CYCLE2(3, 4);
3624: uint32 ea = cea_data_8(cpu);
3625: uint32 dst = m68030_read_8(cpu, ea);
3626: dst &= RegDX & 0xff;
3627: acc_move_8(cpu, dst);
3628: m68030_write_8(cpu, ea, dst);
3629: }
3630: }
3631:
3632: // %1100_xxx101_000yyy EXG.L Dx,Dy
3633: // %1100_xxx101_001yyy EXG.L Ax,Ay
3634: // %1100_xxx101_mmmrrr AND.W Dx,<ea>
3635: OP_DEF(and_w_dn_ea)
3636: {
3637: uint n = RegIR & 0x3f;
3638:
3639: if (n < 8) {
3640: // EXG.L Dx,Dy
3641: CYCLE(4);
3642: int x = RegIRX;
3643: int y = n;
3644: uint32 tmp = RegD(x);
3645: RegD(x) = RegD(y);
3646: RegD(y) = tmp;
3647: return;
3648: } else if (n < 16) {
3649: // EXG.L Ax,Ay
3650: // ここでは x は 0..7 で A(x)、y は 8..15 で R(y)
3651: CYCLE(4);
3652: int x = RegIRX;
3653: int y = n;
3654: uint32 tmp = RegA(x);
3655: RegA(x) = RegR(y);
3656: RegR(y) = tmp;
3657: return;
3658: } else {
3659: // AND.W Dx,<ea>
3660: CYCLE2(3, 4);
3661: uint32 ea = cea_data_16(cpu);
3662: uint32 dst = m68030_read_16(cpu, ea);
3663: dst &= RegDX & 0xffff;
3664: acc_move_16(cpu, dst);
3665: m68030_write_16(cpu, ea, dst);
3666: }
3667: }
3668:
3669: // %1100_xxx110_001yyy EXG.L Dx,Ay
3670: // %1100_xxx110_mmmrrr AND.L Dx,<ea>
3671: OP_DEF(and_l_dn_ea)
3672: {
3673: uint n = RegIR & 0x3f;
3674:
3675: if (n < 8) {
3676: op_illegal(cpu);
3677: return;
3678: } else if (n < 16) {
3679: // EXG.L Dx,Ay
3680: // ここでは x は 0..7 で D(x)、y は 8..15 で R(y)
3681: CYCLE(4);
3682: int x = RegIRX;
3683: int y = n;
3684: uint32 tmp = RegD(x);
3685: RegD(x) = RegR(y);
3686: RegR(y) = tmp;
3687: return;
3688: } else {
3689: // AND.L Dx,<ea>
3690: CYCLE2(3, 4);
3691: uint32 ea = cea_data_32(cpu);
3692: uint32 dst = m68030_read_32(cpu, ea);
3693: dst &= RegDX;
3694: acc_move_32(cpu, dst);
3695: m68030_write_32(cpu, ea, dst);
3696: }
3697: }
3698:
3699: // %1100_xxx111_mmmrrr MULS.W <ea>,Dx
3700: OP_DEF(muls_w)
3701: {
3702: CYCLE(28); // 実際にはこれは最大値
3703: uint32 src = fea_data_16(cpu);
3704: uint32 dst = RegDX & 0xffff;
3705: RegDX = acc_muls_16(cpu, src, dst);
3706: }
3707:
3708: // %1101_xxx000_mmmrrr ADD.B <ea>,Dx
3709: OP_DEF(add_b_ea_dn)
3710: {
3711: CYCLE(2);
3712: uint32 src = fea_all_8(cpu);
3713: uint32 data = acc_add_8(cpu, src, RegDX & 0xff);
3714: RegDX = (RegDX & 0xffffff00) | data;
3715: }
3716:
3717: // %1101_xxx001_mmmrrr ADD.W <ea>,Dx
3718: OP_DEF(add_w_ea_dn)
3719: {
3720: CYCLE(2);
3721: uint32 src = fea_all_16(cpu);
3722: uint32 data = acc_add_16(cpu, src, RegDX & 0xffff);
3723: RegDX = (RegDX & 0xffff0000) | data;
3724: }
3725:
3726: // %1101_xxx010_mmmrrr ADD.L <ea>,Dx
3727: OP_DEF(add_l_ea_dn)
3728: {
3729: CYCLE(2);
3730: uint32 src = fea_all_32(cpu);
3731: RegDX = acc_add_32(cpu, src, RegDX);
3732: }
3733:
3734: // %1101_xxx011_mmmrrr ADDA.W <ea>,Ax
3735: OP_DEF(adda_w)
3736: {
3737: CYCLE(4);
3738: uint32 src = (int32)(int16)fea_all_16(cpu);
3739: RegAX += src;
3740: }
3741:
3742: // %1101_xxx100_000yyy ADDX.B Dy,Dx
3743: // %1101_xxx100_001yyy ADDX.B -(Ay),-(Ax)
3744: // %1101_xxx100_mmmrrr ADD.B Dx,<ea>
3745: OP_DEF(add_b_dn_ea)
3746: {
3747: uint n = RegIR & 0x3f;
3748:
3749: if (n < 8) {
3750: // ADDX.B Dy,Dx
3751: CYCLE(2);
3752: uint32 src = RegDY & 0xff;
3753: uint32 dst = RegDX & 0xff;
3754: dst = acc_addx_8(cpu, src, dst);
3755: RegDX = (RegDX & 0xffffff00) | dst;
3756: } else if (n < 16) {
3757: // ADDX.B -(Ay),-(Ax)
3758: CYCLE2(9, 10);
3759: uint32 srcea = internal_ea_anpd_8(cpu, RegIRY);
3760: uint32 dstea = internal_ea_anpd_8(cpu, RegIRX);
3761: uint32 src = m68030_read_8(cpu, srcea);
3762: uint32 dst = m68030_read_8(cpu, dstea);
3763: dst = acc_addx_8(cpu, src, dst);
3764: m68030_write_8(cpu, dstea, dst);
3765: } else {
3766: // ADD.B Dx,<ea>
3767: CYCLE2(3, 4);
3768: uint32 ea = cea_data_8(cpu);
3769: uint32 data = m68030_read_8(cpu, ea);
3770: data = acc_add_8(cpu, RegDX & 0xff, data);
3771: m68030_write_8(cpu, ea, data);
3772: }
3773: }
3774:
3775: // %1101_xxx101_000yyy ADDX.W Dy,Dx
3776: // %1101_xxx101_001yyy ADDX.W -(Ay),-(Ax)
3777: // %1101_xxx101_mmmrrr ADD.W Dx,<ea>
3778: OP_DEF(add_w_dn_ea)
3779: {
3780: uint n = RegIR & 0x3f;
3781:
3782: if (n < 8) {
3783: // ADDX.W Dy,Dx
3784: CYCLE(2);
3785: uint32 src = RegDY & 0xffff;
3786: uint32 dst = RegDX & 0xffff;
3787: dst = acc_addx_16(cpu, src, dst);
3788: RegDX = (RegDX & 0xffff0000) | dst;
3789: } else if (n < 16) {
3790: // ADDX.W -(Ay),-(Ax)
3791: CYCLE2(9, 10);
3792: uint32 srcea = internal_ea_anpd_16(cpu, RegIRY);
3793: uint32 dstea = internal_ea_anpd_16(cpu, RegIRX);
3794: uint32 src = m68030_read_16(cpu, srcea);
3795: uint32 dst = m68030_read_16(cpu, dstea);
3796: dst = acc_addx_16(cpu, src, dst);
3797: m68030_write_16(cpu, dstea, dst);
3798: } else {
3799: // ADD.W Dx,<ea>
3800: CYCLE2(3, 4);
3801: uint32 ea = cea_data_16(cpu);
3802: uint32 data = m68030_read_16(cpu, ea);
3803: data = acc_add_16(cpu, RegDX & 0xffff, data);
3804: m68030_write_16(cpu, ea, data);
3805: }
3806: }
3807:
3808: // %1101_xxx110_000yyy ADDX.L Dy,Dx
3809: // %1101_xxx110_001yyy ADDX.L -(Ay),-(Ax)
3810: // %1101_xxx110_mmmrrr ADD.L Dx,<ea>
3811: OP_DEF(add_l_dn_ea)
3812: {
3813: uint n = RegIR & 0x3f;
3814:
3815: if (n < 8) {
3816: // ADDX.L Dy,Dx
3817: CYCLE(2);
3818: uint32 src = RegDY;
3819: uint32 dst = RegDX;
3820: RegDX = acc_addx_32(cpu, src, dst);
3821: } else if (n < 16) {
3822: // ADDX.L -(Ay),-(Ax)
3823: CYCLE2(9, 10);
3824: uint32 srcea = internal_ea_anpd_32(cpu, RegIRY);
3825: uint32 dstea = internal_ea_anpd_32(cpu, RegIRX);
3826: uint32 src = m68030_read_32(cpu, srcea);
3827: uint32 dst = m68030_read_32(cpu, dstea);
3828: dst = acc_addx_32(cpu, src, dst);
3829: m68030_write_32(cpu, dstea, dst);
3830: } else {
3831: // ADD.L Dx,<ea>
3832: CYCLE2(3, 4);
3833: uint32 ea = cea_data_32(cpu);
3834: uint32 data = m68030_read_32(cpu, ea);
3835: data = acc_add_32(cpu, RegDX, data);
3836: m68030_write_32(cpu, ea, data);
3837: }
3838: }
3839:
3840: // %1101_xxx111_mmmrrr ADDA.L <ea>,Ax
3841: OP_DEF(adda_l)
3842: {
3843: CYCLE(2);
3844: uint32 src = fea_all_32(cpu);
3845: RegAX += src;
3846: }
3847:
3848: // %1110_qqq000_000yyy ASR.B #qqq,Dy
3849: // %1110_qqq000_001yyy LSR.B #qqq,Dy
3850: // %1110_qqq000_010yyy ROXR.B #qqq,Dy
3851: // %1110_qqq000_011yyy ROR.B #qqq,Dy
3852: // %1110_xxx000_100yyy ASR.B Dx,Dy
3853: // %1110_xxx000_101yyy LSR.B Dx,Dy
3854: // %1110_xxx000_110yyy ROXR.B Dx,Dy
3855: // %1110_xxx000_111yyy ROR.B Dx,Dy
3856: OP_DEF(asr_b_imm)
3857: {
3858: int count;
3859: uint32 data;
3860: switch (eamode(RegIR)) {
3861: case 0: // ASR.B #qqq,Dy
3862: CYCLE(4);
3863: count = RegIRX;
3864: count = (count == 0) ? 8 : count;
3865: __assume(1 <= count && count <= 8);
3866: data = acc_asr_8(cpu, RegDY & 0xff, count);
3867: RegDY = (RegDY & 0xffffff00) | data;
3868: return;
3869: case 1: // LSR.B #qqq,Dy
3870: CYCLE(4);
3871: count = RegIRX;
3872: count = (count == 0) ? 8 : count;
3873: __assume(1 <= count && count <= 8);
3874: data = acc_lsr_8(cpu, RegDY & 0xff, count);
3875: RegDY = (RegDY & 0xffffff00) | data;
3876: return;
3877: case 2: // ROXR.B #qqq,Dy
3878: CYCLE(12);
3879: count = RegIRX;
3880: count = (count == 0) ? 8 : count;
3881: __assume(1 <= count && count <= 8);
3882: data = acc_roxr_8(cpu, RegDY & 0xff, count);
3883: RegDY = (RegDY & 0xffffff00) | data;
3884: return;
3885: case 3: // ROR.B #qqq,Dy
3886: CYCLE(6);
3887: count = RegIRX;
3888: count = (count == 0) ? 8 : count;
3889: __assume(1 <= count && count <= 8);
3890: data = acc_ror_8(cpu, RegDY & 0xff, count);
3891: RegDY = (RegDY & 0xffffff00) | data;
3892: return;
3893: case 4: // ASR.B Dx,Dy
3894: count = RegDX & 63;
3895: // シフト数がデータサイズを越えるかどうかでサイクルが違う
3896: CYCLE(count <= 8 ? 6 : 10);
3897: __assume(0 <= count && count < 64);
3898: data = acc_asr_8(cpu, RegDY & 0xff, count);
3899: RegDY = (RegDY & 0xffffff00) | data;
3900: return;
3901: case 5: // LSR.B Dx,Dy
3902: count = RegDX & 63;
3903: // シフト数がデータサイズを越えるかどうかでサイクルが違う
3904: CYCLE(count <= 8 ? 6 : 8);
3905: __assume(0 <= count && count < 64);
3906: data = acc_lsr_8(cpu, RegDY & 0xff, count);
3907: RegDY = (RegDY & 0xffffff00) | data;
3908: return;
3909: case 6: // ROXR.B Dx,Dy
3910: CYCLE(12);
3911: count = RegDX & 63;
3912: __assume(0 <= count && count < 64);
3913: data = acc_roxr_8(cpu, RegDY & 0xff, count);
3914: RegDY = (RegDY & 0xffffff00) | data;
3915: return;
3916: case 7: // ROR.B Dx,Dy
3917: CYCLE(8);
3918: count = RegDX & 63;
3919: __assume(0 <= count && count < 64);
3920: data = acc_ror_8(cpu, RegDY & 0xff, count);
3921: RegDY = (RegDY & 0xffffff00) | data;
3922: return;
3923: }
3924: }
3925:
3926: // %1110_qqq001_000yyy ASR.W #qqq,Dy
3927: // %1110_qqq001_001yyy LSR.W #qqq,Dy
3928: // %1110_qqq001_010yyy ROXR.W #qqq,Dy
3929: // %1110_qqq001_011yyy ROR.W #qqq,Dy
3930: // %1110_xxx001_100yyy ASR.W Dx,Dy
3931: // %1110_xxx001_101yyy LSR.W Dx,Dy
3932: // %1110_xxx001_110yyy ROXR.W Dx,Dy
3933: // %1110_xxx001_111yyy ROR.W Dx,Dy
3934: OP_DEF(asr_w_imm)
3935: {
3936: int count;
3937: uint32 data;
3938: switch (eamode(RegIR)) {
3939: case 0: // ASR.W #qqq,Dy
3940: CYCLE(4);
3941: count = RegIRX;
3942: count = (count == 0) ? 8 : count;
3943: __assume(1 <= count && count <= 8);
3944: data = acc_asr_16(cpu, RegDY & 0xffff, count);
3945: RegDY = (RegDY & 0xffff0000) | data;
3946: return;
3947: case 1: // LSR.W #qqq,Dy
3948: CYCLE(4);
3949: count = RegIRX;
3950: count = (count == 0) ? 8 : count;
3951: __assume(1 <= count && count <= 8);
3952: data = acc_lsr_16(cpu, RegDY & 0xffff, count);
3953: RegDY = (RegDY & 0xffff0000) | data;
3954: return;
3955: case 2: // ROXR.W #qqq,Dy
3956: CYCLE(12);
3957: count = RegIRX;
3958: count = (count == 0) ? 8 : count;
3959: __assume(1 <= count && count <= 8);
3960: data = acc_roxr_16(cpu, RegDY & 0xffff, count);
3961: RegDY = (RegDY & 0xffff0000) | data;
3962: return;
3963: case 3: // ROR.W #qqq,Dy
3964: CYCLE(6);
3965: count = RegIRX;
3966: count = (count == 0) ? 8 : count;
3967: __assume(1 <= count && count <= 8);
3968: data = acc_ror_16(cpu, RegDY & 0xffff, count);
3969: RegDY = (RegDY & 0xffff0000) | data;
3970: return;
3971: case 4: // ASR.W Dx,Dy
3972: count = RegDX & 63;
3973: // シフト数がデータサイズを越えるかどうかでサイクルが違う
3974: CYCLE(count <= 16 ? 6 : 10);
3975: __assume(0 <= count && count < 64);
3976: data = acc_asr_16(cpu, RegDY & 0xffff, count);
3977: RegDY = (RegDY & 0xffff0000) | data;
3978: return;
3979: case 5: // LSR.W Dx,Dy
3980: count = RegDX & 63;
3981: // シフト数がデータサイズを越えるかどうかでサイクルが違う
3982: CYCLE(count <= 16 ? 6 : 8);
3983: __assume(0 <= count && count < 64);
3984: data = acc_lsr_16(cpu, RegDY & 0xffff, count);
3985: RegDY = (RegDY & 0xffff0000) | data;
3986: return;
3987: case 6: // ROXR.W Dx,Dy
3988: CYCLE(12);
3989: count = RegDX & 63;
3990: __assume(0 <= count && count < 64);
3991: data = acc_roxr_16(cpu, RegDY & 0xffff, count);
3992: RegDY = (RegDY & 0xffff0000) | data;
3993: return;
3994: case 7: // ROR.W Dx,Dy
3995: CYCLE(8);
3996: count = RegDX & 63;
3997: __assume(0 <= count && count < 64);
3998: data = acc_ror_16(cpu, RegDY & 0xffff, count);
3999: RegDY = (RegDY & 0xffff0000) | data;
4000: return;
4001: }
4002: }
4003:
4004: // %1110_qqq010_000yyy ASR.L #qqq,Dy
4005: // %1110_qqq010_001yyy LSR.L #qqq,Dy
4006: // %1110_qqq010_010yyy ROXR.L #qqq,Dy
4007: // %1110_qqq010_011yyy ROR.L #qqq,Dy
4008: // %1110_xxx010_100yyy ASR.L Dx,Dy
4009: // %1110_xxx010_101yyy LSR.L Dx,Dy
4010: // %1110_xxx010_110yyy ROXR.L Dx,Dy
4011: // %1110_xxx010_111yyy ROR.L Dx,Dy
4012: OP_DEF(asr_l_imm)
4013: {
4014: int count;
4015: switch (eamode(RegIR)) {
4016: case 0: // ASR.L #qqq,Dy
4017: CYCLE(4);
4018: count = RegIRX;
4019: count = (count == 0) ? 8 : count;
4020: __assume(1 <= count && count <= 8);
4021: RegDY = acc_asr_32(cpu, RegDY, count);
4022: return;
4023: case 1: // LSR.L #qqq,Dy
4024: CYCLE(4);
4025: count = RegIRX;
4026: count = (count == 0) ? 8 : count;
4027: __assume(1 <= count && count <= 8);
4028: RegDY = acc_lsr_32(cpu, RegDY, count);
4029: return;
4030: case 2: // ROXR.L #qqq,Dy
4031: CYCLE(12);
4032: count = RegIRX;
4033: count = (count == 0) ? 8 : count;
4034: __assume(1 <= count && count <= 8);
4035: RegDY = acc_roxr_32(cpu, RegDY, count);
4036: return;
4037: case 3: // ROR.L #qqq,Dy
4038: CYCLE(6);
4039: count = RegIRX;
4040: count = (count == 0) ? 8 : count;
4041: __assume(1 <= count && count <= 8);
4042: RegDY = acc_ror_32(cpu, RegDY, count);
4043: return;
4044: case 4: // ASR.L Dx,Dy
4045: count = RegDX & 63;
4046: // シフト数がデータサイズを越えるかどうかでサイクルが違う
4047: CYCLE(count <= 32 ? 6 : 10);
4048: __assume(0 <= count && count < 64);
4049: RegDY = acc_asr_32(cpu, RegDY, count);
4050: return;
4051: case 5: // LSR.L Dx,Dy
4052: count = RegDX & 63;
4053: // シフト数がデータサイズを越えるかどうかでサイクルが違う
4054: CYCLE(count <= 32 ? 6 : 8);
4055: __assume(0 <= count && count < 64);
4056: RegDY = acc_lsr_32(cpu, RegDY, count);
4057: return;
4058: case 6: // ROXR.L Dx,Dy
4059: CYCLE(12);
4060: count = RegDX & 63;
4061: __assume(0 <= count && count < 64);
4062: RegDY = acc_roxr_32(cpu, RegDY, count);
4063: return;
4064: case 7: // ROR.L Dx,Dy
4065: CYCLE(8);
4066: count = RegDX & 63;
4067: __assume(0 <= count && count < 64);
4068: RegDY = acc_ror_32(cpu, RegDY, count);
4069: return;
4070: }
4071: }
4072:
4073: // %1110_000011_mmmrrr ASR.W <ea>
4074: OP_DEF(asr_w)
4075: {
4076: CYCLE(4);
4077: uint32 ea = cea_data_16(cpu);
4078: uint32 data = m68030_read_16(cpu, ea);
4079: data = acc_asr_16(cpu, data, 1);
4080: m68030_write_16(cpu, ea, data);
4081: }
4082:
4083: // %1110_qqq100_000yyy ASL.B #qqq,Dy
4084: // %1110_qqq100_001yyy LSL.B #qqq,Dy
4085: // %1110_qqq100_010yyy ROXL.B #qqq,Dy
4086: // %1110_qqq100_011yyy ROL.B #qqq,Dy
4087: // %1110_xxx100_100yyy ASL.B Dx,Dy
4088: // %1110_xxx100_101yyy LSL.B Dx,Dy
4089: // %1110_xxx100_110yyy ROXL.B Dx,Dy
4090: // %1110_xxx100_111yyy ROL.B Dx,Dy
4091: OP_DEF(asl_b_imm)
4092: {
4093: int count;
4094: uint32 data;
4095: switch (eamode(RegIR)) {
4096: case 0: // ASL.B #qqq,Dy
4097: CYCLE(6);
4098: count = RegIRX;
4099: count = (count == 0) ? 8 : count;
4100: __assume(1 <= count && count <= 8);
4101: data = acc_asl_8(cpu, RegDY & 0xff, count);
4102: RegDY = (RegDY & 0xffffff00) | data;
4103: return;
4104: case 1: // LSL.B #qqq,Dy
4105: CYCLE(4);
4106: count = RegIRX;
4107: count = (count == 0) ? 8 : count;
4108: __assume(1 <= count && count <= 8);
4109: data = acc_lsl_8(cpu, RegDY & 0xff, count);
4110: RegDY = (RegDY & 0xffffff00) | data;
4111: return;
4112: case 2: // ROXL.B #qqq,Dy
4113: CYCLE(12);
4114: count = RegIRX;
4115: count = (count == 0) ? 8 : count;
4116: __assume(1 <= count && count <= 8);
4117: data = acc_roxl_8(cpu, RegDY & 0xff, count);
4118: RegDY = (RegDY & 0xffffff00) | data;
4119: return;
4120: case 3: // ROL.B #qqq,Dy
4121: CYCLE(6);
4122: count = RegIRX;
4123: count = (count == 0) ? 8 : count;
4124: __assume(1 <= count && count <= 8);
4125: data = acc_rol_8(cpu, RegDY & 0xff, count);
4126: RegDY = (RegDY & 0xffffff00) | data;
4127: return;
4128: case 4: // ASL.B Dx,Dy
4129: CYCLE(8);
4130: count = RegDX & 63;
4131: __assume(0 <= count && count < 64);
4132: data = acc_asl_8(cpu, RegDY & 0xff, count);
4133: RegDY = (RegDY & 0xffffff00) | data;
4134: return;
4135: case 5: // LSL.B Dx,Dy
4136: count = RegDX & 63;
4137: // シフト数がデータサイズを越えるかどうかでサイクルが違う
4138: CYCLE(count <= 8 ? 6 : 8);
4139: __assume(0 <= count && count < 64);
4140: data = acc_lsl_8(cpu, RegDY & 0xff, count);
4141: RegDY = (RegDY & 0xffffff00) | data;
4142: return;
4143: case 6: // ROXL.B Dx,Dy
4144: CYCLE(12);
4145: count = RegDX & 63;
4146: __assume(0 <= count && count < 64);
4147: data = acc_roxl_8(cpu, RegDY & 0xff, count);
4148: RegDY = (RegDY & 0xffffff00) | data;
4149: return;
4150: case 7: // ROL.B Dx,Dy
4151: CYCLE(8);
4152: count = RegDX & 63;
4153: __assume(0 <= count && count < 64);
4154: data = acc_rol_8(cpu, RegDY & 0xff, count);
4155: RegDY = (RegDY & 0xffffff00) | data;
4156: return;
4157: }
4158: }
4159:
4160: // %1110_qqq101_000yyy ASL.W #qqq,Dy
4161: // %1110_qqq101_001yyy LSL.W #qqq,Dy
4162: // %1110_qqq101_010yyy ROXL.W #qqq,Dy
4163: // %1110_qqq101_011yyy ROL.W #qqq,Dy
4164: // %1110_xxx101_100yyy ASL.W Dx,Dy
4165: // %1110_xxx101_101yyy LSL.W Dx,Dy
4166: // %1110_xxx101_110yyy ROXL.W Dx,Dy
4167: // %1110_xxx101_111yyy ROL.W Dx,Dy
4168: OP_DEF(asl_w_imm)
4169: {
4170: int count;
4171: uint32 data;
4172: switch (eamode(RegIR)) {
4173: case 0: // ASL.W #qqq,Dy
4174: CYCLE(6);
4175: count = RegIRX;
4176: count = (count == 0) ? 8 : count;
4177: __assume(1 <= count && count <= 8);
4178: data = acc_asl_16(cpu, RegDY & 0xffff, count);
4179: RegDY = (RegDY & 0xffff0000) | data;
4180: return;
4181: case 1: // LSL.W #qqq,Dy
4182: CYCLE(4);
4183: count = RegIRX;
4184: count = (count == 0) ? 8 : count;
4185: __assume(1 <= count && count <= 8);
4186: data = acc_lsl_16(cpu, RegDY & 0xffff, count);
4187: RegDY = (RegDY & 0xffff0000) | data;
4188: return;
4189: case 2: // ROXL.W #qqq,Dy
4190: CYCLE(12);
4191: count = RegIRX;
4192: count = (count == 0) ? 8 : count;
4193: __assume(1 <= count && count <= 8);
4194: data = acc_roxl_16(cpu, RegDY & 0xffff, count);
4195: RegDY = (RegDY & 0xffff0000) | data;
4196: return;
4197: case 3: // ROL.W #qqq,Dy
4198: CYCLE(6);
4199: count = RegIRX;
4200: count = (count == 0) ? 8 : count;
4201: __assume(1 <= count && count <= 8);
4202: data = acc_rol_16(cpu, RegDY & 0xffff, count);
4203: RegDY = (RegDY & 0xffff0000) | data;
4204: return;
4205: case 4: // ASL.W Dx,Dy
4206: CYCLE(8);
4207: count = RegDX & 63;
4208: __assume(0 <= count && count < 64);
4209: data = acc_asl_16(cpu, RegDY & 0xffff, count);
4210: RegDY = (RegDY & 0xffff0000) | data;
4211: return;
4212: case 5: // LSL.W Dx,Dy
4213: count = RegDX & 63;
4214: // シフト数がデータサイズを越えるかどうかでサイクルが違う
4215: CYCLE(count <= 16 ? 6 : 8);
4216: __assume(0 <= count && count < 64);
4217: data = acc_lsl_16(cpu, RegDY & 0xffff, count);
4218: RegDY = (RegDY & 0xffff0000) | data;
4219: return;
4220: case 6: // ROXL.W Dx,Dy
4221: CYCLE(12);
4222: count = RegDX & 63;
4223: __assume(0 <= count && count < 64);
4224: data = acc_roxl_16(cpu, RegDY & 0xffff, count);
4225: RegDY = (RegDY & 0xffff0000) | data;
4226: return;
4227: case 7: // ROL.W Dx,Dy
4228: CYCLE(8);
4229: count = RegDX & 63;
4230: __assume(0 <= count && count < 64);
4231: data = acc_rol_16(cpu, RegDY & 0xffff, count);
4232: RegDY = (RegDY & 0xffff0000) | data;
4233: return;
4234: }
4235: }
4236:
4237: // %1110_qqq110_000yyy ASL.L #qqq,Dy
4238: // %1110_qqq110_001yyy LSL.L #qqq,Dy
4239: // %1110_qqq110_010yyy ROXL.L #qqq,Dy
4240: // %1110_qqq110_011yyy ROL.L #qqq,Dy
4241: // %1110_xxx110_100yyy ASL.L Dx,Dy
4242: // %1110_xxx110_101yyy LSL.L Dx,Dy
4243: // %1110_xxx110_110yyy ROXL.L Dx,Dy
4244: // %1110_xxx110_111yyy ROL.L Dx,Dy
4245: OP_DEF(asl_l_imm)
4246: {
4247: int count;
4248: switch (eamode(RegIR)) {
4249: case 0: // ASL.L #qqq,Dy
4250: CYCLE(6);
4251: count = RegIRX;
4252: count = (count == 0) ? 8 : count;
4253: __assume(1 <= count && count <= 8);
4254: RegDY = acc_asl_32(cpu, RegDY, count);
4255: return;
4256: case 1: // LSL.L #qqq,Dy
4257: CYCLE(4);
4258: count = RegIRX;
4259: count = (count == 0) ? 8 : count;
4260: __assume(1 <= count && count <= 8);
4261: RegDY = acc_lsl_32(cpu, RegDY, count);
4262: return;
4263: case 2: // ROXL.L #qqq,Dy
4264: CYCLE(12);
4265: count = RegIRX;
4266: count = (count == 0) ? 8 : count;
4267: __assume(1 <= count && count <= 8);
4268: RegDY = acc_roxl_32(cpu, RegDY, count);
4269: return;
4270: case 3: // ROL.L #qqq,Dy
4271: CYCLE(6);
4272: count = RegIRX;
4273: count = (count == 0) ? 8 : count;
4274: __assume(1 <= count && count <= 8);
4275: RegDY = acc_rol_32(cpu, RegDY, count);
4276: return;
4277: case 4: // ASL.L Dx,Dy
4278: CYCLE(8);
4279: count = RegDX & 63;
4280: __assume(0 <= count && count < 64);
4281: RegDY = acc_asl_32(cpu, RegDY, count);
4282: return;
4283: case 5: // LSL.L Dx,Dy
4284: count = RegDX & 63;
4285: // シフト数がデータサイズを越えるかどうかでサイクルが違う
4286: CYCLE(count <= 32 ? 6 : 8);
4287: __assume(0 <= count && count < 64);
4288: RegDY = acc_lsl_32(cpu, RegDY, count);
4289: return;
4290: case 6: // ROXL.L Dx,Dy
4291: CYCLE(12);
4292: count = RegDX & 63;
4293: __assume(0 <= count && count < 64);
4294: RegDY = acc_roxl_32(cpu, RegDY, count);
4295: return;
4296: case 7: // ROL.L Dx,Dy
4297: CYCLE(8);
4298: count = RegDX & 63;
4299: __assume(0 <= count && count < 64);
4300: RegDY = acc_rol_32(cpu, RegDY, count);
4301: return;
4302: }
4303: }
4304:
4305: // %1110_000111_mmmrrr ASL.W <ea>
4306: OP_DEF(asl_w)
4307: {
4308: CYCLE(6);
4309: uint32 ea = cea_data_16(cpu);
4310: uint32 data = m68030_read_16(cpu, ea);
4311: data = acc_asl_16(cpu, data, 1);
4312: m68030_write_16(cpu, ea, data);
4313: }
4314:
4315: // %1110_001011_mmmrrr LSR.W <ea>
4316: OP_DEF(lsr_w)
4317: {
4318: CYCLE(4);
4319: uint32 ea = cea_data_16(cpu);
4320: uint32 data = m68030_read_16(cpu, ea);
4321: data = acc_lsr_16(cpu, data, 1);
4322: m68030_write_16(cpu, ea, data);
4323: }
4324:
4325: // %1110_001111_mmmrrr LSL.W <ea>
4326: OP_DEF(lsl_w)
4327: {
4328: CYCLE(4);
4329: uint32 ea = cea_data_16(cpu);
4330: uint32 data = m68030_read_16(cpu, ea);
4331: data = acc_lsl_16(cpu, data, 1);
4332: m68030_write_16(cpu, ea, data);
4333: }
4334:
4335: // %1110_010011_mmmrrr ROXR.W <ea>
4336: OP_DEF(roxr_w)
4337: {
4338: CYCLE(4);
4339: uint32 ea = cea_data_16(cpu);
4340: uint32 data = m68030_read_16(cpu, ea);
4341: data = acc_roxr_16(cpu, data, 1);
4342: m68030_write_16(cpu, ea, data);
4343: }
4344:
4345: // %1110_010111_mmmrrr ROXL.W <ea>
4346: OP_DEF(roxl_w)
4347: {
4348: CYCLE(4);
4349: uint32 ea = cea_data_16(cpu);
4350: uint32 data = m68030_read_16(cpu, ea);
4351: data = acc_roxl_16(cpu, data, 1);
4352: m68030_write_16(cpu, ea, data);
4353: }
4354:
4355: // %1110_011011_mmmrrr ROR.W <ea>
4356: OP_DEF(ror_w)
4357: {
4358: CYCLE(6);
4359: uint32 ea = cea_data_16(cpu);
4360: uint32 data = m68030_read_16(cpu, ea);
4361: data = acc_ror_16(cpu, data, 1);
4362: m68030_write_16(cpu, ea, data);
4363: }
4364:
4365: // %1110_011111_mmmrrr ROL.W <ea>
4366: OP_DEF(rol_w)
4367: {
4368: CYCLE(6);
4369: uint32 ea = cea_data_16(cpu);
4370: uint32 data = m68030_read_16(cpu, ea);
4371: data = acc_rol_16(cpu, data, 1);
4372: m68030_write_16(cpu, ea, data);
4373: }
4374:
4375: // %1110_100011_mmmrrr BFTST <ea>{#o:#w}
4376: OP_DEF(bftst)
4377: {
4378: uint n = RegIR & 0x3f;
4379: RegIR2 = m68030_fetch_16(cpu);
4380:
4381: acc_bf bf(cpu);
4382: if (n < 8) {
4383: // BFTST Dn{#o:#w}
4384: bf.LoadReg(n);
4385: } else {
4386: // BFTST <ea>{#o:#w}
4387: uint32 ea = cea_ctrl(cpu);
4388: bf.LoadMem(ea);
4389: }
4390: acc_move_32(cpu, bf.data);
4391: }
4392:
4393: // %1110_100111_mmmrrr BFEXTU <ea>{#o:#w},Dn
4394: OP_DEF(bfextu)
4395: {
4396: uint n = RegIR & 0x3f;
4397: RegIR2 = m68030_fetch_16(cpu);
4398: uint dn = RegIR2 >> 12;
4399:
4400: acc_bf bf(cpu);
4401: if (n < 8) {
4402: // BFEXTU Dn{#o:#w},Dn
4403: bf.LoadReg(n);
4404: } else {
4405: // BFEXTU <ea>{#o:#w},Dn
4406: uint32 ea = cea_ctrl(cpu);
4407: bf.LoadMem(ea);
4408: }
4409: // CCR は操作前のビットフィールドに対して
4410: acc_move_32(cpu, bf.data);
4411: // 符号なしシフト
4412: RegD(dn) = bf.data >> (32 - bf.width);
4413: }
4414:
4415: // %1110_101011_mmmrrr BFCHG <ea>{#o:#w}
4416: OP_DEF(bfchg)
4417: {
4418: uint n = RegIR & 0x3f;
4419: RegIR2 = m68030_fetch_16(cpu);
4420:
4421: acc_bf bf(cpu);
4422: if (n < 8) {
4423: // BFCHG Dn{#o:#w}
4424: bf.LoadReg(n);
4425: } else if (n >= 0x3a) {
4426: // BFCHG <ea> に PC 相対(と #imm) はない
4427: op_illegal(cpu);
4428: } else {
4429: // BFCHG <ea>{#o:#w}
4430: uint32 ea = cea_ctrl(cpu);
4431: bf.LoadMem(ea);
4432: }
4433: // CCR は操作前のビットフィールドに対して
4434: acc_move_32(cpu, bf.data);
4435: bf.data = ~bf.data;
4436: bf.Store(n);
4437: }
4438:
4439: // %1110_101111_mmmrrr BFEXTS <ea>{#o:#w},Dn
4440: OP_DEF(bfexts)
4441: {
4442: uint n = RegIR & 0x3f;
4443: RegIR2 = m68030_fetch_16(cpu);
4444: uint dn = RegIR2 >> 12;
4445:
4446: acc_bf bf(cpu);
4447: if (n < 8) {
4448: // BFEXTS Dn{#o:#w},Dn
4449: bf.LoadReg(n);
4450: } else {
4451: // BFEXTS <ea>{#o:#w},Dn
4452: uint32 ea = cea_ctrl(cpu);
4453: bf.LoadMem(ea);
4454: }
4455: // CCR は操作前のビットフィールドに対して
4456: acc_move_32(cpu, bf.data);
4457: // 符号付きシフト
4458: // XXX 負数の右シフト
4459: RegD(dn) = ((int32)bf.data) >> (32 - bf.width);
4460: }
4461:
4462: // %1110_110011_mmmrrr BFCLR <ea>{#o:#w}
4463: OP_DEF(bfclr)
4464: {
4465: uint n = RegIR & 0x3f;
4466: RegIR2 = m68030_fetch_16(cpu);
4467:
4468: acc_bf bf(cpu);
4469: if (n < 8) {
4470: // BFCLR Dn{#o:#w}
4471: bf.LoadReg(n);
4472: } else if (n >= 0x3a) {
4473: // BFCLR <ea> に PC 相対(と #imm) はない
4474: op_illegal(cpu);
4475: } else {
4476: // BFCLR <ea>{#o:#w}
4477: uint32 ea = cea_ctrl(cpu);
4478: bf.LoadMem(ea);
4479: }
4480: // CCR は操作前のビットフィールドに対して
4481: acc_move_32(cpu, bf.data);
4482: bf.data = 0;
4483: bf.Store(n);
4484: }
4485:
4486: // %1110_110111_mmmrrr BFFFO <ea>{#o:#w},Dn
4487: OP_DEF(bfffo)
4488: {
4489: uint n = RegIR & 0x3f;
4490: RegIR2 = m68030_fetch_16(cpu);
4491: uint dn = RegIR2 >> 12;
4492:
4493: acc_bf bf(cpu);
4494: if (n < 8) {
4495: // BFFFO Dn{#o:#w},Dn
4496: bf.LoadReg(n);
4497: } else {
4498: // BFFFO <ea>{#o:#w},Dn
4499: uint32 ea = cea_ctrl(cpu);
4500: bf.LoadMem(ea);
4501: }
4502: // CCR は操作前のビットフィールドに対して
4503: acc_move_32(cpu, bf.data);
4504: // 1 になっているビットを探す
4505: for (; (int)bf.width-- > 0 && (int32)bf.data >= 0; bf.data <<= 1) {
4506: bf.offset++;
4507: }
4508: RegD(dn) = bf.offset;
4509: }
4510:
4511: // %1110_111011_mmmrrr BFSET <ea>{#o:#w}
4512: OP_DEF(bfset)
4513: {
4514: uint n = RegIR & 0x3f;
4515: RegIR2 = m68030_fetch_16(cpu);
4516:
4517: acc_bf bf(cpu);
4518: if (n < 8) {
4519: // BFSET Dn{#o:#w}
4520: bf.LoadReg(n);
4521: } else if (n >= 0x3a) {
4522: // BFSET <ea> に PC 相対(と #imm) はない
4523: op_illegal(cpu);
4524: } else {
4525: // BFSET <ea>{#o:#w}
4526: uint32 ea = cea_ctrl(cpu);
4527: bf.LoadMem(ea);
4528: }
4529: // CCR は操作前のビットフィールドに対して
4530: acc_move_32(cpu, bf.data);
4531: bf.data = 0xffffffff;
4532: bf.Store(n);
4533: }
4534:
4535: // %1110_111111_mmmrrr BFINS Dn,<ea>{#o:#w}
4536: OP_DEF(bfins)
4537: {
4538: uint n = RegIR & 0x3f;
4539: RegIR2 = m68030_fetch_16(cpu);
4540: uint dn = RegIR2 >> 12;
4541:
4542: acc_bf bf(cpu);
4543: if (n < 8) {
4544: // BFINS Dm,Dn{#o:#w}
4545: bf.LoadReg(n);
4546: } else if (n >= 0x3a) {
4547: // BFINS Dn,<ea> に PC 相対(と #imm) はない
4548: op_illegal(cpu);
4549: } else {
4550: // BFINS Dn,<ea>{#o:#w}
4551: uint32 ea = cea_ctrl(cpu);
4552: bf.LoadMem(ea);
4553: }
4554: bf.data = RegD(dn) << (32 - bf.width);
4555: // BFINS のみ CCR は操作後のビットフィールドに対して
4556: acc_move_32(cpu, bf.data);
4557: bf.Store(n);
4558: }
4559:
4560: // %1111_000nnn_nnnnnn MMU_OP
4561: OP_DEF(mmuop)
4562: {
4563: cpu->ir2 = m68030_fetch_16(cpu);
4564: switch ((cpu->ir2 >> 8) & 0xff) {
4565: case (0x0800 >> 8):
4566: case (0x0900 >> 8):
4567: case (0x0c00 >> 8):
4568: case (0x0d00 >> 8):
4569: // %000_01n00_000_00000 PMOVE.L <ea>,TTn
4570: // %000_01n01_000_00000 PMOVEFD.L <ea>,TTn
4571: {
4572: CYCLE2(12, 14);
4573: uint32 ea = cea_copro(cpu);
4574: uint32 data = m68030_read_32(cpu, ea);
4575: int n = (RegIR2 >> 10) & 1;
4576: cpu->SetTT(n, data);
4577: if ((RegIR2 & 0x0100) == 0)
4578: cpu->atc.flush();
4579: break;
4580: }
4581: case (0x0a00 >> 8):
4582: case (0x0e00 >> 8):
4583: // %000_01n10_000_00000 PMOVE.L TTn,<ea>
4584: {
4585: CYCLE(8);
4586: uint32 ea = cea_copro(cpu);
4587: int n = (RegIR2 >> 10) & 1;
4588: m68030_write_32(cpu, ea, cpu->GetTT(n));
4589: break;
4590: }
4591: case (0x2000 >> 8):
4592: // %001_00000_000_00000 PLOADW SFC,<ea>
4593: // %001_00000_000_00001 PLOADW DFC,<ea>
4594: // %001_00000_000_01yyy PLOADW Dy,<ea>
4595: // %001_00000_000_10nnn PLOADW #<imm>,<ea>
4596: {
4597: cpulog(0, "ploadw");
4598: mmu_op_pload(cpu);
4599: break;
4600: }
4601: case (0x2200 >> 8):
4602: // %001_00010_000_00000 PLOADR SFC,<ea>
4603: // %001_00010_000_00001 PLOADR DFC,<ea>
4604: // %001_00010_000_01yyy PLOADR Dy,<ea>
4605: // %001_00010_000_10nnn PLOADR #<imm>,<ea>
4606: {
4607: cpulog(0, "ploadr");
4608: mmu_op_pload(cpu);
4609: break;
4610: }
4611: case (0x2400 >> 8):
4612: // %001_00100_000_00000 PFLUSHA
4613: {
4614: CYCLE2(12, 14);
4615: cpu->atc.flush();
4616: break;
4617: }
4618: case (0x3000 >> 8):
4619: // %001_10000_nnn_00000 PFLUSH SFC,#<mask>
4620: // %001_10000_nnn_00001 PFLUSH DFC,#<mask>
4621: // %001_10000_nnn_01yyy PFLUSH Dy,#<mask>
4622: // %001_10000_nnn_10nnn PFLUSH #<imm>,#<mask>
4623: {
4624: mmu_op_pflush(cpu);
4625: break;
4626: }
4627: case (0x3800 >> 8):
4628: // %001_11000_nnn_00000 PFLUSH SFC,#<mask>,<ea>
4629: // %001_11000_nnn_00001 PFLUSH DFC,#<mask>,<ea>
4630: // %001_11000_nnn_01yyy PFLUSH Dy,#<mask>,<ea>
4631: // %001_11000_nnn_10nnn PFLUSH #<imm>,#<mask>,<ea>
4632: {
4633: mmu_op_pflush_ea(cpu);
4634: break;
4635: }
4636: case (0x4000 >> 8):
4637: case (0x4100 >> 8):
4638: // %010_00000_000_00000 PMOVE.L <ea>,TC
4639: // %010_00001_000_00000 PMOVEFD.L <ea>,TC
4640: {
4641: // たぶん
4642: // 無効→有効が (38, 40)
4643: // 有効→無効が (56, 58)
4644: // 無効→無効が (14, 16) ってことだと思うんだけど。
4645: CYCLE2(14, 16);
4646: uint32 ea = cea_copro(cpu);
4647: uint32 data = m68030_read_32(cpu, ea);
4648: if (cpu->SetTC(data) == false) {
4649: m68030_exception(cpu, M68K_EXCEP_MMU_CONFIG);
4650: break;
4651: }
4652: if ((RegIR2 & 0x0100) == 0)
4653: cpu->atc.flush();
4654: break;
4655: }
4656: case (0x4200 >> 8):
4657: // %010_00010_000_00000 PMOVE.L TC,<ea>
4658: {
4659: CYCLE2(4, 5);
4660: uint32 ea = cea_copro(cpu);
4661: m68030_write_32(cpu, ea, cpu->GetTC());
4662: break;
4663: }
4664: case (0x4800 >> 8):
4665: case (0x4900 >> 8):
4666: // %010_01000_000_00000 PMOVE.Q <ea>,SRP
4667: // %010_01001_000_00000 PMOVEFD.Q <ea>,SRP
4668: {
4669: // たぶん有効になる時が (12, 14)
4670: // それ以外が (28, 30) ってことかな。
4671: CYCLE2(28, 30);
4672: uint32 ea = cea_copro(cpu);
4673: uint32 h = m68030_read_32(cpu, ea);
4674: uint32 l = m68030_read_32(cpu, ea + 4);
4675: cpu->SetSRP(h, l);
4676: if ((RegIR2 & 0x0100) == 0)
4677: cpu->atc.flush();
4678: break;
4679: }
4680: case (0x4a00 >> 8):
4681: // %010_01010_000_00000 PMOVE.Q SRP,<ea>
4682: {
4683: CYCLE2(4, 5);
4684: uint32 ea = cea_copro(cpu);
4685: m68030_write_32(cpu, ea, cpu->GetSRPh());
4686: m68030_write_32(cpu, ea + 4, cpu->GetSRPl());
4687: break;
4688: }
4689: case (0x4c00 >> 8):
4690: case (0x4d00 >> 8):
4691: // %010_01100_000_00000 PMOVE.Q <ea>,CRP
4692: // %010_01101_000_00000 PMOVEFD.Q <ea>,CRP
4693: {
4694: // たぶん有効になる時が (12, 14)
4695: // それ以外が (28, 30) ってことかな。
4696: CYCLE2(28, 30);
4697: uint32 ea = cea_copro(cpu);
4698: uint32 h = m68030_read_32(cpu, ea);
4699: uint32 l = m68030_read_32(cpu, ea + 4);
4700: cpu->SetCRP(h, l);
4701: if ((RegIR2 & 0x0100) == 0)
4702: cpu->atc.flush();
4703: break;
4704: }
4705: case (0x4e00 >> 8):
4706: // %010_01110_000_00000 PMOVE.Q CRP,<ea>
4707: {
4708: CYCLE2(4, 5);
4709: uint32 ea = cea_copro(cpu);
4710: m68030_write_32(cpu, ea, cpu->GetCRPh());
4711: m68030_write_32(cpu, ea + 4, cpu->GetCRPl());
4712: break;
4713: }
4714: case (0x6000 >> 8):
4715: // %011_00000_000_00000 PMOVE.W <ea>,MMUSR
4716: {
4717: CYCLE(6);
4718: uint32 ea = cea_copro(cpu);
4719: uint16 data = m68030_read_16(cpu, ea);
4720: cpu->SetMMUSR(data);
4721: break;
4722: }
4723: case (0x6200 >> 8):
4724: // %011_00010_000_00000 PMOVE.W MMUSR,<ea>
4725: {
4726: CYCLE2(4, 5);
4727: uint32 ea = cea_copro(cpu);
4728: m68030_write_16(cpu, ea, cpu->GetMMUSR());
4729: break;
4730: }
4731: case (0x8000 >> 8):
4732: case (0x8400 >> 8):
4733: case (0x8800 >> 8):
4734: case (0x8c00 >> 8):
4735: case (0x9000 >> 8):
4736: case (0x9400 >> 8):
4737: case (0x9800 >> 8):
4738: case (0x9c00 >> 8):
4739: // %100_nnn00_000_00000 PTESTW SFC,<ea>,#<level>
4740: // %100_nnn00_000_00001 PTESTW DFC,<ea>,#<level>
4741: // %100_nnn00_000_01yyy PTESTW Dy,<ea>,#<level>
4742: // %100_nnn00_000_10nnn PTESTW #<imm>,<ea>,#<level>
4743: {
4744: mmu_op_ptest(cpu);
4745: break;
4746: }
4747: case (0x8100 >> 8):
4748: case (0x8500 >> 8):
4749: case (0x8900 >> 8):
4750: case (0x8d00 >> 8):
4751: case (0x9100 >> 8):
4752: case (0x9500 >> 8):
4753: case (0x9900 >> 8):
4754: case (0x9d00 >> 8):
4755: // %100_nnn01_nnn_00000 PTESTW SFC,<ea>,#<level>,An
4756: // %100_nnn01_nnn_00001 PTESTW DFC,<ea>,#<level>,An
4757: // %100_nnn01_nnn_01yyy PTESTW Dy,<ea>,#<level>,An
4758: // %100_nnn01_nnn_10nnn PTESTW #<imm>,<ea>,#<level>,An
4759: {
4760: mmu_op_ptest(cpu);
4761: break;
4762: }
4763: case (0x8200 >> 8):
4764: case (0x8600 >> 8):
4765: case (0x8a00 >> 8):
4766: case (0x8e00 >> 8):
4767: case (0x9200 >> 8):
4768: case (0x9600 >> 8):
4769: case (0x9a00 >> 8):
4770: case (0x9e00 >> 8):
4771: // %100_nnn10_000_00000 PTESTR SFC,<ea>,#<level>
4772: // %100_nnn10_000_00001 PTESTR DFC,<ea>,#<level>
4773: // %100_nnn10_000_01yyy PTESTR Dy,<ea>,#<level>
4774: // %100_nnn10_000_10nnn PTESTR #<imm>,<ea>,#<level>
4775: {
4776: mmu_op_ptest(cpu);
4777: break;
4778: }
4779: case (0x8300 >> 8):
4780: case (0x8700 >> 8):
4781: case (0x8b00 >> 8):
4782: case (0x8f00 >> 8):
4783: case (0x9300 >> 8):
4784: case (0x9700 >> 8):
4785: case (0x9b00 >> 8):
4786: case (0x9f00 >> 8):
4787: // %100_nnn11_nnn_00000 PTESTR SFC,<ea>,#<level>,An
4788: // %100_nnn11_nnn_00001 PTESTR DFC,<ea>,#<level>,An
4789: // %100_nnn11_nnn_01yyy PTESTR Dy,<ea>,#<level>,An
4790: // %100_nnn11_nnn_10nnn PTESTR #<imm>,<ea>,#<level>,An
4791: {
4792: mmu_op_ptest(cpu);
4793: break;
4794: }
4795: default:
4796: OP_FUNC(illegal);
4797: break;
4798: }
4799: }
4800:
4801: // %1111_001000_nnnnnn FPGEN
4802: OP_DEF(fpgen)
4803: {
4804: if (cpu->has_fpu == 0) {
4805: op_fline(cpu);
4806: return;
4807: }
4808:
4809: fpu_op_start(cpu);
4810:
4811: RegIR2 = m68030_fetch_16(cpu);
4812: switch (RegIR2 >> 13) {
4813: case 0:
4814: fpu_op_fgen_reg(cpu);
4815: break;
4816: case 1:
4817: fpu_op_illg(cpu);
4818: break;
4819: case 2:
4820: fpu_op_fgen_mem(cpu);
4821: break;
4822: case 3:
4823: {
4824: // FMOVE reg,<ea> はサイズごとに分岐
4825: int size = (RegIR2 >> 10) & 7;
4826: switch (size) {
4827: case SIZE_B:
4828: fpu_op_fmove_b_mem(cpu);
4829: break;
4830: case SIZE_W:
4831: fpu_op_fmove_w_mem(cpu);
4832: break;
4833: case SIZE_L:
4834: fpu_op_fmove_l_mem(cpu);
4835: break;
4836: case SIZE_S:
4837: fpu_op_fmove_s_mem(cpu);
4838: break;
4839: case SIZE_D:
4840: fpu_op_fmove_d_mem(cpu);
4841: break;
4842: case SIZE_X:
4843: fpu_op_fmove_x_mem(cpu);
4844: break;
4845: case SIZE_P:
4846: case 7:
4847: fpu_op_fmove_p_mem(cpu);
4848: break;
4849: }
4850: break;
4851: }
4852: case 4:
4853: fpu_op_fmovem_ea2ctl(cpu);
4854: break;
4855: case 5:
4856: fpu_op_fmovem_ctl2ea(cpu);
4857: break;
4858: case 6:
4859: fpu_op_fmovem_ea2reg(cpu);
4860: break;
4861: case 7:
4862: fpu_op_fmovem_reg2ea(cpu);
4863: break;
4864: }
4865: }
4866:
4867: // %1111_001001_nnnnnn FScc.B <ea>
4868: // %1111_001001_001yyy FDBcc Dy,<label>
4869: // %1111_001001_111010 FTRAPcc.W #<imm>
4870: // %1111_001001_111011 FTRAPcc.L #<imm>
4871: // %1111_001001_111100 FTRAPcc
4872: OP_DEF(fxcc)
4873: {
4874: if (cpu->has_fpu == 0) {
4875: op_fline(cpu);
4876: return;
4877: }
4878:
4879: fpu_op_start(cpu);
4880:
4881: RegIR2 = m68030_fetch_16(cpu);
4882: switch (eamode(RegIR)) {
4883: case 1:
4884: fpu_op_fdbcc(cpu);
4885: return;
4886: case 7:
4887: switch (RegIR & 7) {
4888: case 0:
4889: case 1:
4890: fpu_op_fscc(cpu);
4891: return;
4892: case 2:
4893: fpu_op_ftrapcc_w(cpu);
4894: return;
4895: case 3:
4896: fpu_op_ftrapcc_l(cpu);
4897: return;
4898: case 4:
4899: fpu_op_ftrapcc(cpu);
4900: return;
4901: default:
4902: break;
4903: }
4904: break;
4905: default:
4906: fpu_op_fscc(cpu);
4907: return;
4908: }
4909: }
4910:
4911: // %1111_001010_nnnnnn FBcc.W <label>
4912: OP_DEF(fbcc_w)
4913: {
4914: if (cpu->has_fpu == 0) {
4915: op_fline(cpu);
4916: return;
4917: }
4918:
4919: fpu_op_start(cpu);
4920:
4921: fpu_op_fbcc_w(cpu);
4922: }
4923:
4924: // %1111_001011_nnnnnn FBcc.L <label>
4925: OP_DEF(fbcc_l)
4926: {
4927: if (cpu->has_fpu == 0) {
4928: op_fline(cpu);
4929: return;
4930: }
4931:
4932: fpu_op_start(cpu);
4933:
4934: fpu_op_fbcc_l(cpu);
4935: }
4936:
4937: // %1111_001100_nnnnnn FSAVE <ea>
4938: OP_DEF(fsave)
4939: {
4940: if (cpu->has_fpu == 0) {
4941: op_fline(cpu);
4942: return;
4943: }
4944:
4945: SUPERVISOR_OP;
4946:
4947: fpu_op_fsave(cpu);
4948: }
4949:
4950: // %1111_001101_nnnnnn FRESTORE <ea>
4951: OP_DEF(frestore)
4952: {
4953: if (cpu->has_fpu == 0) {
4954: op_fline(cpu);
4955: return;
4956: }
4957:
4958: SUPERVISOR_OP;
4959:
4960: fpu_op_frestore(cpu);
4961: }
4962:
4963: // %1111_nnnnnn_nnnnnn F-Line
4964: OP_DEF(fline)
4965: {
4966: CYCLE2(18, 20);
4967:
4968: if (cpu->fline_callback) {
4969: if (cpu->fline_callback(cpu, cpu->fline_arg)) {
4970: return;
4971: }
4972: }
4973: // F系列命令例外
4974: m68030_exception(cpu, M68K_EXCEP_FLINE);
4975: }
4976:
4977: // illegal instructions
4978: OP_DEF(illegal)
4979: {
4980: CYCLE2(18, 20);
4981: // 不当命令例外
4982: m68030_exception(cpu, M68K_EXCEP_ILLEGAL);
4983: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.