![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68030acc.h 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 m68030acc.h CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0 |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2017 [email protected]
4: //
5:
6: #pragma once
7:
8: extern void acc_chk2cmp2_32(m68kcpu *cpu, uint32, uint32, uint32);
9: extern bool acc_divu_32_16(m68kcpu *cpu, uint32, uint32, uint32 *, uint32 *);
10: extern bool acc_divu_32_32(m68kcpu *cpu, uint32, uint32, uint32 *, uint32 *);
11: extern bool acc_divu_64_32(m68kcpu *cpu, uint32, uint64, uint32 *, uint32 *);
12: extern bool acc_divs_32_16(m68kcpu *cpu, uint32, uint32, uint32 *, uint32 *);
13: extern bool acc_divs_32_32(m68kcpu *cpu, uint32, uint32, uint32 *, uint32 *);
14: extern bool acc_divs_64_32(m68kcpu *cpu, uint32, uint64, uint32 *, uint32 *);
15: extern uint32 acc_abcd_8(m68kcpu *cpu, uint32 src ,uint32 dst);
16: extern uint32 acc_sbcd_8(m68kcpu *cpu, uint32 src, uint32 dst);
17:
18: // ビットフィールド命令
19: class acc_bf
20: {
21: public:
22: acc_bf(m68kcpu *);
23: // デストラクタは無し。
24:
25: void LoadReg(uint n); // Dn から値を読み込む
26: void LoadMem(uint32 addr); // メモリから値を読み込む
27:
28: // レジスタまたはメモリにストアする
29: void Store(uint n) {
30: if (n < 8) {
31: StoreReg(n);
32: } else {
33: StoreMem();
34: }
35: };
36:
37: uint32 data = 0; // 32bit 左詰めデータ
38: int32 offset = 0; // (第2ワードで指定された) オフセット
39: uint32 width = 0; // 幅
40:
41: private:
42: void StoreReg(uint n); // 値を Dn に書き出す
43: void StoreMem(); // 値をメモリに書き出す
44:
45: // 32ビットの val を count ビット左ローテートした値を返す。
46: // count は 0..31。
47: // 実際には count==0 の時 (val>>32) となりこれは未定義動作なのだが
48: // ぶっちゃけこの形式はローテート命令一発に変換されると知っているので
49: // とりあえず放置しておく。C++20 になったら std::rotl() を検討。
50: NO_SANITIZE("undefined")
51: uint32 ROL32(uint32 val, uint count) {
52: return (val << count) | (val >> (32 - count));
53: }
54:
55: // 32ビットの val を count ビット右ローテートした値を返す。
56: // count は 0..31。
57: // 実際には count==0 の時 (val>>32) となりこれは未定義動作なのだが
58: // ぶっちゃけこの形式はローテート命令一発に変換されると知っているので
59: // とりあえず放置しておく。C++20 になったら std::rotr() を検討。
60: NO_SANITIZE("undefined")
61: uint32 ROR32(uint32 val, uint count) {
62: return (val >> count) | (val << (32 - count));
63: }
64:
65: m68kcpu *cpu = NULL;
66:
67: uint32 mask = 0; // 32ビット左詰めマスク
68: uint32 ea = 0; // オフセット計算後の EA
69: int32 local_offset = 0; // 内部(32bit or 8bit 内)オフセット
70: int bytes = 0; // アクセスバイト数
71: uint64 buf = 0; // 40ビットのメモリバッファ
72: };
73:
74: // res を元に NZVC フラグをセットする。
75: // res の上位ビットは無視される。
76: static inline void
77: acc_move_8(m68kcpu *cpu, uint32 res)
78: {
79: CCR.z = res << 24;
80: CCR.n = CCR.z;
81: CCR.c = 0;
82: CCR.v = 0;
83: }
84:
85: // res を元に NZVC フラグをセットする。
86: // res の上位ビットは無視される。
87: static inline void
88: acc_move_16(m68kcpu *cpu, uint32 res)
89: {
90: CCR.z = res << 16;
91: CCR.n = CCR.z;
92: CCR.c = 0;
93: CCR.v = 0;
94: }
95:
96: // res を元に NZVC フラグをセットする。
97: static inline void
98: acc_move_32(m68kcpu *cpu, uint32 res)
99: {
100: CCR.z = res;
101: CCR.n = res;
102: CCR.c = 0;
103: CCR.v = 0;
104: }
105:
106:
107: #define vflag_add_8(src, dst, res) (vflag_add_32(src, dst, res) << 24)
108: #define vflag_add_16(src, dst, res) (vflag_add_32(src, dst, res) << 16)
109: #define vflag_add_32(src, dst, res) (((src) ^ (res)) & ((dst) ^ (res)))
110:
111: // src + dst を計算し、XNZVC フラグをセットして結果を返す。
112: // src, dst の上位ビットはクリアしておくこと。
113: // 戻り値の上位ビットはクリアされている。
114: static inline uint32
115: acc_add_8(m68kcpu *cpu, uint32 src, uint32 dst)
116: {
117: CCR.z = dst + src;
118: CCR.c = CCR.z >> 8;
119: CCR.x = CCR.c;
120: CCR.n = CCR.z << 24;
121: CCR.z &= 0xff;
122: CCR.v = vflag_add_8(src, dst, CCR.z);
123: return CCR.z;
124: }
125:
126: // src + dst を計算し、XNZVC フラグをセットして結果を返す。
127: // src, dst の上位ビットはクリアしておくこと。
128: // 戻り値の上位ビットはクリアされている。
129: static inline uint32
130: acc_add_16(m68kcpu *cpu, uint32 src, uint32 dst)
131: {
132: CCR.z = dst + src;
133: CCR.c = CCR.z >> 16;
134: CCR.x = CCR.c;
135: CCR.n = CCR.z << 16;
136: CCR.z &= 0xffff;
137: CCR.v = vflag_add_16(src, dst, CCR.z);
138: return CCR.z;
139: }
140:
141: // src + dst を計算し、XNZVC フラグをセットして結果を返す。
142: static inline uint32
143: acc_add_32(m68kcpu *cpu, uint32 src, uint32 dst)
144: {
145: CCR.cz = (uint64)dst + (uint64)src;
146: CCR.x = CCR.c;
147: CCR.v = vflag_add_32(src, dst, CCR.z);
148: CCR.n = CCR.z;
149: return CCR.z;
150: }
151:
152: // src + dst + X を計算し、XNZVC フラグをセットして結果を返す。
153: // src, dst の上位ビットはクリアしておくこと。
154: // 戻り値の上位ビットはクリアされている。
155: static inline uint32
156: acc_addx_8(m68kcpu *cpu, uint32 src, uint32 dst)
157: {
158: uint32 res = dst + src + (CCR.IsX() ? 1 : 0);
159: CCR.c = res >> 8;
160: CCR.x = CCR.c;
161: CCR.n = res << 24;
162: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
163: if (CCR.n != 0) {
164: CCR.z = CCR.n;
165: }
166: CCR.v = vflag_add_8(src, dst, res);
167: return res & 0xff;
168: }
169:
170: // src + dst + X を計算し、XNZVC フラグをセットして結果を返す。
171: // src, dst の上位ビットはクリアしておくこと。
172: // 戻り値の上位ビットはクリアされている。
173: static inline uint32
174: acc_addx_16(m68kcpu *cpu, uint32 src, uint32 dst)
175: {
176: uint32 res = dst + src + (CCR.IsX() ? 1 : 0);
177: CCR.c = res >> 16;
178: CCR.x = CCR.c;
179: CCR.n = res << 16;
180: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
181: if (CCR.n != 0) {
182: CCR.z = CCR.n;
183: }
184: CCR.v = vflag_add_16(src, dst, res);
185: return res & 0xffff;
186: }
187:
188: // src + dst + X を計算し、XNZVC フラグをセットして結果を返す。
189: static inline uint32
190: acc_addx_32(m68kcpu *cpu, uint32 src, uint32 dst)
191: {
192: uint64 res = (uint64)dst + (uint64)src + (CCR.IsX() ? 1 : 0);
193: CCR.c = res >> 32;
194: CCR.x = CCR.c;
195: CCR.n = res;
196: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
197: if (CCR.n != 0) {
198: CCR.z = CCR.n;
199: }
200: CCR.v = vflag_add_32(src, dst, res);
201: return res;
202: }
203:
204:
205: #define vflag_sub_8(src, dst, res) (vflag_sub_32(src, dst, res) << 24)
206: #define vflag_sub_16(src, dst, res) (vflag_sub_32(src, dst, res) << 16)
207: #define vflag_sub_32(src, dst, res) (((src) ^ (dst)) & ((dst) ^ (res)))
208:
209: // dst - src を計算し、NZVC フラグをセットして結果を返す。
210: // src, dst の上位ビットはクリアしておくこと。
211: // 戻り値の上位ビットはクリアされている。
212: static inline uint32
213: acc_cmp_8(m68kcpu *cpu, uint32 src, uint32 dst)
214: {
215: CCR.z = dst - src;
216: CCR.c = CCR.z >> 8;
217: CCR.n = CCR.z << 24;
218: CCR.z &= 0xff;
219: CCR.v = vflag_sub_8(src, dst, CCR.z);
220: return CCR.z;
221: }
222:
223: // dst - src を計算し、NZVC フラグをセットして結果を返す。
224: // src, dst の上位ビットはクリアしておくこと。
225: // 戻り値の上位ビットはクリアされている。
226: static inline uint32
227: acc_cmp_16(m68kcpu *cpu, uint32 src, uint32 dst)
228: {
229: CCR.z = dst - src;
230: CCR.c = CCR.z >> 16;
231: CCR.n = CCR.z << 16;
232: CCR.z &= 0xffff;
233: CCR.v = vflag_sub_16(src, dst, CCR.z);
234: return CCR.z;
235: }
236:
237: // dst - src を計算し、NZVC フラグをセットして結果を返す。
238: static inline uint32
239: acc_cmp_32(m68kcpu *cpu, uint32 src, uint32 dst)
240: {
241: CCR.cz = (uint64)dst - (uint64)src;
242: CCR.n = CCR.z;
243: CCR.v = vflag_sub_32(src, dst, CCR.z);
244: return CCR.z;
245: }
246:
247: // dst - src を計算し、XNZVC フラグをセットして結果を返す。
248: // src, dst の上位ビットはクリアしておくこと。
249: // 戻り値の上位ビットはクリアされている。
250: static inline uint32
251: acc_sub_8(m68kcpu *cpu, uint32 src, uint32 dst)
252: {
253: uint32 res = acc_cmp_8(cpu, src, dst);
254: CCR.x = CCR.c;
255: return res;
256: }
257:
258: // dst - src を計算し、XNZVC フラグをセットして結果を返す。
259: // src, dst の上位ビットはクリアしておくこと。
260: // 戻り値の上位ビットはクリアされている。
261: static inline uint32
262: acc_sub_16(m68kcpu *cpu, uint32 src, uint32 dst)
263: {
264: uint32 res = acc_cmp_16(cpu, src, dst);
265: CCR.x = CCR.c;
266: return res;
267: }
268:
269: // dst - src を計算し、XNZVC フラグをセットして結果を返す。
270: static inline uint32
271: acc_sub_32(m68kcpu *cpu, uint32 src, uint32 dst)
272: {
273: uint32 res = acc_cmp_32(cpu, src, dst);
274: CCR.x = CCR.c;
275: return res;
276: }
277:
278: // src - dst - X を計算し、XNZVC フラグをセットして結果を返す。
279: // src, dst の上位ビットはクリアしておくこと。
280: // 戻り値 res の上位ビットはクリアされている。
281: static inline uint32
282: acc_subx_8(m68kcpu *cpu, uint32 src, uint32 dst)
283: {
284: uint32 res = dst - src - (CCR.IsX() ? 1 : 0);
285: CCR.c = res >> 8;
286: CCR.x = CCR.c;
287: CCR.n = res << 24;
288: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
289: if (CCR.n != 0) {
290: CCR.z = CCR.n;
291: }
292: CCR.v = vflag_sub_8(src, dst, res);
293: return res & 0xff;
294: }
295:
296: // src - dst - X を計算し、XNZVC フラグをセットして結果を返す。
297: // src, dst の上位ビットはクリアしておくこと。
298: // 戻り値 res の上位ビットはクリアされている。
299: static inline uint32
300: acc_subx_16(m68kcpu *cpu, uint32 src, uint32 dst)
301: {
302: uint32 res = dst - src - (CCR.IsX() ? 1 : 0);
303: CCR.c = res >> 16;
304: CCR.x = CCR.c;
305: CCR.n = res << 16;
306: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
307: if (CCR.n != 0) {
308: CCR.z = CCR.n;
309: }
310: CCR.v = vflag_sub_16(src, dst, res);
311: return res & 0xffff;
312: }
313:
314: // src - dst - X を計算し、XNZVC フラグをセットして結果を返す。
315: static inline uint32
316: acc_subx_32(m68kcpu *cpu, uint32 src, uint32 dst)
317: {
318: uint64 res = (uint64)dst - (uint64)src - (CCR.IsX() ? 1 : 0);
319: CCR.c = res >> 32;
320: CCR.x = CCR.c;
321: CCR.n = res;
322: // 結果がゼロでなければ Z をクリア、結果がゼロなら Z は何もしない
323: if (CCR.n != 0) {
324: CCR.z = CCR.n;
325: }
326: CCR.v = vflag_sub_32(src, dst, res);
327: return res;
328: }
329:
330: // src(u16) * dst(u16) を計算し、NZVC フラグをセットして結果(u32)を返す。
331: // src, dst の上位ビットはクリアしておくこと。
332: static inline uint32
333: acc_mulu_16(m68kcpu *cpu, uint32 src, uint32 dst)
334: {
335: uint32 res = src * dst;
336: // 16x16->32 ではオーバーフローは起きないので acc_move でよい
337: acc_move_32(cpu, res);
338: return res;
339: }
340:
341: // src(s16) * dst(s16) を計算し、NZVC フラグをセットして結果(u32)を返す。
342: // src, dst の上位ビットはクリアしておくこと。
343: static inline uint32
344: acc_muls_16(m68kcpu *cpu, uint32 src, uint32 dst)
345: {
346: int32 res = (int32)(int16)src * (int32)(int16)dst;
347: // 16x16->32 ではオーバーフローは起きないので acc_move でよい
348: acc_move_32(cpu, res);
349: return res;
350: }
351:
352: // src(u32) * dst(u32) を計算し、NZVC フラグをセットして結果(32bit)を返す。
353: static inline uint32
354: acc_mulu_32(m68kcpu *cpu, uint32 src, uint32 dst)
355: {
356: uint64 res = (uint64)src * (uint64)dst;
357: CCR.z = res;
358: CCR.n = res;
359: CCR.c = 0;
360: if (res > 0xffffffffUL) {
361: CCR.v = m68030ccr::V_BIT;
362: } else {
363: CCR.v = 0;
364: }
365: return (uint32)res;
366: }
367:
368: // src(s32) * dst(s32) を計算し、NZVC フラグをセットして結果(32bit)を返す。
369: static inline uint32
370: acc_muls_32(m68kcpu *cpu, uint32 src, uint32 dst)
371: {
372: int64 res = (int64)(int32)src * (int64)(int32)dst;
373: CCR.z = res;
374: CCR.n = res;
375: CCR.c = 0;
376: // V フラグは64ビット演算結果の上位32ビットが
377: // 下位32ビットの符号拡張になっていなかった場合に立つ。
378: // つまり符号付き整数で 32bit 表現と 64bit 表現が一致していなければ立つ。
379: int32 tmp = res;
380: if (res != tmp) {
381: CCR.v = m68030ccr::V_BIT;
382: } else {
383: CCR.v = 0;
384: }
385: return (uint32)res;
386: }
387:
388: // src(u32) * dst(u32) を計算し、NZVC フラグをセットして結果(64bit)を返す。
389: static inline uint64
390: acc_mulu_64(m68kcpu *cpu, uint32 src, uint32 dst)
391: {
392: uint64 res = (uint64)src * (uint64)dst;
393: CCR.n = res >> 32;
394: CCR.z = CCR.n | res;
395: CCR.v = 0;
396: CCR.c = 0;
397: return res;
398: }
399:
400: // src(s32) * dst(s32) を計算し、NZVC フラグをセットして結果(64bit)を返す。
401: static inline uint64
402: acc_muls_64(m68kcpu *cpu, uint32 src, uint32 dst)
403: {
404: int64 res = (int64)(int32)src * (int64)(int32)dst;
405: CCR.n = res >> 32;
406: CCR.z = CCR.n | res;
407: CCR.v = 0;
408: CCR.c = 0;
409: return res;
410: }
411:
412: static inline void
413: acc_btst(m68kcpu *cpu, uint32 data, int n)
414: {
415: CCR.z = data & (1 << n);
416: }
417:
418: static inline uint32
419: acc_bchg(m68kcpu *cpu, uint32 data, int n)
420: {
421: CCR.z = data & (1 << n);
422: data ^= (1 << n);
423: return data;
424: }
425:
426: static inline uint32
427: acc_bclr(m68kcpu *cpu, uint32 data, int n)
428: {
429: CCR.z = data & (1 << n);
430: data &= ~(1 << n);
431: return data;
432: }
433:
434: static inline uint32
435: acc_bset(m68kcpu *cpu, uint32 data, int n)
436: {
437: CCR.z = data & (1 << n);
438: data |= (1 << n);
439: return data;
440: }
441:
442:
443: // data を count ビット算術左シフトし、XNZVC フラグを反映して結果を返す。
444: // count は 0..63。data の上位はクリアしておくこと。
445: static inline uint32
446: acc_asl_8(m68kcpu *cpu, uint32 data, int count)
447: {
448: if (count == 0) {
449: acc_move_8(cpu, data);
450: return data;
451: }
452: int64 tmps = (int64)(int8)data;
453: if (count > 8) count = 9;
454: uint64 tmp = (uint64)tmps << count;
455: CCR.x = CCR.c = tmp >> 8;
456: CCR.n = tmp << 24;
457: CCR.z = CCR.n;
458: // 送り出された全てのビットが元の MSB と一致すれば V=0
459: CCR.PutV(((int64)tmp >> 7) != (tmps >> 8));
460: return tmp & 0xff;
461: }
462:
463: // data を count ビット算術左シフトし、XNZVC フラグを反映して結果を返す。
464: // count は 0..63。data の上位はクリアしておくこと。
465: static inline uint32
466: acc_asl_16(m68kcpu *cpu, uint32 data, int count)
467: {
468: if (count == 0) {
469: acc_move_16(cpu, data);
470: return data;
471: }
472: int64 tmps = (int64)(int16)data;
473: if (count > 16) count = 17;
474: uint64 tmp = (uint64)tmps << count;
475: CCR.x = CCR.c = tmp >> 16;
476: CCR.n = tmp << 16;
477: CCR.z = CCR.n;
478: // 送り出された全てのビットが元の MSB と一致すれば V=0
479: CCR.PutV(((int64)tmp >> 15) != (tmps >> 16));
480: return tmp & 0xffff;
481: }
482:
483: // data を count ビット算術左シフトし、XNZVC フラグを反映して結果を返す。
484: // count は 0..63
485: static inline uint32
486: acc_asl_32(m68kcpu *cpu, uint32 data, int count)
487: {
488: if (count == 0) {
489: acc_move_32(cpu, data);
490: return data;
491: }
492: int64 tmps = (int64)(int32)data;
493: if (count > 32) count = 33;
494: uint64 tmp = (uint64)tmps << count;
495: CCR.x = CCR.c = tmp >> 32;
496: CCR.n = CCR.z = tmp;
497: // 送り出された全てのビットが元の MSB と一致すれば V=0
498: CCR.PutV(((int64)tmp >> 31) != (tmps >> 32));
499: return tmp;
500: }
501:
502: // data を count ビット左シフトし、NZVC フラグを反映して結果を返す。
503: // count は 0..63。data の上位はクリアしておくこと。
504: static inline uint32
505: acc_lsl_8(m68kcpu *cpu, uint32 data, int count)
506: {
507: if (count == 0) {
508: acc_move_8(cpu, data);
509: return data;
510: }
511: uint64 tmp = (uint64)data << count;
512: CCR.x = CCR.c = tmp >> 8;
513: CCR.n = tmp << 24;
514: CCR.z = tmp & 0xff;
515: CCR.v = 0;
516: return CCR.z;
517: }
518:
519: // data を count ビット左シフトし、NZVC フラグを反映して結果を返す。
520: // count は 0..63。data の上位はクリアしておくこと。
521: static inline uint32
522: acc_lsl_16(m68kcpu *cpu, uint32 data, int count)
523: {
524: if (count == 0) {
525: acc_move_16(cpu, data);
526: return data;
527: }
528: uint64 tmp = (uint64)data << count;
529: CCR.x = CCR.c = tmp >> 16;
530: CCR.n = tmp << 16;
531: CCR.z = tmp & 0xffff;
532: CCR.v = 0;
533: return CCR.z;
534: }
535:
536: // data を count ビット左シフトし、NZVC フラグを反映して結果を返す。
537: // count は 0..63
538: static inline uint32
539: acc_lsl_32(m68kcpu *cpu, uint32 data, int count)
540: {
541: if (count == 0) {
542: acc_move_32(cpu, data);
543: return data;
544: }
545: uint64 tmp = (uint64)data << count;
546: CCR.x = CCR.c = tmp >> 32;
547: CCR.n = tmp;
548: CCR.z = tmp;
549: CCR.v = 0;
550: return CCR.z;
551: }
552:
553: // data:X を count ビット左ローテートし、XNZVC フラグを反映して結果を返す。
554: // count は 0..63
555: static inline uint32
556: acc_roxl_8(m68kcpu *cpu, uint32 data, int count)
557: {
558: count %= 9;
559: if (count == 0) {
560: CCR.z = data;
561: CCR.n = data << 24;
562: CCR.v = 0;
563: CCR.c = CCR.x;
564: return CCR.z;
565: }
566: uint32 x = CCR.x & 1;
567: CCR.z = (data << count) | (data >> (9 - count)) | (x << (count - 1));
568: CCR.c = CCR.x = CCR.z >> 8;
569: CCR.z &= 0xff;
570: CCR.n = CCR.z << 24;
571: CCR.v = 0;
572: return CCR.z;
573: }
574:
575: // data:X を count ビット左ローテートし、XNZVC フラグを反映して結果を返す。
576: // count は 0..63
577: static inline uint32
578: acc_roxl_16(m68kcpu *cpu, uint32 data, int count)
579: {
580: count %= 17;
581: if (count == 0) {
582: CCR.z = data;
583: CCR.n = data << 16;
584: CCR.v = 0;
585: CCR.c = CCR.x;
586: return CCR.z;
587: }
588: uint32 x = CCR.x & 1;
589: CCR.z = (data << count) | (data >> (17 - count)) | (x << (count - 1));
590: CCR.c = CCR.x = CCR.z >> 16;
591: CCR.z &= 0xffff;
592: CCR.n = CCR.z << 16;
593: CCR.v = 0;
594: return CCR.z;
595: }
596:
597: // data:X を count ビット左ローテートし、XNZVC フラグを反映して結果を返す。
598: // count は 0..63
599: static inline uint32
600: acc_roxl_32(m68kcpu *cpu, uint32 data, int count)
601: {
602: count %= 33;
603: if (count == 0) {
604: CCR.z = data;
605: CCR.n = data;
606: CCR.v = 0;
607: CCR.c = CCR.x;
608: return CCR.z;
609: }
610: // 32bit値の 32ビットシフトは未定義動作なので 64bit値を使用
611: uint64 data64 = data;
612: uint32 x = CCR.x & 1;
613: CCR.z = (data64 << count) | (data64 >> (33 - count)) | (x << (count - 1));
614: CCR.c = CCR.x = data64 >> (32 - count);
615: CCR.n = CCR.z;
616: CCR.v = 0;
617: return CCR.z;
618: }
619:
620: // data を count ビット左ローテートし、NZVC フラグを反映して結果を返す。
621: // count は 0..63。data の上位はクリアしておくこと
622: static inline uint32
623: acc_rol_8(m68kcpu *cpu, uint32 data, int count)
624: {
625: if (count == 0) {
626: acc_move_8(cpu, data);
627: return data;
628: }
629:
630: count %= 8;
631: int count2 = (8 - count) % 8;
632: uint8 tmp = (data << count) | (data >> count2);
633: CCR.z = tmp;
634: CCR.n = (uint32)tmp << 24;
635: CCR.c = data >> count2;
636: CCR.v = 0;
637: return CCR.z;
638: }
639:
640: // data を count ビット左ローテートし、NZVC フラグを反映して結果を返す。
641: // count は 0..63。data の上位はクリアしておくこと
642: static inline uint32
643: acc_rol_16(m68kcpu *cpu, uint32 data, int count)
644: {
645: if (count == 0) {
646: acc_move_16(cpu, data);
647: return data;
648: }
649:
650: count %= 16;
651: int count2 = (16 - count) % 16;
652: uint16 tmp = (data << count) | (data >> count2);
653: CCR.z = tmp;
654: CCR.n = (uint32)tmp << 16;
655: CCR.c = data >> count2;
656: CCR.v = 0;
657: return CCR.z;
658: }
659:
660: // data を count ビット左ローテートし、NZVC フラグを反映して結果を返す。
661: // count は 0..63
662: static inline uint32
663: acc_rol_32(m68kcpu *cpu, uint32 data, int count)
664: {
665: if (count == 0) {
666: acc_move_32(cpu, data);
667: return data;
668: }
669:
670: count %= 32;
671: int count2 = (32 - count) % 32;
672: uint64 data64 = (uint64)data;
673: uint64 tmp = (data << count) | (data >> count2);
674: CCR.z = tmp;
675: CCR.n = CCR.z;
676: CCR.c = data64 >> count2;
677: CCR.v = 0;
678: return CCR.z;
679: }
680:
681: // data を count ビット算術右シフトし、XNZVC フラグを反映して結果を返す。
682: // count は 0..64。data の上位はクリアしておくこと。
683: static inline uint32
684: acc_asr_8(m68kcpu *cpu, uint32 data, int count)
685: {
686: if (count == 0) {
687: acc_move_8(cpu, data);
688: return data;
689: }
690: if (count > 8) {
691: if ((int8)data < 0) {
692: data = 0xff;
693: } else {
694: data = 0;
695: }
696: CCR.x = CCR.c = CCR.z = data;
697: CCR.n = data << 24;
698: CCR.v = 0;
699: return data;
700: }
701: // data >>> count の結果が tmp の上位32ビット中の下位8ビットに入る
702: uint64 tmp = (uint64)(int64)(int8)data << (32 - count);
703: CCR.x = CCR.c = tmp >> 31;
704: CCR.n = tmp >> 8;
705: CCR.z = (tmp >> 32) & 0xff;
706: CCR.v = 0;
707: return CCR.z;
708: }
709:
710: // data を count ビット算術右シフトし、XNZVC フラグを反映して結果を返す。
711: // count は 0..64。data の上位はクリアしておくこと。
712: static inline uint32
713: acc_asr_16(m68kcpu *cpu, uint32 data, int count)
714: {
715: if (count == 0) {
716: acc_move_16(cpu, data);
717: return data;
718: }
719: if (count > 16) {
720: if ((int16)data < 0) {
721: data = 0xffff;
722: } else {
723: data = 0;
724: }
725: CCR.x = CCR.c = CCR.z = data;
726: CCR.n = data << 16;
727: CCR.v = 0;
728: return data;
729: }
730: // data >>> count の結果が tmp の上位32ビット中の下位16ビットに入る
731: uint64 tmp = (uint64)(int64)(int16)data << (32 - count);
732: CCR.x = CCR.c = tmp >> 31;
733: CCR.n = tmp >> 16;
734: CCR.z = (tmp >> 32) & 0xffff;
735: CCR.v = 0;
736: return CCR.z;
737: }
738:
739: // data を count ビット算術右シフトし、XNZVC フラグを反映して結果を返す。
740: // count は 0..64
741: static inline uint32
742: acc_asr_32(m68kcpu *cpu, uint32 data, int count)
743: {
744: if (count == 0) {
745: acc_move_32(cpu, data);
746: return data;
747: }
748: if (count > 32) {
749: if ((int32)data < 0) {
750: data = 0xffffffff;
751: } else {
752: data = 0;
753: }
754: CCR.x = CCR.c = CCR.z = data;
755: CCR.n = data;
756: CCR.v = 0;
757: return data;
758: }
759: // data >>> count の結果が tmp の上位32ビットに入る
760: uint64 tmp = (uint64)(int64)(int32)data << (32 - count);
761: CCR.x = CCR.c = tmp >> 31;
762: CCR.z = CCR.n = tmp >> 32;
763: CCR.v = 0;
764: return CCR.z;
765: }
766:
767: // data を count ビット論理右シフトし、XNZVC フラグを反映して結果を返す。
768: // count は 0..63
769: static inline uint32
770: acc_lsr_8(m68kcpu *cpu, uint32 data, int count)
771: {
772: if (count == 0) {
773: acc_move_8(cpu, data);
774: return data;
775: }
776: if (count > 8) {
777: CCR.x = CCR.c = 0;
778: acc_move_8(cpu, 0);
779: return 0;
780: }
781: // data >> count の結果が tmp の上位32ビットに入る
782: uint64 tmp = (uint64)data << (32 - count);
783: CCR.x = CCR.c = tmp >> 31;
784: CCR.n = tmp >> 8;
785: CCR.z = (tmp >> 32) & 0xff;
786: CCR.v = 0;
787: return CCR.z;
788: }
789:
790: // data を count ビット論理右シフトし、XNZVC フラグを反映して結果を返す。
791: // count は 0..63
792: static inline uint32
793: acc_lsr_16(m68kcpu *cpu, uint32 data, int count)
794: {
795: if (count == 0) {
796: acc_move_16(cpu, data);
797: return data;
798: }
799: if (count > 16) {
800: CCR.x = CCR.c = 0;
801: acc_move_16(cpu, 0);
802: return 0;
803: }
804: // data >> count の結果が tmp の上位32ビットに入る
805: uint64 tmp = (uint64)data << (32 - count);
806: CCR.x = CCR.c = tmp >> 31;
807: CCR.n = tmp >> 16;
808: CCR.z = (tmp >> 32) & 0xffff;
809: CCR.v = 0;
810: return CCR.z;
811: }
812:
813: // data を count ビット論理右シフトし、XNZVC フラグを反映して結果を返す。
814: // count は 0..63
815: static inline uint32
816: acc_lsr_32(m68kcpu *cpu, uint32 data, int count)
817: {
818: if (count == 0) {
819: acc_move_32(cpu, data);
820: return data;
821: }
822: if (count > 32) {
823: CCR.x = CCR.c = 0;
824: acc_move_32(cpu, 0);
825: return 0;
826: }
827: // data >> count の結果が tmp の上位32ビットに入る
828: uint64 tmp = (uint64)data << (32 - count);
829: CCR.x = CCR.c = tmp >> 31;
830: CCR.z = CCR.n = tmp >> 32;
831: CCR.v = 0;
832: return CCR.z;
833: }
834:
835: // data:C を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
836: // count は 0..63
837: static inline uint32
838: acc_roxr_8(m68kcpu *cpu, uint32 data, int count)
839: {
840: count %= 9;
841: if (count == 0) {
842: CCR.z = data;
843: CCR.n = data << 24;
844: CCR.v = 0;
845: CCR.c = CCR.x;
846: return CCR.z;
847: }
848: uint32 rot = data & ((1 << (count - 1)) - 1);
849: uint32 x = CCR.x & 1;
850: CCR.z = (data >> count) | (rot << (9 - count)) | (x << (8 - count));
851: CCR.c = CCR.x = data >> (count - 1);
852: CCR.n = CCR.z << 24;
853: CCR.v = 0;
854: return CCR.z;
855: }
856:
857: // data:C を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
858: // count は 0..63
859: static inline uint32
860: acc_roxr_16(m68kcpu *cpu, uint32 data, int count)
861: {
862: count %= 17;
863: if (count == 0) {
864: CCR.z = data;
865: CCR.n = data << 16;
866: CCR.v = 0;
867: CCR.c = CCR.x;
868: return CCR.z;
869: }
870: uint32 rot = data & ((1 << (count - 1)) - 1);
871: uint32 x = CCR.x & 1;
872: CCR.z = (data >> count) | (rot << (17 - count)) | (x << (16 - count));
873: CCR.c = CCR.x = data >> (count - 1);
874: CCR.n = CCR.z << 16;
875: CCR.v = 0;
876: return CCR.z;
877: }
878:
879: // data:C を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
880: // count は 0..63
881: static inline uint32
882: acc_roxr_32(m68kcpu *cpu, uint32 data, int count)
883: {
884: count %= 33;
885: if (count == 0) {
886: CCR.z = data;
887: CCR.n = data;
888: CCR.v = 0;
889: CCR.c = CCR.x;
890: return CCR.z;
891: }
892: // 32bit値の 32ビットシフトは未定義動作なので 64bit値を使用
893: uint64 data64 = data;
894: uint64 rot = data64 & ((1 << (count - 1)) - 1);
895: uint32 x = CCR.x & 1;
896: CCR.z = (data64 >> count) | (rot << (33 - count)) | (x << (32 - count));
897: CCR.c = CCR.x = data64 >> (count - 1);
898: CCR.n = CCR.z;
899: CCR.v = 0;
900: return CCR.z;
901: }
902:
903: // data を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
904: // count は 0..63
905: static inline uint32
906: acc_ror_8(m68kcpu *cpu, uint32 data, int count)
907: {
908: if (count == 0) {
909: acc_move_8(cpu, data);
910: return data;
911: }
912:
913: count %= 8;
914: uint8 tmp = (data >> count) | (data << (8 - count));
915: CCR.z = tmp;
916: CCR.n = (uint32)tmp << 24;
917: // 7 0 1 2 3 4 5 6
918: CCR.c = data >> ((count + 7) % 8);
919: CCR.v = 0;
920: return tmp;
921: }
922:
923: // data を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
924: // count は 0..63
925: static inline uint32
926: acc_ror_16(m68kcpu *cpu, uint32 data, int count)
927: {
928: if (count == 0) {
929: acc_move_16(cpu, data);
930: return data;
931: }
932:
933: count %= 16;
934: uint16 tmp = (data >> count) | (data << (16 - count));
935: CCR.z = tmp;
936: CCR.n = (uint32)tmp << 16;
937: CCR.c = data >> ((count + 15) % 16);
938: CCR.v = 0;
939: return tmp;
940: }
941:
942: // data を count ビット右ローテートし、NZVC フラグを反映して結果を返す。
943: // count は 0..63
944: static inline uint32
945: acc_ror_32(m68kcpu *cpu, uint32 data, int count)
946: {
947: if (count == 0) {
948: acc_move_32(cpu, data);
949: return data;
950: }
951:
952: count %= 32;
953: uint64 data64 = (uint64)data;
954: uint64 tmp = (data >> count) | (data << (32 - count));
955: CCR.z = tmp;
956: CCR.n = tmp;
957: CCR.c = data64 >> ((count + 31) % 32);
958: CCR.v = 0;
959: return tmp;
960: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.