![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fpp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to fpp.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * MC68881 emulation
5: *
6: * Copyright 1996 Herman ten Brugge
7: */
8:
9: #include <math.h>
10:
11: #include "sysconfig.h"
12: #include "sysdeps.h"
13:
14: #include "config.h"
15: #include "options.h"
16: #include "events.h"
17: #include "gui.h"
18: #include "memory.h"
19: #include "custom.h"
20: #include "newcpu.h"
21: #include "ersatz.h"
22: #include "readcpu.h"
23:
24: #if CPU_LEVEL >= 2
25:
26: #define DEBUG_FPP 0
27:
28: /* single : S 8*E 23*F */
29: /* double : S 11*E 52*F */
30: /* extended : S 15*E 64*F */
31: /* E = 0 & F = 0 -> 0 */
32: /* E = MAX & F = 0 -> Infin */
33: /* E = MAX & F # 0 -> NotANumber */
34: /* E = biased by 127 (single) ,1023 (double) ,16383 (extended) */
35:
36: static __inline__ double
37: to_single(ULONG value)
38: {
39: double frac;
40:
41: if ((value & 0x7fffffff) == 0) return(0.0);
42: frac = (double)((value & 0x7fffff) | 0x800000) / 8388608.0;
43: if (value & 0x80000000) frac = -frac;
44: return(ldexp(frac, ((value >> 23) & 0xff) - 127));
45: }
46:
47: static __inline__ ULONG
48: from_single(double src)
49: {
50: int expon;
51: ULONG tmp;
52: double frac;
53:
54: if (src == 0.0) return 0;
55: if (src < 0) { tmp = 0x80000000 ; src = -src; }
56: else { tmp = 0; }
57: frac = frexp(src,&expon);
58: frac += 0.5 / 16777216.0;
59: if (frac >= 1.0) { frac /= 2.0; expon++; }
60: return (tmp | (((expon + 127 - 1) & 0xff) << 23) |
61: (((int)(frac * 16777216.0)) & 0x7fffff));
62: }
63:
64: static __inline__ double
65: to_exten(ULONG wrd1,ULONG wrd2,ULONG wrd3)
66: {
67: double frac;
68:
69: if ((wrd1 & 0x7fff0000) == 0 && wrd2 == 0 && wrd3 == 0) return 0.0;
70: frac = (double)wrd2 / 2147483648.0 +
71: (double)wrd3 / 9223372036854775808.0;
72: if (wrd1 & 0x80000000) frac = -frac;
73: return ldexp(frac, ((wrd1 >> 16) & 0x7fff) - 16383);
74: }
75:
76: static __inline__ void
77: from_exten(double src,ULONG *wrd1, ULONG *wrd2, ULONG * wrd3)
78: {
79: int expon;
80: double frac;
81:
82: if (src == 0.0) { *wrd1 = 0; *wrd2 = 0; *wrd3 = 0; return; }
83: if (src < 0) { *wrd1 = 0x80000000 ; src = -src; }
84: else { *wrd1 = 0; }
85: frac = frexp(src,&expon);
86: frac += 0.5 / 18446744073709551616.0;
87: if (frac >= 1.0) { frac /= 2.0; expon++; }
88: *wrd1 |= (((expon + 16383 - 1) & 0x7fff) << 16);
89: *wrd2 = (ULONG)(frac * 4294967296.0);
90: *wrd3 = (ULONG)(frac * 18446744073709551616.0 - *wrd2 * 4294967296.0);
91: }
92:
93: static __inline__ double
94: to_double(ULONG wrd1,ULONG wrd2)
95: {
96: double frac;
97:
98: if ((wrd1 & 0x7fffffff) == 0 && wrd2 == 0) return 0.0;
99: frac = (double)((wrd1 & 0xfffff) | 0x100000) / 1048576.0 +
100: (double)wrd2 / 4503599627370496.0;
101: if (wrd1 & 0x80000000) frac = -frac;
102: return ldexp(frac, ((wrd1 >> 20) & 0x7ff) - 1023);
103: }
104:
105: static __inline__ void
106: from_double(double src,ULONG *wrd1, ULONG *wrd2)
107: {
108: int expon;
109: int tmp;
110: double frac;
111:
112: if (src == 0.0) { *wrd1 = 0; *wrd2 = 0; return; }
113: if (src < 0) { *wrd1 = 0x80000000 ; src = -src; }
114: else { *wrd1 = 0; }
115: frac = frexp(src,&expon);
116: frac += 0.5 / 9007199254740992.0;
117: if (frac >= 1.0) { frac /= 2.0; expon++; }
118: tmp = (ULONG)(frac * 2097152.0);
119: *wrd1 |= (((expon + 1023 - 1) & 0x7ff) << 20) | (tmp & 0xfffff);
120: *wrd2 = (ULONG)(frac * 9007199254740992.0 - tmp * 4294967296.0);
121: }
122:
123: static __inline__ double
124: to_pack(ULONG wrd1,ULONG wrd2,ULONG wrd3)
125: {
126: double d;
127: char *cp;
128: char str[100];
129:
130: cp = str;
131: if (wrd1 & 0x80000000) *cp++ = '-';
132: *cp++ = (wrd1 & 0xf) + '0';
133: *cp++ = '.';
134: *cp++ = ((wrd2 >> 28) & 0xf) + '0';
135: *cp++ = ((wrd2 >> 24) & 0xf) + '0';
136: *cp++ = ((wrd2 >> 20) & 0xf) + '0';
137: *cp++ = ((wrd2 >> 16) & 0xf) + '0';
138: *cp++ = ((wrd2 >> 12) & 0xf) + '0';
139: *cp++ = ((wrd2 >> 8) & 0xf) + '0';
140: *cp++ = ((wrd2 >> 4) & 0xf) + '0';
141: *cp++ = ((wrd2 >> 0) & 0xf) + '0';
142: *cp++ = ((wrd3 >> 28) & 0xf) + '0';
143: *cp++ = ((wrd3 >> 24) & 0xf) + '0';
144: *cp++ = ((wrd3 >> 20) & 0xf) + '0';
145: *cp++ = ((wrd3 >> 16) & 0xf) + '0';
146: *cp++ = ((wrd3 >> 12) & 0xf) + '0';
147: *cp++ = ((wrd3 >> 8) & 0xf) + '0';
148: *cp++ = ((wrd3 >> 4) & 0xf) + '0';
149: *cp++ = ((wrd3 >> 0) & 0xf) + '0';
150: *cp++ = 'E';
151: if (wrd1 & 0x40000000) *cp++ = '-';
152: *cp++ = ((wrd1 >> 24) & 0xf) + '0';
153: *cp++ = ((wrd1 >> 20) & 0xf) + '0';
154: *cp++ = ((wrd1 >> 16) & 0xf) + '0';
155: *cp = 0;
156: sscanf(str,"%le",&d);
157: return d;
158: }
159:
160: static __inline__ void
161: from_pack(double src,ULONG *wrd1, ULONG *wrd2, ULONG * wrd3)
162: {
163: int i;
164: int t;
165: char *cp;
166: char str[100];
167:
168: sprintf(str,"%.16e",src);
169: cp = str;
170: *wrd1 = *wrd2 = *wrd3 = 0;
171: if (*cp == '-') { cp++ ; *wrd1 = 0x80000000; }
172: if (*cp == '+') cp++;
173: *wrd1 |= (*cp++ - '0');
174: if (*cp == '.') cp++;
175: for (i = 0 ; i < 8 ; i++) {
176: *wrd2 <<= 4;
177: if (*cp >= '0' && *cp <= '9')
178: *wrd2 |= *cp++ - '0';
179: }
180: for (i = 0 ; i < 8 ; i++) {
181: *wrd3 <<= 4;
182: if (*cp >= '0' && *cp <= '9')
183: *wrd3 |= *cp++ - '0';
184: }
185: if (*cp == 'e' || *cp == 'E') {
186: cp++;
187: if (*cp == '-') { cp++; *wrd1 |= 0x40000000; }
188: if (*cp == '+') cp++;
189: t = 0;
190: for (i = 0 ; i < 3 ; i++) {
191: if (*cp >= '0' && *cp <= '9')
192: t = (t << 4) | (*cp++ - '0');
193: }
194: *wrd1 |= t << 16;
195: }
196: }
197:
198: static __inline__ int
199: get_fp_value(ULONG opcode, UWORD extra,double *src)
200: {
201: int size;
202: int mode;
203: int reg;
204: ULONG ad = 0;
205: static int sz1[8] = { 4,4,12,12,2,8,1,0 };
206: static int sz2[8] = { 4,4,12,12,2,8,2,0 };
207:
208: if ((extra & 0x4000) == 0) {
209: *src = regs.fp[(extra >> 10) & 7];
210: return 1;
211: }
212: mode = (opcode >> 3) & 7;
213: reg = opcode & 7;
214: size = (extra >> 10) & 7;
215: switch (mode) {
216: case 0:
217: switch (size) {
218: case 6: *src = (double)(BYTE)regs.d[reg];
219: break;
220: case 4: *src = (double)(WORD)regs.d[reg];
221: break;
222: case 0: *src = (double)(LONG)regs.d[reg];
223: break;
224: case 1: *src = to_single(regs.d[reg]);
225: break;
226: default:
227: return 0;
228: }
229: return 1;
230: case 1:
231: return 0;
232: case 2:
233: ad = regs.a[reg];
234: break;
235: case 3:
236: ad = regs.a[reg];
237: regs.a[reg] += reg == 7 ? sz2[size] : sz1[size];
238: break;
239: case 4:
240: regs.a[reg] -= reg == 7 ? sz2[size] : sz1[size];
241: ad = regs.a[reg];
242: break;
243: case 5:
244: ad = regs.a[reg] + (LONG)(WORD)nextiword();
245: break;
246: case 6:
247: ad = get_disp_ea(regs.a[reg]);
248: break;
249: case 7:
250: switch (reg) {
251: case 0: ad = (LONG)(WORD)nextiword();
252: break;
253: case 1: ad = nextilong();
254: break;
255: case 2: ad = m68k_getpc();
256: ad += (LONG)(WORD)nextiword();
257: break;
258: case 3: ad = get_disp_ea(m68k_getpc());
259: break;
260: case 4: ad = m68k_getpc();
261: m68k_setpc(ad + sz2[size]);
262: break;
263: default:
264: return 0;
265: }
266: }
267: switch (size) {
268: case 0: *src = (double)(LONG)get_long(ad);
269: break;
270: case 1: *src = to_single(get_long(ad));
271: break;
272: case 2: { ULONG wrd1,wrd2,wrd3;
273: wrd1 = get_long(ad);ad+=4;
274: wrd2 = get_long(ad);ad+=4;
275: wrd3 = get_long(ad);
276: *src = to_exten(wrd1,wrd2,wrd3);
277: }
278: break;
279: case 3: { ULONG wrd1,wrd2,wrd3;
280: wrd1 = get_long(ad);ad+=4;
281: wrd2 = get_long(ad);ad+=4;
282: wrd3 = get_long(ad);
283: *src = to_pack(wrd1,wrd2,wrd3);
284: }
285: break;
286: case 4: *src = (double)(WORD)get_word(ad);
287: break;
288: case 5: { ULONG wrd1,wrd2;
289: wrd1 = get_long(ad);ad+=4;
290: wrd2 = get_long(ad);
291: *src = to_double(wrd1,wrd2);
292: }
293: break;
294: case 6: *src = (double)(BYTE)get_byte(ad);
295: break;
296: default:
297: return 0;
298: }
299: return 1;
300: }
301:
302: static __inline__ int
303: put_fp_value(double value, ULONG opcode, UWORD extra)
304: {
305: int size;
306: int mode;
307: int reg;
308: ULONG ad;
309: static int sz1[8] = { 4,4,12,12,2,8,1,0 };
310: static int sz2[8] = { 4,4,12,12,2,8,2,0 };
311:
312: if ((extra & 0x4000) == 0) {
313: regs.fp[(extra >> 10) & 7] = value;
314: return 1;
315: }
316: mode = (opcode >> 3) & 7;
317: reg = opcode & 7;
318: size = (extra >> 10) & 7;
319: ad = -1;
320: switch (mode) {
321: case 0:
322: switch (size) {
323: case 6: regs.d[reg] = ((int)value & 0xff) |
324: (regs.d[reg] & ~0xff);
325: break;
326: case 4: regs.d[reg] = ((int)value & 0xffff) |
327: (regs.d[reg] & ~0xffff);
328: break;
329: case 0: regs.d[reg] = (int)value;
330: break;
331: case 1: regs.d[reg] = from_single(value);
332: break;
333: default:
334: return 0;
335: }
336: return 1;
337: case 1:
338: return 0;
339: case 2:
340: ad = regs.a[reg];
341: break;
342: case 3:
343: ad = regs.a[reg];
344: regs.a[reg] += reg == 7 ? sz2[size] : sz1[size];
345: break;
346: case 4:
347: regs.a[reg] -= reg == 7 ? sz2[size] : sz1[size];
348: ad = regs.a[reg];
349: break;
350: case 5:
351: ad = regs.a[reg] + (LONG)(WORD)nextiword();
352: break;
353: case 6:
354: ad = get_disp_ea(regs.a[reg]);
355: break;
356: case 7:
357: switch (reg) {
358: case 0: ad = (LONG)(WORD)nextiword();
359: break;
360: case 1: ad = nextilong();
361: break;
362: case 2: ad = m68k_getpc();
363: ad += (LONG)(WORD)nextiword();
364: break;
365: case 3: ad = get_disp_ea(m68k_getpc());
366: break;
367: case 4: ad = m68k_getpc();
368: m68k_setpc(ad + sz2[size]);
369: break;
370: default:
371: return 0;
372: }
373: }
374: switch (size) {
375: case 0: put_long(ad,(LONG)value);
376: break;
377: case 1: put_long(ad,from_single(value));
378: break;
379: case 2: { ULONG wrd1,wrd2,wrd3;
380: from_exten(value,&wrd1,&wrd2,&wrd3);
381: put_long(ad,wrd1);ad+=4;
382: put_long(ad,wrd2);ad+=4;
383: put_long(ad,wrd3);
384: }
385: break;
386: case 3: { ULONG wrd1,wrd2,wrd3;
387: from_pack(value,&wrd1,&wrd2,&wrd3);
388: put_long(ad,wrd1);ad+=4;
389: put_long(ad,wrd2);ad+=4;
390: put_long(ad,wrd3);
391: }
392: break;
393: case 4: put_word(ad,(WORD)value);
394: break;
395: case 5: { ULONG wrd1,wrd2;
396: from_double(value,&wrd1,&wrd2);
397: put_long(ad,wrd1);ad+=4;
398: put_long(ad,wrd2);
399: }
400: break;
401: case 6: put_byte(ad,(BYTE)value);
402: break;
403: default:
404: return 0;
405: }
406: return 1;
407: }
408:
409: static __inline__ int
410: get_fp_ad(ULONG opcode,ULONG *ad)
411: {
412: int mode;
413: int reg;
414:
415: mode = (opcode >> 3) & 7;
416: reg = opcode & 7;
417: switch (mode) {
418: case 0:
419: case 1:
420: return 0;
421: case 2:
422: *ad = regs.a[reg];
423: break;
424: case 3:
425: *ad = regs.a[reg];
426: break;
427: case 4:
428: *ad = regs.a[reg];
429: break;
430: case 5:
431: *ad = regs.a[reg] + (LONG)(WORD)nextiword();
432: break;
433: case 6:
434: *ad = get_disp_ea(regs.a[reg]);
435: break;
436: case 7:
437: switch (reg) {
438: case 0: *ad = (LONG)(WORD)nextiword();
439: break;
440: case 1: *ad = nextilong();
441: break;
442: case 2: *ad = m68k_getpc();
443: *ad += (LONG)(WORD)nextiword();
444: break;
445: case 3: *ad = get_disp_ea(m68k_getpc());
446: break;
447: default:
448: return 0;
449: }
450: }
451: return 1;
452: }
453:
454: static __inline__ int
455: fpp_cond(ULONG opcode, int contition)
456: {
457: int N = (regs.fpsr & 0x8000000) != 0;
458: int Z = (regs.fpsr & 0x4000000) != 0;
459: /* int I = (regs.fpsr & 0x2000000) != 0; */
460: int NotANumber = (regs.fpsr & 0x1000000) != 0;
461:
462: switch (contition) {
463: case 0x00: return 0;
464: case 0x01: return Z;
465: case 0x02: return !(NotANumber || Z || N);
466: case 0x03: return Z || !(NotANumber || N);
467: case 0x04: return N && !(NotANumber || Z);
468: case 0x05: return Z || (N && !NotANumber);
469: case 0x06: return !(NotANumber || Z);
470: case 0x07: return !NotANumber;
471: case 0x08: return NotANumber;
472: case 0x09: return NotANumber || Z;
473: case 0x0a: return NotANumber || !(N || Z);
474: case 0x0b: return NotANumber || Z || !N;
475: case 0x0c: return NotANumber || (N && !Z);
476: case 0x0d: return NotANumber || Z || N;
477: case 0x0e: return !Z;
478: case 0x0f: return 1;
479: case 0x10: return 0;
480: case 0x11: return Z;
481: case 0x12: return !(NotANumber || Z || N);
482: case 0x13: return Z || !(NotANumber || N);
483: case 0x14: return N && !(NotANumber || Z);
484: case 0x15: return Z || (N && !NotANumber);
485: case 0x16: return !(NotANumber || Z);
486: case 0x17: return !NotANumber;
487: case 0x18: return NotANumber;
488: case 0x19: return NotANumber || Z;
489: case 0x1a: return NotANumber || !(N || Z);
490: case 0x1b: return NotANumber || Z || !N;
491: case 0x1c: return NotANumber || (Z && N);
492: case 0x1d: return NotANumber || Z || N;
493: case 0x1e: return !Z;
494: case 0x1f: return 1;
495: }
496: return -1;
497: }
498:
499: void
500: fdbcc_opp(ULONG opcode, UWORD extra)
501: {
502: CPTR pc = (ULONG)m68k_getpc();
503: LONG disp = (LONG)(WORD)nextiword();
504: int cc;
505:
506: #if DEBUG_FPP
507: printf("fdbcc_opp at %08lx\n",m68k_getpc());fflush(stdout);
508: #endif
509: cc = fpp_cond(opcode, extra & 0x3f);
510: if (cc == -1) {
511: m68k_setpc(pc-2);
512: op_illg(opcode);
513: }
514: else if (!cc) {
515: regs.d[opcode & 0x7] = (regs.d[opcode & 0x7] & ~0xffff) |
516: ((regs.d[opcode & 0x7]-1) & 0xffff);
517: if ((regs.d[opcode & 0x7] & 0xffff) == 0xffff)
518: m68k_setpc(pc + disp);
519: }
520: }
521:
522: void
523: fscc_opp(ULONG opcode, UWORD extra)
524: {
525: ULONG ad;
526: int cc;
527:
528: #if DEBUG_FPP
529: printf("fscc_opp at %08lx\n",m68k_getpc());fflush(stdout);
530: #endif
531: cc = fpp_cond(opcode, extra & 0x3f);
532: if (cc == -1) {
533: m68k_setpc(m68k_getpc()-2);
534: op_illg(opcode);
535: }
536: else if ((opcode & 0x38) == 0) {
537: regs.d[opcode & 7] = (regs.d[opcode & 7] & ~0xff) |
538: (cc ? 0xff : 0x00);
539: }
540: else {
541: if (get_fp_ad(opcode,&ad) == 0) {
542: m68k_setpc(m68k_getpc()-2);
543: op_illg(opcode);
544: }
545: else
546: put_byte(ad,cc ? 0xff : 0x00);
547: }
548: }
549:
550: void
551: ftrapcc_opp(ULONG opcode, CPTR oldpc)
552: {
553: int cc;
554:
555: #if DEBUG_FPP
556: printf("ftrapcc_opp at %08lx\n",m68k_getpc());fflush(stdout);
557: #endif
558: cc = fpp_cond(opcode, opcode & 0x3f);
559: if (cc == -1) {
560: m68k_setpc(oldpc);
561: op_illg(opcode);
562: }
563: if (cc)
564: Exception(7,oldpc-2);
565: }
566:
567: void
568: fbcc_opp(ULONG opcode, CPTR pc, ULONG extra)
569: {
570: int cc;
571:
572: #if DEBUG_FPP
573: printf("fbcc_opp at %08lx\n",m68k_getpc());fflush(stdout);
574: #endif
575: cc = fpp_cond(opcode, opcode & 0x3f);
576: if (cc == -1) {
577: m68k_setpc(pc);
578: op_illg(opcode);
579: }
580: else if (cc) {
581: if ((opcode & 0x40) == 0)
582: extra = (LONG)(WORD)extra;
583: m68k_setpc(pc + extra);
584: }
585: }
586:
587: void
588: fsave_opp(ULONG opcode)
589: {
590: ULONG ad;
591: int incr = (opcode & 0x38) == 0x20 ? -1 : 1;
592: int i;
593:
594: #if DEBUG_FPP
595: printf("fsave_opp at %08lx\n",m68k_getpc());fflush(stdout);
596: #endif
597: if (get_fp_ad(opcode,&ad) == 0) {
598: op_illg(opcode);
599: return;
600: }
601: if (incr < 0) {
602: ad -= 4;put_long(ad,0x70000000);
603: for (i = 0 ; i < 5 ; i++) {
604: ad -= 4;put_long(ad,0x00000000);
605: }
606: ad -= 4;put_long(ad,0x1f180000);
607: }
608: else {
609: put_long(ad,0x1f180000); ad += 4;
610: for (i = 0 ; i < 5 ; i++) {
611: put_long(ad,0x00000000); ad += 4;
612: }
613: put_long(ad,0x70000000); ad += 4;
614: }
615: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
616: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad;
617: }
618:
619: void
620: frestore_opp(ULONG opcode)
621: {
622: ULONG ad;
623: ULONG d;
624: int incr = (opcode & 0x38) == 0x20 ? -1 : 1;
625:
626: #if DEBUG_FPP
627: printf("frestore_opp at %08lx\n",m68k_getpc());fflush(stdout);
628: #endif
629: if (get_fp_ad(opcode,&ad) == 0) {
630: op_illg(opcode);
631: return;
632: }
633: if (incr < 0) {
634: ad -= 4; d = get_long(ad);
635: if ((d & 0xff000000) != 0) {
636: if ((d & 0x00ff0000) == 0x00180000)
637: ad -= 6 * 4;
638: else if ((d & 0x00ff0000) == 0x00380000)
639: ad -= 14 * 4;
640: else if ((d & 0x00ff0000) == 0x00b40000)
641: ad -= 45 * 4;
642: }
643: }
644: else {
645: d = get_long(ad); ad += 4;
646: if ((d & 0xff000000) != 0) {
647: if ((d & 0x00ff0000) == 0x00180000)
648: ad += 6 * 4;
649: else if ((d & 0x00ff0000) == 0x00380000)
650: ad += 14 * 4;
651: else if ((d & 0x00ff0000) == 0x00b40000)
652: ad += 45 * 4;
653: }
654: }
655: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
656: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad;
657: }
658:
659: void
660: fpp_opp(ULONG opcode, UWORD extra)
661: {
662: int reg;
663: double src;
664:
665: #if DEBUG_FPP
666: printf("FPP %04lx %04x at %08lx\n",opcode & 0xffff,extra & 0xffff,
667: m68k_getpc()-4);fflush(stdout);
668: #endif
669: switch ((extra >> 13) & 0x7) {
670: case 3:
671: if (put_fp_value(regs.fp[(extra >> 7) & 7], opcode, extra)== 0){
672: m68k_setpc(m68k_getpc()-2);
673: op_illg(opcode);
674: }
675: return;
676: case 4:
677: case 5:
678: if ((opcode & 0x38) == 0) {
679: if (extra & 0x2000) {
680: if (extra & 0x1000)
681: regs.d[opcode & 7] = regs.fpcr;
682: if (extra & 0x0800)
683: regs.d[opcode & 7] = regs.fpsr;
684: if (extra & 0x0400)
685: regs.d[opcode & 7] = regs.fpiar;
686: }
687: else {
688: if (extra & 0x1000)
689: regs.fpcr = regs.d[opcode & 7];
690: if (extra & 0x0800)
691: regs.fpsr = regs.d[opcode & 7];
692: if (extra & 0x0400)
693: regs.fpiar = regs.d[opcode & 7];
694: }
695: }
696: else if ((opcode & 0x38) == 1) {
697: if (extra & 0x2000) {
698: if (extra & 0x1000)
699: regs.a[opcode & 7] = regs.fpcr;
700: if (extra & 0x0800)
701: regs.a[opcode & 7] = regs.fpsr;
702: if (extra & 0x0400)
703: regs.a[opcode & 7] = regs.fpiar;
704: }
705: else {
706: if (extra & 0x1000)
707: regs.fpcr = regs.a[opcode & 7];
708: if (extra & 0x0800)
709: regs.fpsr = regs.a[opcode & 7];
710: if (extra & 0x0400)
711: regs.fpiar = regs.a[opcode & 7];
712: }
713: }
714: else if ((opcode & 0x3f) == 0x3c) {
715: if ((extra & 0x2000) == 0) {
716: if (extra & 0x1000)
717: regs.fpcr = nextilong();
718: if (extra & 0x0800)
719: regs.fpsr = nextilong();
720: if (extra & 0x0400)
721: regs.fpiar = nextilong();
722: }
723: }
724: else if (extra & 0x2000) {
725: /* FMOVEM FPP->memory */
726: ULONG ad;
727: int incr = 0;
728:
729: if (get_fp_ad(opcode,&ad) == 0) {
730: m68k_setpc(m68k_getpc()-2);
731: op_illg(opcode);
732: return;
733: }
734: if ((opcode & 0x38) == 0x20) {
735: if (extra & 0x1000) incr += 4;
736: if (extra & 0x0800) incr += 4;
737: if (extra & 0x0400) incr += 4;
738: }
739: ad -= incr;
740: if (extra & 0x1000) {
741: put_long(ad,regs.fpcr);ad+=4;
742: }
743: if (extra & 0x0800) {
744: put_long(ad,regs.fpsr);ad+=4;
745: }
746: if (extra & 0x0400) {
747: put_long(ad,regs.fpiar);ad+=4;
748: }
749: ad -= incr;
750: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
751: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad;
752: }
753: else {
754: /* FMOVEM memory->FPP */
755: ULONG ad;
756:
757: if (get_fp_ad(opcode,&ad) == 0) {
758: m68k_setpc(m68k_getpc()-2);
759: op_illg(opcode);
760: return;
761: }
762: ad = (opcode & 0x38) == 0x20 ? ad-12 : ad;
763: if (extra & 0x1000) {
764: regs.fpcr = get_long(ad);ad+=4;
765: }
766: if (extra & 0x0800) {
767: regs.fpsr = get_long(ad);ad+=4;
768: }
769: if (extra & 0x0400) {
770: regs.fpiar = get_long(ad);ad+=4;
771: }
772: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
773: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad-12;
774: }
775: return;
776: case 6:
777: case 7:
778: {
779: ULONG ad,list = 0;
780: int incr = 0;
781: if (extra & 0x2000) {
782: /* FMOVEM FPP->memory */
783: if (get_fp_ad(opcode,&ad) == 0) {
784: m68k_setpc(m68k_getpc()-2);
785: op_illg(opcode);
786: return;
787: }
788: switch ((extra >> 11) & 3) {
789: case 0: /* static pred */
790: list = extra & 0xff;
791: incr = -1;
792: break;
793: case 1: /* dynamic pred */
794: list = regs.d[(extra >> 4) & 3] & 0xff;
795: incr = -1;
796: break;
797: case 2: /* static postinc */
798: list = extra & 0xff;
799: incr = 1;
800: break;
801: case 3: /* dynamic postinc */
802: list = regs.d[(extra >> 4) & 3] & 0xff;
803: incr = 1;
804: break;
805: }
806: while (list) {
807: ULONG wrd1,wrd2,wrd3;
808: if (incr < 0) {
809: from_exten(
810: regs.fp[fpp_movem_index2[list]],
811: &wrd1,&wrd2,&wrd3);
812: ad-=4;put_long(ad,wrd3);
813: ad-=4;put_long(ad,wrd2);
814: ad-=4;put_long(ad,wrd1);
815: }
816: else {
817: from_exten(
818: regs.fp[fpp_movem_index1[list]],
819: &wrd1,&wrd2,&wrd3);
820: put_long(ad,wrd1);ad+=4;
821: put_long(ad,wrd2);ad+=4;
822: put_long(ad,wrd3);ad+=4;
823: }
824: list = fpp_movem_next[list];
825: }
826: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
827: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad;
828: }
829: else {
830: /* FMOVEM memory->FPP */
831: if (get_fp_ad(opcode,&ad) == 0) {
832: m68k_setpc(m68k_getpc()-2);
833: op_illg(opcode);
834: return;
835: }
836: switch ((extra >> 11) & 3) {
837: case 0: /* static pred */
838: list = extra & 0xff;
839: incr = -1;
840: break;
841: case 1: /* dynamic pred */
842: list = regs.d[(extra >> 4) & 3] & 0xff;
843: incr = -1;
844: break;
845: case 2: /* static postinc */
846: list = extra & 0xff;
847: incr = 1;
848: break;
849: case 3: /* dynamic postinc */
850: list = regs.d[(extra >> 4) & 3] & 0xff;
851: incr = 1;
852: break;
853: }
854: while (list) {
855: ULONG wrd1,wrd2,wrd3;
856: if (incr < 0) {
857: ad-=4;wrd3 = get_long(ad);
858: ad-=4;wrd2 = get_long(ad);
859: ad-=4;wrd1 = get_long(ad);
860: regs.fp[fpp_movem_index2[list]] =
861: to_exten(wrd1,wrd2,wrd3);
862: }
863: else {
864: wrd1 = get_long(ad);ad+=4;
865: wrd2 = get_long(ad);ad+=4;
866: wrd3 = get_long(ad);ad+=4;
867: regs.fp[fpp_movem_index1[list]] =
868: to_exten(wrd1,wrd2,wrd3);
869: }
870: list = fpp_movem_next[list];
871: }
872: if ((opcode & 0x38) == 0x18) regs.a[opcode & 7] = ad;
873: if ((opcode & 0x38) == 0x20) regs.a[opcode & 7] = ad;
874: }
875: }
876: return;
877: case 0:
878: case 2:
879: reg = (extra >> 7) & 7;
880: if ((extra & 0xfc00) == 0x5c00) {
881: switch (extra & 0x7f) {
882: case 0x00: regs.fp[reg] = 4.0*atan(1.0); break;
883: case 0x0b: regs.fp[reg] = log10(2.0); break;
884: case 0x0c: regs.fp[reg] = exp(1.0); break;
885: case 0x0d: regs.fp[reg] = log(exp(1.0))/log(2.0); break;
886: case 0x0e: regs.fp[reg] = log(exp(1.0))/log(10.0); break;
887: case 0x0f: regs.fp[reg] = 0.0; break;
888: case 0x30: regs.fp[reg] = log(2.0); break;
889: case 0x31: regs.fp[reg] = log(10.0); break;
890: case 0x32: regs.fp[reg] = 1.0e0; break;
891: case 0x33: regs.fp[reg] = 1.0e1; break;
892: case 0x34: regs.fp[reg] = 1.0e2; break;
893: case 0x35: regs.fp[reg] = 1.0e4; break;
894: case 0x36: regs.fp[reg] = 1.0e8; break;
895: case 0x37: regs.fp[reg] = 1.0e16; break;
896: case 0x38: regs.fp[reg] = 1.0e32; break;
897: case 0x39: regs.fp[reg] = 1.0e64; break;
898: case 0x3a: regs.fp[reg] = 1.0e128; break;
899: case 0x3b: regs.fp[reg] = 1.0e256; break;
900: #if 0
901: case 0x3c: regs.fp[reg] = 1.0e512; break;
902: case 0x3d: regs.fp[reg] = 1.0e1024; break;
903: case 0x3e: regs.fp[reg] = 1.0e2048; break;
904: case 0x3f: regs.fp[reg] = 1.0e4096; break;
905: #endif
906: default:
907: m68k_setpc(m68k_getpc()-2);
908: op_illg(opcode);
909: break;
910: }
911: return;
912: }
913: if (get_fp_value(opcode, extra, &src) == 0) {
914: m68k_setpc(m68k_getpc()-2);
915: op_illg(opcode);
916: return;
917: }
918: switch (extra & 0x7f) {
919: case 0x00: /* FMOVE */
920: regs.fp[reg] = src;
921: break;
922: case 0x01: /* FINT */
923: regs.fp[reg] = (int)(src + 0.5);
924: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
925: (regs.fp[reg] < 0 ? 0x8000000 : 0);
926: break;
927: case 0x02: /* FSINH */
928: regs.fp[reg] = sinh(src);
929: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
930: (regs.fp[reg] < 0 ? 0x8000000 : 0);
931: break;
932: case 0x03: /* FINTRZ */
933: regs.fp[reg] = (int)src;
934: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
935: (regs.fp[reg] < 0 ? 0x8000000 : 0);
936: break;
937: case 0x04: /* FSQRT */
938: regs.fp[reg] = sqrt(src);
939: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
940: (regs.fp[reg] < 0 ? 0x8000000 : 0);
941: break;
942: case 0x06: /* FLOGNP1 */
943: regs.fp[reg] = log(src + 1.0);
944: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
945: (regs.fp[reg] < 0 ? 0x8000000 : 0);
946: break;
947: case 0x08: /* FETOXM1 */
948: regs.fp[reg] = exp(src) - 1.0;
949: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
950: (regs.fp[reg] < 0 ? 0x8000000 : 0);
951: break;
952: case 0x09: /* FTANH */
953: regs.fp[reg] = tanh(src);
954: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
955: (regs.fp[reg] < 0 ? 0x8000000 : 0);
956: break;
957: case 0x0a: /* FATAN */
958: regs.fp[reg] = atan(src);
959: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
960: (regs.fp[reg] < 0 ? 0x8000000 : 0);
961: break;
962: case 0x0c: /* FASIN */
963: regs.fp[reg] = asin(src);
964: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
965: (regs.fp[reg] < 0 ? 0x8000000 : 0);
966: break;
967: case 0x0d: /* FATANH */
968: #ifdef __bebox__
969: printf("atanh\n");
970: #else
971: regs.fp[reg] = atanh(src);
972: #endif
973: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
974: (regs.fp[reg] < 0 ? 0x8000000 : 0);
975: break;
976: case 0x0e: /* FSIN */
977: regs.fp[reg] = sin(src);
978: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
979: (regs.fp[reg] < 0 ? 0x8000000 : 0);
980: break;
981: case 0x0f: /* FTAN */
982: regs.fp[reg] = tan(src);
983: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
984: (regs.fp[reg] < 0 ? 0x8000000 : 0);
985: break;
986: case 0x10: /* FETOX */
987: regs.fp[reg] = exp(src);
988: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
989: (regs.fp[reg] < 0 ? 0x8000000 : 0);
990: break;
991: case 0x11: /* FTWOTOX */
992: regs.fp[reg] = pow(2.0,src);
993: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
994: (regs.fp[reg] < 0 ? 0x8000000 : 0);
995: break;
996: case 0x12: /* FTENTOX */
997: regs.fp[reg] = pow(10.0,src);
998: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
999: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1000: break;
1001: case 0x14: /* FLOGN */
1002: regs.fp[reg] = log(src);
1003: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1004: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1005: break;
1006: case 0x15: /* FLOG10 */
1007: regs.fp[reg] = log10(src);
1008: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1009: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1010: break;
1011: case 0x16: /* FLOG2 */
1012: regs.fp[reg] = log(src) / log(2.0);
1013: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1014: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1015: break;
1016: case 0x18: /* FABS */
1017: regs.fp[reg] = src < 0 ? -src : src;
1018: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1019: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1020: break;
1021: case 0x19: /* FCOSH */
1022: regs.fp[reg] = cosh(src);
1023: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1024: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1025: break;
1026: case 0x1a: /* FNEG */
1027: regs.fp[reg] = -src;
1028: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1029: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1030: break;
1031: case 0x1c: /* FACOS */
1032: regs.fp[reg] = acos(src);
1033: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1034: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1035: break;
1036: case 0x1d: /* FCOS */
1037: regs.fp[reg] = cos(src);
1038: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1039: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1040: break;
1041: case 0x1e: /* FGETEXP */
1042: { int expon;
1043: frexp(src,&expon);
1044: regs.fp[reg] = (double)(expon-1);
1045: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1046: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1047: }
1048: break;
1049: case 0x1f: /* FGETMAN */
1050: { int expon;
1051: regs.fp[reg] = frexp(src,&expon) * 2.0;
1052: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1053: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1054: }
1055: break;
1056: case 0x20: /* FDIV */
1057: regs.fp[reg] /= src;
1058: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1059: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1060: break;
1061: case 0x21: /* FMOD */
1062: regs.fp[reg] = regs.fp[reg] -
1063: (double)((int)(regs.fp[reg] / src)) * src;
1064: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1065: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1066: break;
1067: case 0x22: /* FADD */
1068: regs.fp[reg] += src;
1069: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1070: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1071: break;
1072: case 0x23: /* FMUL */
1073: regs.fp[reg] *= src;
1074: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1075: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1076: break;
1077: case 0x24: /* FSGLDIV */
1078: regs.fp[reg] /= src;
1079: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1080: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1081: break;
1082: case 0x25: /* FREM */
1083: regs.fp[reg] = regs.fp[reg] -
1084: (double)((int)(regs.fp[reg] / src + 0.5)) * src;
1085: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1086: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1087: break;
1088: case 0x26: /* FSCALE */
1089: regs.fp[reg] *= exp(log(2.0)*src);
1090: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1091: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1092: break;
1093: case 0x27: /* FSGLMUL */
1094: regs.fp[reg] *= src;
1095: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1096: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1097: break;
1098: case 0x28: /* FSUB */
1099: regs.fp[reg] -= src;
1100: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1101: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1102: break;
1103: case 0x30: /* FSINCOS */
1104: case 0x31:
1105: case 0x32:
1106: case 0x33:
1107: case 0x34:
1108: case 0x35:
1109: case 0x36:
1110: case 0x37:
1111: regs.fp[reg] = sin(src);
1112: regs.fp[extra & 7] = cos(src);
1113: regs.fpsr = (regs.fp[reg] == 0 ? 0x4000000 : 0) |
1114: (regs.fp[reg] < 0 ? 0x8000000 : 0);
1115: break;
1116: case 0x38: /* FCMP */
1117: { double tmp = regs.fp[reg] - src;
1118: regs.fpsr = (tmp == 0 ? 0x4000000 : 0) |
1119: (tmp < 0 ? 0x8000000 : 0);
1120: }
1121: break;
1122: case 0x3a: /* FTST */
1123: regs.fpsr = (src == 0 ? 0x4000000 : 0) |
1124: (src < 0 ? 0x8000000 : 0);
1125: break;
1126: default:
1127: m68k_setpc(m68k_getpc()-2);
1128: op_illg(opcode);
1129: break;
1130: }
1131: return;
1132: }
1133: m68k_setpc(m68k_getpc()-2);
1134: op_illg(opcode);
1135: }
1136:
1137: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.