ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/uae_cpu/fpu_x86.cpp
Revision: 1.5
Committed: 2001-03-20T18:04:01Z (23 years, 2 months ago) by gbeauche
Branch: MAIN
CVS Tags: HEAD
Changes since 1.4: +0 -0 lines
State: FILE REMOVED
Log Message: 
Moved FPU emulation code sources to uae_cpu/fpu/

File Contents

# Content
1 /*
2 * fpu_x86.cpp - 68881/68040 fpu code for x86/Windows an Linux/x86.
3 *
4 * Basilisk II (C) 1997-2001 Christian Bauer
5 *
6 * MC68881/68040 fpu emulation
7 *
8 * Based on UAE FPU, original copyright 1996 Herman ten Brugge,
9 * rewritten for x86 by Lauri Pesonen 1999-2000,
10 * accomodated to GCC's Extended Asm syntax by Gwenole Beauchesne 2000.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 *
27 * Interface
28 * Almost the same as original. Please see the comments in "fpu.h".
29 * Call fpu_init() and fpu_set_integral_fpu() before cpu thread starts up.
30 *
31 *
32 * Why assembly?
33 * The reason is not really speed, but to get infinities,
34 * NANs and flags finally working.
35 *
36 *
37 * How to maintain Mac and x86 FPU flags -- plan B
38 *
39 * regs.piar is not updated.
40 *
41 * regs.fpcr always contains the real 68881/68040 control word.
42 *
43 * regs.fpsr is not kept up-to-date, for efficiency reasons.
44 * Most of the FPU commands update this in a way or another,
45 * but it is not read nearly that often. Therefore, three host-specific
46 * words hold the status byte and exception byte ("sw"), accrued exception
47 * byte ("sw_accrued") and the quotient byte ("sw_quotient"), as explained below.
48 *
49 * CONDITION CODE - QUOTIENT - EXCEPTION STATUS - ACCRUED EXCEPTION
50 * CONDITION CODE (N,Z,I,NAN)
51 * updated after each opcode, if needed.
52 * x86 assembly opcodes call FXAM and store the status word to "sw".
53 * When regs.fpsr is actually used, the value of "sw" is translated.
54 * QUOTIENT BYTE
55 * Updated by frem, fmod, frestore(null frame)
56 * Stored in "sw_quotient" in correct bit position, combined when
57 * regs.fpsr is actually used.
58 * EXCEPTION STATUS (BSUN,SNAN,OPERR,OVFL,UNFL,DZ,INEX2,INEX1)
59 * updated after each opcode, if needed.
60 * Saved in x86 form in "sw".
61 * When regs.fpsr is actually used, the value of "sw" is translated.
62 * Only fcc_op can set BSUN
63 * ACCRUED EXCEPTION (ACCR_IOP,ACCR_OVFL,ACCR_UNFL,ACCR_DZ,ACCR_INEX)
64 * updated after each opcode, if needed.
65 * Logically OR'ed in x86 form to "sw_accrued".
66 * When regs.fpsr is actually used, the value of "sw_accrued" is translated.
67 *
68 * When "sw" and "sw_accrued" are stored, all pending x86 FPU
69 * exceptions are cleared, if there are any.
70 *
71 * Writing to "regs.fpsr" reverse-maps to x86 status/exception values
72 * and stores the values in "sw", "sw_accrued" and "sw_quotient".
73 *
74 * So, "sw" and "sw_accrued" are not in correct bit positions
75 * and have x86 values, but "sw_quotient" is at correct position.
76 *
77 * Note that it does not matter that the reverse-mapping is not exact
78 * (both SW_IE and SW_DE are mapped to ACCR_IOP, but ACCR_IOP maps to SW_IE
79 * only), the MacOS always sees the correct exception bits.
80 *
81 * Also note the usage of the fake BSUN flag SW_FAKE_BSUN. If you change the
82 * x86 FPU code, you must make sure that you don't generate any FPU stack faults.
83 *
84 *
85 * x86 co-processor initialization:
86 *
87 * Bit Code Use
88 * 0 IM Invalid operation exception mask 1 Disabled
89 * 1 DM Denormalized operand exception mask 1 Disabled
90 * 2 ZM Zerodivide exception mask 1 Disabled
91 * 3 OM Overflow exception mask 1 Disabled
92 * 4 UM Underflow exception mask 1 Disabled
93 * 5 PM Precision exception mask 1 Disabled
94 * 6 - - - -
95 * 7 IEM Interrupt enable mask 0 Enabled
96 * 8 PC Precision control\ 1 - 64 bits
97 * 9 PC Precision control/ 1 /
98 * 10 RC Rounding control\ 0 - Nearest even
99 * 11 RC Rounding control/ 0 /
100 * 12 IC Infinity control 1 Affine
101 * 13 - - - -
102 * 14 - - - -
103 * 15 - - - -
104 *
105 *
106 * TODO:
107 * - Exceptions are not implemented.
108 * - All tbyte variables should be aligned to 16-byte boundaries.
109 * (for best efficiency).
110 * - FTRAPcc code looks like broken.
111 * - If USE_3_BIT_QUOTIENT is 0, exceptions should be checked after
112 * float -> int rounding (frem,fmod).
113 * - The speed can be greatly improved. Do this only after you are sure
114 * that there are no major bugs.
115 * - Support for big-endian byte order (but all assembly code needs to
116 * be rewritten anyway)
117 * I have some non-portable code like *((uae_u16 *)&m68k_dreg(regs, reg)) = newv;
118 * Sorry about that, you need to change these. I could do it myself, but better
119 * not, I would have no way to test them out.
120 * I tried to mark all spots with a comment TODO_BIGENDIAN.
121 * - to_double() may need renormalization code. Or then again, maybe not.
122 * - Signaling NANs should be handled better. The current mapping of
123 * signaling nan exception to denormalized operand exception is only
124 * based on the idea that the (possible) handler sees that "something
125 * seriously wrong" and takes the same action. Should not really get (m)any
126 * of those since normalization is handled on to_exten()
127 *
128 */
129
130 #include <math.h>
131 #include <stdio.h>
132 #include <string.h>
133
134 #include "sysdeps.h"
135 #include "memory.h"
136 #include "readcpu.h"
137 #include "newcpu.h"
138 #include "fpu_x86.h"
139 #include "fpu_x86_asm.h"
140
141 /* ---------------------------- Compatibility ---------------------------- */
142
143 #define BYTE uint8
144 #define WORD uint16
145 #define DWORD uint32
146 #define _ASM __asm__ __volatile__
147 #define min(a, b) (((a) < (b)) ? (a) : (b))
148
149 /* ---------------------------- Configuration ---------------------------- */
150
151 /*
152 If USE_3_BIT_QUOTIENT is set to 1, FREM and FMOD use a faster version
153 with only 3 quotient bits (those provided by the x86 FPU). If set to 0,
154 they calculate the same 7 bits that m68k does. It seems (as for now) that
155 3 bits suffice for all Mac programs I have tried.
156
157 If you decide that you need all 7 bits (USE_3_BIT_QUOTIENT is 0),
158 consider checking the host exception flags after FISTP (search for
159 "TODO:Quotient". The result may be too large to fit into a dword.
160 */
161 /*
162 gb-- I only tested the following configurations:
163 USE_3_BIT_QUOTIENT 1 -- still changes to apply if no 3-bit quotient
164 DEBUG 1 or 0
165 USE_CONSISTENCY_CHECKING 0
166 I3_ON_ILLEGAL_FPU_OP 0 -- and this won't change
167 I3_ON_FTRAPCC 0 -- and this won't change
168 */
169 #define USE_3_BIT_QUOTIENT 1
170
171 #define DEBUG 0
172 #define USE_CONSISTENCY_CHECKING 0
173
174 #define I3_ON_ILLEGAL_FPU_OP 0
175 #define I3_ON_FTRAPCC 0
176
177
178 /* ---------------------------- Registers ---------------------------- */
179
180 // "regs.fp" is not used. regs.fpcr, regs.fpsr and regs.fpiar are used.
181
182 typedef BYTE *float80;
183 typedef BYTE float80_s[10];
184 typedef BYTE float80_s_aligned[16];
185
186 static float80_s_aligned fp_reg[8];
187
188
189 /* ---------------------------- Debugging ---------------------------- */
190
191 #if DEBUG
192 //#pragma optimize("",off)
193 #endif
194
195 // extern "C" {int debugging_fpp = 0;}
196
197 #include "debug.h"
198
199 #if DEBUG
200 #undef __inline__
201 #define __inline__
202 //#undef D
203 //#define D(x) { if(debugging_fpp) { (x); } }
204
205 static void dump_first_bytes_buf( char *b, BYTE *buf, int32 actual )
206 {
207 char bb[10];
208 int32 i, bytes = min(actual,100);
209
210 *b = 0;
211 for (i=0; i<bytes; i++) {
212 sprintf( bb, "%02x ", (uint32)buf[i] );
213 strcat( b, bb );
214 }
215 strcat((char*)b,"\r\n");
216 }
217
218 static void dump_first_bytes( BYTE *buf, int32 actual )
219 {
220 char msg[256];
221 dump_first_bytes_buf( msg, buf, actual );
222 D(bug("%s\n", msg));
223 }
224
225 #define CONDRET(s,x) D(bug("fpp_cond %s = %d\r\n",s,(uint32)(x))); return (x)
226 static char * etos( float80 e ) REGPARAM;
227 static char * etos( float80 e )
228 {
229 static char _s[10][30];
230 static int _ix = 0;
231 float f;
232
233 /* _asm {
234 MOV EDI, [e]
235 FLD TBYTE PTR [EDI]
236 FSTP DWORD PTR f
237 } */
238
239 _ASM( "fldt %1\n"
240 "fstp %0\n"
241 : "=m" (f)
242 : "m" (*e)
243 );
244
245 if(++_ix >= 10) _ix = 0;
246
247 sprintf( _s[_ix], "%.04f", (float)f );
248 return( _s[_ix] );
249 }
250 static void dump_fp_regs( char *s )
251 {
252 char b[512];
253
254 sprintf(
255 b,
256 "%s: %s, %s, %s, %s, %s, %s, %s, %s\r\n",
257 s,
258 etos(fp_reg[0]),
259 etos(fp_reg[1]),
260 etos(fp_reg[2]),
261 etos(fp_reg[3]),
262 etos(fp_reg[4]),
263 etos(fp_reg[5]),
264 etos(fp_reg[6]),
265 etos(fp_reg[7])
266 );
267 D(bug((char*)b));
268 }
269
270 #else
271 #define CONDRET(s,x) return (x)
272 #define dump_fp_regs(s) {}
273 #endif
274
275
276 /* ---------------------------- FPU consistency ---------------------------- */
277
278 #if USE_CONSISTENCY_CHECKING
279 static uae_u16 checked_sw_atstart;
280
281 static void FPU_CONSISTENCY_CHECK_START()
282 {
283 /* _asm {
284 FNSTSW checked_sw_atstart
285 } */
286 _ASM("fnstsw %0" : "=m" (checked_sw_atstart));
287 }
288
289 static void FPU_CONSISTENCY_CHECK_STOP(char *name)
290 {
291 uae_u16 checked_sw_atend;
292 // _asm FNSTSW checked_sw_atend
293 _ASM("fnstsw %0" : "=m" (checked_sw_attend));
294 char msg[256];
295
296 // Check for FPU stack overflows/underflows.
297 if( (checked_sw_atend & 0x3800) != (checked_sw_atstart & 0x3800) ) {
298 wsprintf(
299 msg,
300 "FPU stack leak at %s, %X, %X\r\n",
301 name,
302 (int)(checked_sw_atstart & 0x3800) >> 11,
303 (int)(checked_sw_atend & 0x3800) >> 11
304 );
305 OutputDebugString(msg);
306 }
307
308 // Observe status mapping.
309 /*
310 if(checked_sw_atstart != 0x400 || checked_sw_atend != 0x400) {
311 wsprintf(
312 msg, "Op %s, sw before=%X, sw after=%X\r\n",
313 name, (int)checked_sw_atstart, (int)checked_sw_atend
314 );
315 OutputDebugString(msg);
316 }
317 */
318 }
319 #else
320 #define FPU_CONSISTENCY_CHECK_START()
321 #define FPU_CONSISTENCY_CHECK_STOP(name)
322 #endif
323
324
325 /* ---------------------------- FPU type ---------------------------- */
326
327 static uae_u32 is_integral_68040_fpu = 0;
328
329
330 /* ---------------------------- Status byte ---------------------------- */
331
332 // Extend the SW_* codes
333 #define SW_FAKE_BSUN SW_SF
334
335 // Shorthand
336 #define SW_EXCEPTION_MASK (SW_ES|SW_SF|SW_PE|SW_UE|SW_OE|SW_ZE|SW_DE|SW_IE)
337 // #define SW_EXCEPTION_MASK (SW_SF|SW_PE|SW_UE|SW_OE|SW_ZE|SW_DE|SW_IE)
338
339 // Map x86 FXAM codes -> m68k fpu status byte
340 #define SW_Z_I_NAN_MASK (SW_C0|SW_C2|SW_C3)
341 #define SW_Z (SW_C3)
342 #define SW_I (SW_C0|SW_C2)
343 #define SW_NAN (SW_C0)
344 #define SW_FINITE (SW_C2)
345 #define SW_EMPTY_REGISTER (SW_C0|SW_C3)
346 #define SW_DENORMAL (SW_C2|SW_C3)
347 #define SW_UNSUPPORTED (0)
348 #define SW_N (SW_C1)
349
350 // Initial state after boot, reset and frestore(null frame)
351 #define SW_INITIAL SW_FINITE
352
353 // These hold the contents of the fpsr, in Intel values.
354 static DWORD sw = SW_INITIAL;
355 static DWORD sw_accrued = 0;
356 static DWORD sw_quotient = 0;
357
358
359 /* ---------------------------- Control word ---------------------------- */
360
361 // Initial state after boot, reset and frestore(null frame)
362 #define CW_INITIAL (CW_RESET|CW_X|CW_PC_EXTENDED|CW_RC_NEAR|CW_PM|CW_UM|CW_OM|CW_ZM|CW_DM|CW_IM)
363
364 static WORD cw = CW_INITIAL;
365
366
367 /* ---------------------------- FMOVECR constants ---------------------------- */
368
369 static float80_s
370 // Suported by x86 FPU
371 const_pi,
372 const_lg2,
373 const_l2e,
374 const_z,
375 const_ln2,
376 const_1,
377
378 // Not suported by x86 FPU
379 const_e,
380 const_log_10_e,
381 const_ln_10,
382 const_1e1,
383 const_1e2,
384 const_1e4,
385 const_1e8,
386 const_1e16,
387 const_1e32,
388 const_1e64,
389 const_1e128,
390 const_1e256,
391 const_1e512,
392 const_1e1024,
393 const_1e2048,
394 const_1e4096;
395
396
397 /* ---------------------------- Saved host FPU state ---------------------------- */
398
399 static BYTE m_fpu_state_original[108]; // 90/94/108
400
401
402 /* ---------------------------- Map tables ---------------------------- */
403
404 typedef void REGPARAM2 fpuop_func( uae_u32, uae_u16 );
405 extern "C" { fpuop_func *fpufunctbl[65536]; }
406
407 // Control word -- need only one-way mapping
408 static const uae_u16 cw_rc_mac2host[] = {
409 CW_RC_NEAR,
410 CW_RC_ZERO,
411 CW_RC_DOWN,
412 CW_RC_UP
413 };
414 static const uae_u16 cw_pc_mac2host[] = {
415 CW_PC_EXTENDED,
416 CW_PC_SINGLE,
417 CW_PC_DOUBLE,
418 CW_PC_RESERVED
419 };
420
421 // Status word -- need two-way mapping
422 static uae_u32 sw_cond_host2mac[ 0x48 ];
423 static uae_u16 sw_cond_mac2host[ 16 ];
424
425 static uae_u32 exception_host2mac[ 0x80 ];
426 static uae_u32 exception_mac2host[ 0x100 ];
427
428 static uae_u32 accrued_exception_host2mac[ 0x40 ];
429 static uae_u32 accrued_exception_mac2host[ 0x20 ];
430
431
432 /* ---------------------------- Control functions ---------------------------- */
433
434 /*
435 Exception enable byte is ignored, but the same value is returned
436 that was previously set.
437 */
438 static void __inline__ set_host_fpu_control_word()
439 {
440 cw = (cw & ~(X86_ROUND_CONTROL_MASK|X86_PRECISION_CONTROL_MASK)) |
441 cw_rc_mac2host[ (regs.fpcr & ROUND_CONTROL_MASK) >> 4 ] |
442 cw_pc_mac2host[ (regs.fpcr & PRECISION_CONTROL_MASK) >> 6 ];
443
444 // Writing to control register is very slow (no register renaming on
445 // ppro++, and most of all, it's one of those serializing commands).
446 /* _asm {
447 FLDCW cw
448 } */
449 _ASM("fldcw %0" : : "m" (cw));
450 }
451
452
453 /* ---------------------------- Status functions ---------------------------- */
454
455 static void __inline__ SET_BSUN_ON_NAN()
456 {
457 if( (sw & (SW_Z_I_NAN_MASK)) == SW_NAN ) {
458 sw |= SW_FAKE_BSUN;
459 sw_accrued |= SW_IE;
460 }
461 }
462
463 static void __inline__ build_ex_status()
464 {
465 if(sw & SW_EXCEPTION_MASK) {
466 // _asm FNCLEX
467 _ASM("fnclex");
468 sw_accrued |= sw;
469 }
470 }
471
472 static void __inline__ to_fpsr()
473 {
474 regs.fpsr =
475 sw_cond_host2mac[ (sw & 0x4700) >> 8 ] |
476 sw_quotient |
477 exception_host2mac[ sw & (SW_FAKE_BSUN|SW_PE|SW_UE|SW_OE|SW_ZE|SW_DE|SW_IE) ] |
478 accrued_exception_host2mac[ sw_accrued & (SW_PE|SW_UE|SW_OE|SW_ZE|SW_DE|SW_IE) ]
479 ;
480 }
481
482 static void __inline__ from_fpsr()
483 {
484 sw =
485 sw_cond_mac2host[ (regs.fpsr & 0x0F000000) >> 24 ] |
486 exception_mac2host[ (regs.fpsr & 0x0000FF00) >> 8 ];
487 sw_quotient = regs.fpsr & 0x00FF0000;
488 sw_accrued = accrued_exception_mac2host[ (regs.fpsr & 0xF8) >> 3 ];
489 }
490
491
492 // TODO_BIGENDIAN; all of these.
493 /* ---------------------------- Type functions ---------------------------- */
494
495 /*
496 When the FPU creates a NAN, the NAN always contains the same bit pattern
497 in the mantissa. All bits of the mantissa are ones for any precision.
498 When the user creates a NAN, any nonzero bit pattern can be stored in the mantissa.
499 */
500 static __inline__ void MAKE_NAN(float80 p)
501 {
502 // Make it non-signaling.
503 memset( p, 0xFF, sizeof(float80_s)-1 );
504 p[9] = 0x7F;
505 }
506
507 /*
508 For single- and double-precision infinities the fraction is a zero.
509 For extended-precision infinities, the mantissa’s MSB, the explicit
510 integer bit, can be either one or zero.
511 */
512 static __inline__ uae_u32 IS_INFINITY(float80 p)
513 {
514 if( ((p[9] & 0x7F) == 0x7F) && p[8] == 0xFF ) {
515 if( *((uae_u32 *)p) == 0 &&
516 ( *((uae_u32 *)&p[4]) & 0x7FFFFFFF ) == 0 )
517 {
518 return(1);
519 }
520 }
521 return(0);
522 }
523
524 static __inline__ uae_u32 IS_NAN(float80 p)
525 {
526 if( ((p[9] & 0x7F) == 0x7F) && p[8] == 0xFF ) {
527 if( *((uae_u32 *)p) != 0 ||
528 ( *((uae_u32 *)&p[4]) & 0x7FFFFFFF ) != 0 )
529 {
530 return(1);
531 }
532 }
533 return(0);
534 }
535
536 static __inline__ uae_u32 IS_ZERO(float80 p)
537 {
538 return *((uae_u32 *)p) == 0 &&
539 *((uae_u32 *)&p[4]) == 0 &&
540 ( *((uae_u16 *)&p[8]) & 0x7FFF ) == 0;
541 }
542
543 static __inline__ void MAKE_INF_POSITIVE(float80 p)
544 {
545 memset( p, 0, sizeof(float80_s)-2 );
546 *((uae_u16 *)&p[8]) = 0x7FFF;
547 }
548
549 static __inline__ void MAKE_INF_NEGATIVE(float80 p)
550 {
551 memset( p, 0, sizeof(float80_s)-2 );
552 *((uae_u16 *)&p[8]) = 0xFFFF;
553 }
554
555 static __inline__ void MAKE_ZERO_POSITIVE(float80 p)
556 {
557 memset( p, 0, sizeof(float80_s) );
558 }
559
560 static __inline__ void MAKE_ZERO_NEGATIVE(float80 *p)
561 {
562 memset( p, 0, sizeof(float80_s) );
563 *((uae_u32 *)&p[4]) = 0x80000000;
564 }
565
566 static __inline__ uae_u32 IS_NEGATIVE(float80 p)
567 {
568 return( (p[9] & 0x80) != 0 );
569 }
570
571
572 /* ---------------------------- Conversions ---------------------------- */
573
574 static void signed_to_extended( uae_s32 x, float80 f ) REGPARAM;
575 static void signed_to_extended( uae_s32 x, float80 f )
576 {
577 FPU_CONSISTENCY_CHECK_START();
578
579 /* _asm {
580 MOV ESI, [f]
581 FILD DWORD PTR [x]
582 FSTP TBYTE PTR [ESI]
583 } */
584
585 _ASM( "fildl %1\n"
586 "fstpt %0\n"
587 : "=m" (*f)
588 : "m" (x)
589 );
590
591 D(bug("signed_to_extended (%X) = %s\r\n",(int)x,etos(f)));
592 FPU_CONSISTENCY_CHECK_STOP("signed_to_extended");
593 }
594
595 static uae_s32 extended_to_signed_32( float80 f ) REGPARAM;
596 static uae_s32 extended_to_signed_32( float80 f )
597 {
598 FPU_CONSISTENCY_CHECK_START();
599 uae_s32 tmp;
600 WORD sw_temp;
601
602 /* _asm {
603 MOV EDI, [f]
604 FLD TBYTE PTR [EDI]
605 FISTP DWORD PTR tmp
606 FNSTSW sw_temp
607 } */
608
609 _ASM( "fldt %2\n"
610 "fistpl %0\n"
611 "fnstsw %1\n"
612 : "=m" (tmp), "=m" (sw_temp)
613 : "m" (*f)
614 );
615
616 if(sw_temp & SW_EXCEPTION_MASK) {
617 // _asm FNCLEX
618 _ASM("fnclex");
619 if(sw_temp & (SW_OE|SW_UE|SW_DE|SW_IE)) { // Map SW_OE to OPERR.
620 sw |= SW_IE;
621 sw_accrued |= SW_IE;
622 // Setting the value to zero might not be the right way to go,
623 // but I'll leave it like this for now.
624 tmp = 0;
625 }
626 if(sw_temp & SW_PE) {
627 sw |= SW_PE;
628 sw_accrued |= SW_PE;
629 }
630 }
631
632 D(bug("extended_to_signed_32 (%s) = %X\r\n",etos(f),(int)tmp));
633 FPU_CONSISTENCY_CHECK_STOP("extended_to_signed_32");
634 return tmp;
635 }
636
637 static uae_s16 extended_to_signed_16( float80 f ) REGPARAM;
638 static uae_s16 extended_to_signed_16( float80 f )
639 {
640 FPU_CONSISTENCY_CHECK_START();
641 uae_s16 tmp;
642 WORD sw_temp;
643
644 /* _asm {
645 MOV EDI, [f]
646 FLD TBYTE PTR [EDI]
647 FISTP WORD PTR tmp
648 FNSTSW sw_temp
649 } */
650
651 _ASM( "fldt %2\n"
652 "fistp %0\n"
653 "fnstsw %1\n"
654 : "=m" (tmp), "=m" (sw_temp)
655 : "m" (*f)
656 );
657
658 if(sw_temp & SW_EXCEPTION_MASK) {
659 // _asm FNCLEX
660 _ASM("fnclex");
661 if(sw_temp & (SW_OE|SW_UE|SW_DE|SW_IE)) { // Map SW_OE to OPERR.
662 sw |= SW_IE;
663 sw_accrued |= SW_IE;
664 tmp = 0;
665 }
666 if(sw_temp & SW_PE) {
667 sw |= SW_PE;
668 sw_accrued |= SW_PE;
669 }
670 }
671
672 D(bug("extended_to_signed_16 (%s) = %X\r\n",etos(f),(int)tmp));
673 FPU_CONSISTENCY_CHECK_STOP("extended_to_signed_16");
674 return tmp;
675 }
676
677 static uae_s8 extended_to_signed_8( float80 f ) REGPARAM;
678 static uae_s8 extended_to_signed_8( float80 f )
679 {
680 FPU_CONSISTENCY_CHECK_START();
681 uae_s16 tmp;
682 WORD sw_temp;
683
684 /* _asm {
685 MOV EDI, [f]
686 FLD TBYTE PTR [EDI]
687 FISTP WORD PTR tmp
688 FNSTSW sw_temp
689 } */
690
691 _ASM( "fldt %2\n"
692 "fistp %0\n"
693 "fnstsw %1\n"
694 : "=m" (tmp), "=m" (sw_temp)
695 : "m" (*f)
696 );
697
698 if(sw_temp & SW_EXCEPTION_MASK) {
699 // _asm FNCLEX
700 _ASM("fnclex");
701 if(sw_temp & (SW_OE|SW_UE|SW_DE|SW_IE)) { // Map SW_OE to OPERR.
702 sw |= SW_IE;
703 sw_accrued |= SW_IE;
704 tmp = 0;
705 }
706 if(sw_temp & SW_PE) {
707 sw |= SW_PE;
708 sw_accrued |= SW_PE;
709 }
710 }
711
712 if(tmp > 127 || tmp < -128) { // OPERR
713 sw |= SW_IE;
714 sw_accrued |= SW_IE;
715 }
716
717 D(bug("extended_to_signed_8 (%s) = %X\r\n",etos(f),(int)tmp));
718 FPU_CONSISTENCY_CHECK_STOP("extended_to_signed_8");
719 return (uae_s8)tmp;
720 }
721
722 static void double_to_extended( double x, float80 f ) REGPARAM;
723 static void double_to_extended( double x, float80 f )
724 {
725 FPU_CONSISTENCY_CHECK_START();
726
727 /* _asm {
728 MOV EDI, [f]
729 FLD QWORD PTR [x]
730 FSTP TBYTE PTR [EDI]
731 } */
732
733 _ASM( "fldl %1\n"
734 "fstpt %0\n"
735 : "=m" (*f)
736 : "m" (x)
737 );
738
739 FPU_CONSISTENCY_CHECK_STOP("double_to_extended");
740 }
741
742 static double extended_to_double( float80 f ) REGPARAM;
743 static double extended_to_double( float80 f )
744 {
745 FPU_CONSISTENCY_CHECK_START();
746 double result;
747
748 /* _asm {
749 MOV ESI, [f]
750 FLD TBYTE PTR [ESI]
751 FSTP QWORD PTR result
752 } */
753
754 _ASM( "fldt %1\n"
755 "fstpl %0\n"
756 : "=m" (result)
757 : "m" (*f)
758 );
759
760 FPU_CONSISTENCY_CHECK_STOP("extended_to_double");
761 return result;
762 }
763
764 static void to_single( uae_u32 src, float80 f ) REGPARAM;
765 static void to_single( uae_u32 src, float80 f )
766 {
767 FPU_CONSISTENCY_CHECK_START();
768 /* _asm {
769 MOV ESI, [f]
770 FLD DWORD PTR src
771 FSTP TBYTE PTR [ESI]
772 } */
773
774 _ASM( "flds %1\n"
775 "fstpt %0\n"
776 : "=m" (*f)
777 : "m" (src)
778 );
779
780 D(bug("to_single (%X) = %s\r\n",src,etos(f)));
781 FPU_CONSISTENCY_CHECK_STOP("to_single");
782 }
783
784 // TODO_BIGENDIAN
785 static void to_exten_no_normalize( uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3, float80 f ) REGPARAM;
786 static void to_exten_no_normalize( uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3, float80 f )
787 {
788 FPU_CONSISTENCY_CHECK_START();
789 uae_u32 *p = (uae_u32 *)f;
790
791 uae_u32 sign = (wrd1 & 0x80000000) >> 16;
792 uae_u32 exp = (wrd1 >> 16) & 0x7fff;
793 p[0] = wrd3;
794 p[1] = wrd2;
795 *((uae_u16 *)&p[2]) = (uae_u16)(sign | exp);
796
797 D(bug("to_exten_no_normalize (%X,%X,%X) = %s\r\n",wrd1,wrd2,wrd3,etos(f)));
798 FPU_CONSISTENCY_CHECK_STOP("to_exten_no_normalize");
799 }
800
801 static void to_exten( uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3, float80 f ) REGPARAM;
802 static void to_exten( uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3, float80 f )
803 {
804 FPU_CONSISTENCY_CHECK_START();
805 uae_u32 *p = (uae_u32 *)f;
806
807 uae_u32 sign = (wrd1 & 0x80000000) >> 16;
808 uae_u32 exp = (wrd1 >> 16) & 0x7fff;
809
810 // The explicit integer bit is not set, must normalize.
811 // Don't do it for zeroes, infinities or nans.
812 if( (wrd2 & 0x80000000) == 0 && exp != 0 && exp != 0x7FFF ) {
813 D(bug("to_exten denormalized mantissa (%X,%X,%X)\r\n",wrd1,wrd2,wrd3));
814 if( wrd2 | wrd3 ) {
815 // mantissa, not fraction.
816 uae_u64 man = ((uae_u64)wrd2 << 32) | wrd3;
817 while( exp > 0 && (man & UVAL64(0x8000000000000000)) == 0 ) {
818 man <<= 1;
819 exp--;
820 }
821 wrd2 = (uae_u32)( man >> 32 );
822 wrd3 = (uae_u32)( man & 0xFFFFFFFF );
823 if( exp == 0 || (wrd2 & 0x80000000) == 0 ) {
824 // underflow
825 wrd2 = wrd3 = exp = 0;
826 sign = 0;
827 }
828 } else {
829 if(exp != 0x7FFF && exp != 0) {
830 // Make a non-signaling nan.
831 exp = 0x7FFF;
832 sign = 0;
833 wrd2 = 0x80000000;
834 }
835 }
836 }
837
838 p[0] = wrd3;
839 p[1] = wrd2;
840 *((uae_u16 *)&p[2]) = (uae_u16)(sign | exp);
841
842 D(bug("to_exten (%X,%X,%X) = %s\r\n",wrd1,wrd2,wrd3,etos(f)));
843 FPU_CONSISTENCY_CHECK_STOP("to_exten");
844 }
845
846 static void to_double( uae_u32 wrd1, uae_u32 wrd2, float80 f ) REGPARAM;
847 static void to_double( uae_u32 wrd1, uae_u32 wrd2, float80 f )
848 {
849 FPU_CONSISTENCY_CHECK_START();
850
851 // gb-- make GCC happy
852 union {
853 uae_u64 q;
854 uae_u32 l[2];
855 } src;
856
857 // Should renormalize if needed. I'm not sure that x86 and m68k FPU's
858 // do it the sama way. This should be extremely rare however.
859 // to_exten() is often called with denormalized values.
860
861 src.l[0] = wrd2;
862 src.l[1] = wrd1;
863
864 /* _asm {
865 FLD QWORD PTR src
866 MOV EDI, [f]
867 FSTP TBYTE PTR [EDI]
868 } */
869
870 _ASM( "fldl %1\n"
871 "fstpt %0\n"
872 : "=m" (*f)
873 : "m" (src.q)
874 );
875
876 D(bug("to_double (%X,%X) = %s\r\n",wrd1,wrd2,etos(f)));
877 FPU_CONSISTENCY_CHECK_STOP("to_double");
878 }
879
880 static uae_u32 from_single( float80 f ) REGPARAM;
881 static uae_u32 from_single( float80 f )
882 {
883 FPU_CONSISTENCY_CHECK_START();
884 uae_u32 dest;
885 WORD sw_temp;
886
887 /* _asm {
888 MOV EDI, [f]
889 FLD TBYTE PTR [EDI]
890 FSTP DWORD PTR dest
891 FNSTSW sw_temp
892 } */
893
894 _ASM( "fldt %2\n"
895 "fstps %0\n"
896 "fnstsw %1\n"
897 : "=m" (dest), "=m" (sw_temp)
898 : "m" (*f)
899 );
900
901 sw_temp &= SW_EXCEPTION_MASK;
902 if(sw_temp) {
903 // _asm FNCLEX
904 asm("fnclex");
905 sw = (sw & ~SW_EXCEPTION_MASK) | sw_temp;
906 sw_accrued |= sw_temp;
907 }
908
909 D(bug("from_single (%s) = %X\r\n",etos(f),dest));
910 FPU_CONSISTENCY_CHECK_STOP("from_single");
911 return dest;
912 }
913
914 // TODO_BIGENDIAN
915 static void from_exten( float80 f, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3 ) REGPARAM;
916 static void from_exten( float80 f, uae_u32 *wrd1, uae_u32 *wrd2, uae_u32 *wrd3 )
917 {
918 FPU_CONSISTENCY_CHECK_START();
919 uae_u32 *p = (uae_u32 *)f;
920 *wrd3 = p[0];
921 *wrd2 = p[1];
922 *wrd1 = ( (uae_u32)*((uae_u16 *)&p[2]) ) << 16;
923
924 D(bug("from_exten (%s) = %X,%X,%X\r\n",etos(f),*wrd1,*wrd2,*wrd3));
925 FPU_CONSISTENCY_CHECK_STOP("from_exten");
926 }
927
928 static void from_double( float80 f, uae_u32 *wrd1, uae_u32 *wrd2 ) REGPARAM;
929 static void from_double( float80 f, uae_u32 *wrd1, uae_u32 *wrd2 )
930 {
931 FPU_CONSISTENCY_CHECK_START();
932 uae_u32 dest[2];
933 WORD sw_temp;
934
935 /* _asm {
936 MOV EDI, [f]
937 FLD TBYTE PTR [EDI]
938 FSTP QWORD PTR dest
939 FNSTSW sw_temp
940 } */
941
942 _ASM( "fldt %2\n"
943 "fstpl %0\n"
944 "fnstsw %1\n"
945 : "=m" (dest), "=m" (sw_temp)
946 : "m" (*f)
947 );
948
949 sw_temp &= SW_EXCEPTION_MASK;
950 if(sw_temp) {
951 // _asm FNCLEX
952 asm("fnclex");
953 sw = (sw & ~SW_EXCEPTION_MASK) | sw_temp;
954 sw_accrued |= sw_temp;
955 }
956
957 // TODO: There is a partial memory stall, nothing happens until FSTP retires.
958 // On PIII, could use MMX move w/o any penalty.
959 *wrd2 = dest[0];
960 *wrd1 = dest[1];
961
962 D(bug("from_double (%s) = %X,%X\r\n",etos(f),dest[1],dest[0]));
963 FPU_CONSISTENCY_CHECK_STOP("from_double");
964 }
965
966 static void do_fmove( float80 dest, float80 src ) REGPARAM;
967 static void do_fmove( float80 dest, float80 src )
968 {
969 FPU_CONSISTENCY_CHECK_START();
970 /* _asm {
971 MOV ESI, [src]
972 MOV EDI, [dest]
973 FLD TBYTE PTR [ESI]
974 FXAM
975 FNSTSW sw
976 FSTP TBYTE PTR [EDI]
977 } */
978
979 _ASM( "fldt %2\n"
980 "fxam \n"
981 "fnstsw %0\n"
982 "fstpt %1\n"
983 : "=m" (sw), "=m" (*dest)
984 : "m" (*src)
985 );
986 FPU_CONSISTENCY_CHECK_STOP("do_fmove");
987 }
988
989 /*
990 static void do_fmove_no_status( float80 dest, float80 src ) REGPARAM;
991 static void do_fmove_no_status( float80 dest, float80 src )
992 {
993 FPU_CONSISTENCY_CHECK_START();
994 _asm {
995 MOV ESI, [src]
996 MOV EDI, [dest]
997 FLD TBYTE PTR [ESI]
998 FSTP TBYTE PTR [EDI]
999 }
1000 FPU_CONSISTENCY_CHECK_STOP("do_fmove_no_status");
1001 }
1002 */
1003
1004
1005 /* ---------------------------- Operations ---------------------------- */
1006
1007 static void do_fint( float80 dest, float80 src ) REGPARAM;
1008 static void do_fint( float80 dest, float80 src )
1009 {
1010 FPU_CONSISTENCY_CHECK_START();
1011 /* _asm {
1012 MOV ESI, [src]
1013 MOV EDI, [dest]
1014 FLD TBYTE PTR [ESI]
1015 FRNDINT
1016 FXAM
1017 FNSTSW sw
1018 FSTP TBYTE PTR [EDI]
1019 } */
1020 _ASM( "fldt %2\n"
1021 "frndint\n"
1022 "fxam \n"
1023 "fnstsw %0\n"
1024 "fstpt %1\n"
1025 : "=m" (sw), "=m" (*dest)
1026 : "m" (*src)
1027 );
1028 if(sw & SW_EXCEPTION_MASK) {
1029 // _asm FNCLEX
1030 _ASM("fnclex");
1031 sw &= ~(SW_EXCEPTION_MASK - SW_PE);
1032 sw_accrued |= sw;
1033 }
1034 FPU_CONSISTENCY_CHECK_STOP("do_fint");
1035 }
1036
1037 static void do_fintrz( float80 dest, float80 src ) REGPARAM;
1038 static void do_fintrz( float80 dest, float80 src )
1039 {
1040 FPU_CONSISTENCY_CHECK_START();
1041 WORD cw_temp;
1042
1043 /* _asm {
1044 MOV ESI, [src]
1045 MOV EDI, [dest]
1046 FSTCW cw_temp
1047 and cw_temp, ~X86_ROUND_CONTROL_MASK
1048 or cw_temp, CW_RC_ZERO
1049 FLDCW cw_temp
1050 FLD TBYTE PTR [ESI]
1051 FRNDINT
1052 FXAM
1053 FNSTSW sw
1054 FLDCW cw
1055 FSTP TBYTE PTR [EDI]
1056 } */
1057
1058 _ASM( "fstcw %0\n"
1059 "andl $(~X86_ROUND_CONTROL_MASK), %0\n"
1060 "orl $CW_RC_ZERO, %0\n"
1061 "fldcw %0\n"
1062 "fldt %3\n"
1063 "frndint\n"
1064 "fxam \n"
1065 "fnstsw %1\n"
1066 "fldcw %4\n"
1067 "fstpt %2\n"
1068 : "+m" (cw_temp), "=m" (sw), "=m" (*dest)
1069 : "m" (*src), "m" (cw)
1070 );
1071
1072 if(sw & SW_EXCEPTION_MASK) {
1073 // _asm FNCLEX
1074 _ASM("fnclex");
1075 sw &= ~(SW_EXCEPTION_MASK - SW_PE);
1076 sw_accrued |= sw;
1077 }
1078 FPU_CONSISTENCY_CHECK_STOP("do_fintrz");
1079 }
1080
1081 static void do_fsqrt( float80 dest, float80 src ) REGPARAM;
1082 static void do_fsqrt( float80 dest, float80 src )
1083 {
1084 FPU_CONSISTENCY_CHECK_START();
1085 /* _asm {
1086 MOV ESI, [src]
1087 MOV EDI, [dest]
1088 FLD TBYTE PTR [ESI]
1089 FSQRT
1090 FXAM
1091 FNSTSW sw
1092 FSTP TBYTE PTR [EDI]
1093 } */
1094
1095 _ASM( "fldt %2\n"
1096 "fsqrt \n"
1097 "fxam \n"
1098 "fnstsw %0\n"
1099 "fstpt %1\n"
1100 : "=m" (sw), "=m" (*dest)
1101 : "m" (*src)
1102 );
1103
1104 if(sw & SW_EXCEPTION_MASK) {
1105 // _asm FNCLEX
1106 _ASM("fnclex");
1107 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_PE);
1108 sw_accrued |= sw;
1109 }
1110 FPU_CONSISTENCY_CHECK_STOP("do_fsqrt");
1111 }
1112
1113 static void do_ftst( float80 src ) REGPARAM;
1114 static void do_ftst( float80 src )
1115 {
1116 FPU_CONSISTENCY_CHECK_START();
1117 /* _asm {
1118 MOV ESI, [src]
1119 FLD TBYTE PTR [ESI]
1120 FXAM
1121 FNSTSW sw
1122 FSTP ST(0)
1123 } */
1124
1125 _ASM( "fldt %1\n"
1126 "fxam \n"
1127 "fnstsw %0\n"
1128 "fstp %%st(0)\n"
1129 : "=m" (sw)
1130 : "m" (*src)
1131 );
1132
1133 if(sw & SW_EXCEPTION_MASK) {
1134 // _asm FNCLEX
1135 _ASM("fnclex");
1136 sw &= ~SW_EXCEPTION_MASK;
1137 }
1138 FPU_CONSISTENCY_CHECK_STOP("do_ftst");
1139 }
1140
1141 // These functions are calculated in 53 bits accuracy only.
1142 // Exception checking is not complete.
1143 static void do_fsinh( float80 dest, float80 src ) REGPARAM;
1144 static void do_fsinh( float80 dest, float80 src )
1145 {
1146 FPU_CONSISTENCY_CHECK_START();
1147 double x, y;
1148 x = extended_to_double( src );
1149 y = sinh(x);
1150 double_to_extended( y, dest );
1151 do_ftst( dest );
1152 FPU_CONSISTENCY_CHECK_STOP("do_fsinh");
1153 }
1154
1155 static void do_flognp1( float80 dest, float80 src ) REGPARAM;
1156 static void do_flognp1( float80 dest, float80 src )
1157 {
1158 FPU_CONSISTENCY_CHECK_START();
1159 double x, y;
1160 x = extended_to_double( src );
1161 y = log (x + 1.0);
1162 double_to_extended( y, dest );
1163 do_ftst( dest );
1164 FPU_CONSISTENCY_CHECK_STOP("do_flognp1");
1165 }
1166
1167 static void do_fetoxm1( float80 dest, float80 src ) REGPARAM;
1168 static void do_fetoxm1( float80 dest, float80 src )
1169 {
1170 FPU_CONSISTENCY_CHECK_START();
1171 double x, y;
1172 x = extended_to_double( src );
1173 y = exp (x) - 1.0;
1174 double_to_extended( y, dest );
1175 do_ftst( dest );
1176 FPU_CONSISTENCY_CHECK_STOP("do_fetoxm1");
1177 }
1178
1179 static void do_ftanh( float80 dest, float80 src ) REGPARAM;
1180 static void do_ftanh( float80 dest, float80 src )
1181 {
1182 FPU_CONSISTENCY_CHECK_START();
1183 double x, y;
1184 x = extended_to_double( src );
1185 y = tanh (x);
1186 double_to_extended( y, dest );
1187 do_ftst( dest );
1188 FPU_CONSISTENCY_CHECK_STOP("do_ftanh");
1189 }
1190
1191 static void do_fatan( float80 dest, float80 src ) REGPARAM;
1192 static void do_fatan( float80 dest, float80 src )
1193 {
1194 FPU_CONSISTENCY_CHECK_START();
1195 double x, y;
1196 x = extended_to_double( src );
1197 y = atan (x);
1198 double_to_extended( y, dest );
1199 do_ftst( dest );
1200 FPU_CONSISTENCY_CHECK_STOP("do_fatan");
1201 }
1202
1203 static void do_fasin( float80 dest, float80 src ) REGPARAM;
1204 static void do_fasin( float80 dest, float80 src )
1205 {
1206 FPU_CONSISTENCY_CHECK_START();
1207 double x, y;
1208 x = extended_to_double( src );
1209 y = asin (x);
1210 double_to_extended( y, dest );
1211 do_ftst( dest );
1212 FPU_CONSISTENCY_CHECK_STOP("do_fasin");
1213 }
1214
1215 static void do_fatanh( float80 dest, float80 src ) REGPARAM;
1216 static void do_fatanh( float80 dest, float80 src )
1217 {
1218 FPU_CONSISTENCY_CHECK_START();
1219 double x, y;
1220 x = extended_to_double( src );
1221 y = log ((1 + x) / (1 - x)) / 2;
1222 double_to_extended( y, dest );
1223 do_ftst( dest );
1224 FPU_CONSISTENCY_CHECK_STOP("do_fatanh");
1225 }
1226
1227 static void do_fetox( float80 dest, float80 src ) REGPARAM;
1228 static void do_fetox( float80 dest, float80 src )
1229 {
1230 FPU_CONSISTENCY_CHECK_START();
1231 double x, y;
1232 x = extended_to_double( src );
1233 y = exp (x);
1234 double_to_extended( y, dest );
1235 do_ftst( dest );
1236 FPU_CONSISTENCY_CHECK_STOP("do_fetox");
1237 }
1238
1239 static void do_ftwotox( float80 dest, float80 src ) REGPARAM;
1240 static void do_ftwotox( float80 dest, float80 src )
1241 {
1242 FPU_CONSISTENCY_CHECK_START();
1243 double x, y;
1244 x = extended_to_double( src );
1245 y = pow(2.0, x);
1246 double_to_extended( y, dest );
1247 do_ftst( dest );
1248 FPU_CONSISTENCY_CHECK_STOP("do_ftwotox");
1249 }
1250
1251 static void do_ftentox( float80 dest, float80 src ) REGPARAM;
1252 static void do_ftentox( float80 dest, float80 src )
1253 {
1254 FPU_CONSISTENCY_CHECK_START();
1255 double x, y;
1256 x = extended_to_double( src );
1257 y = pow(10.0, x);
1258 double_to_extended( y, dest );
1259 do_ftst( dest );
1260 FPU_CONSISTENCY_CHECK_STOP("do_ftentox");
1261 }
1262
1263 static void do_flogn( float80 dest, float80 src ) REGPARAM;
1264 static void do_flogn( float80 dest, float80 src )
1265 {
1266 FPU_CONSISTENCY_CHECK_START();
1267 double x, y;
1268 x = extended_to_double( src );
1269 y = log (x);
1270 double_to_extended( y, dest );
1271 do_ftst( dest );
1272 FPU_CONSISTENCY_CHECK_STOP("do_flogn");
1273 }
1274
1275 static void do_flog10( float80 dest, float80 src ) REGPARAM;
1276 static void do_flog10( float80 dest, float80 src )
1277 {
1278 FPU_CONSISTENCY_CHECK_START();
1279 double x, y;
1280 x = extended_to_double( src );
1281 y = log10 (x);
1282 double_to_extended( y, dest );
1283 do_ftst( dest );
1284 FPU_CONSISTENCY_CHECK_STOP("do_flog10");
1285 }
1286
1287 static void do_flog2( float80 dest, float80 src ) REGPARAM;
1288 static void do_flog2( float80 dest, float80 src )
1289 {
1290 FPU_CONSISTENCY_CHECK_START();
1291 double x, y;
1292 x = extended_to_double( src );
1293 y = log (x) / log (2.0);
1294 double_to_extended( y, dest );
1295 do_ftst( dest );
1296 FPU_CONSISTENCY_CHECK_STOP("do_flog2");
1297 }
1298
1299 static void do_facos( float80 dest, float80 src ) REGPARAM;
1300 static void do_facos( float80 dest, float80 src )
1301 {
1302 FPU_CONSISTENCY_CHECK_START();
1303 double x, y;
1304 x = extended_to_double( src );
1305 y = acos(x);
1306 double_to_extended( y, dest );
1307 do_ftst( dest );
1308 FPU_CONSISTENCY_CHECK_STOP("do_facos");
1309 }
1310
1311 static void do_fcosh( float80 dest, float80 src ) REGPARAM;
1312 static void do_fcosh( float80 dest, float80 src )
1313 {
1314 FPU_CONSISTENCY_CHECK_START();
1315 double x, y;
1316 x = extended_to_double( src );
1317 y = cosh(x);
1318 double_to_extended( y, dest );
1319 do_ftst( dest );
1320 FPU_CONSISTENCY_CHECK_STOP("do_fcosh");
1321 }
1322
1323 static void do_fsin( float80 dest, float80 src ) REGPARAM;
1324 static void do_fsin( float80 dest, float80 src )
1325 {
1326 FPU_CONSISTENCY_CHECK_START();
1327 /* _asm {
1328 MOV ESI, [src]
1329 MOV EDI, [dest]
1330 FLD TBYTE PTR [ESI]
1331 FSIN
1332 FXAM
1333 FNSTSW sw
1334 FSTP TBYTE PTR [EDI]
1335 } */
1336 _ASM( "fldt %2\n"
1337 "fsin \n"
1338 "fxam \n"
1339 "fnstsw %0\n"
1340 "fstpt %1\n"
1341 : "=m" (sw), "=m" (*dest)
1342 : "m" (*src)
1343 );
1344 if(sw & SW_EXCEPTION_MASK) {
1345 // _asm FNCLEX
1346 _ASM("fnclex");
1347 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_PE);
1348 sw_accrued |= sw;
1349 }
1350 FPU_CONSISTENCY_CHECK_STOP("do_fsin");
1351 }
1352
1353 // TODO: Should check for out-of-range condition (partial tangent)
1354 static void do_ftan( float80 dest, float80 src ) REGPARAM;
1355 static void do_ftan( float80 dest, float80 src )
1356 {
1357 FPU_CONSISTENCY_CHECK_START();
1358 /* _asm {
1359 MOV ESI, [src]
1360 MOV EDI, [dest]
1361 FLD TBYTE PTR [ESI]
1362 FPTAN
1363 FSTP ST(0) ; pop 1.0 (the 8087/287 compatibility thing)
1364 FXAM
1365 FNSTSW sw
1366 FSTP TBYTE PTR [EDI]
1367 } */
1368 _ASM( "fldt %2\n"
1369 "fptan \n"
1370 "fstp %%st(0)\n"
1371 "fxam \n"
1372 "fnstsw %0\n"
1373 "fstpt %1\n"
1374 : "=m" (sw), "=m" (*dest)
1375 : "m" (*src)
1376 );
1377 if(sw & SW_EXCEPTION_MASK) {
1378 // _asm FNCLEX
1379 _ASM("fnclex");
1380 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_PE - SW_UE);
1381 sw_accrued |= sw;
1382 }
1383 FPU_CONSISTENCY_CHECK_STOP("do_ftan");
1384 }
1385
1386 static void do_fabs( float80 dest, float80 src ) REGPARAM;
1387 static void do_fabs( float80 dest, float80 src )
1388 {
1389 FPU_CONSISTENCY_CHECK_START();
1390 /* _asm {
1391 MOV ESI, [src]
1392 MOV EDI, [dest]
1393 FLD TBYTE PTR [ESI]
1394 FABS
1395 FXAM
1396 FNSTSW sw
1397 FSTP TBYTE PTR [EDI]
1398 } */
1399 _ASM( "fldt %2\n"
1400 "fabs \n"
1401 "fxam \n"
1402 "fnstsw %0\n"
1403 "fstpt %1\n"
1404 : "=m" (sw), "=m" (*dest)
1405 : "m" (*src)
1406 );
1407 // x86 fabs should not rise any exceptions (except stack underflow)
1408 if(sw & SW_EXCEPTION_MASK) {
1409 // _asm FNCLEX
1410 _ASM("fnclex");
1411 sw &= ~SW_EXCEPTION_MASK;
1412 }
1413 FPU_CONSISTENCY_CHECK_STOP("do_fabs");
1414 }
1415
1416 static void do_fneg( float80 dest, float80 src ) REGPARAM;
1417 static void do_fneg( float80 dest, float80 src )
1418 {
1419 FPU_CONSISTENCY_CHECK_START();
1420 /* _asm {
1421 MOV ESI, [src]
1422 MOV EDI, [dest]
1423 FLD TBYTE PTR [ESI]
1424 FCHS
1425 FXAM
1426 FNSTSW sw
1427 FSTP TBYTE PTR [EDI]
1428 } */
1429 _ASM( "fldt %2\n"
1430 "fchs \n"
1431 "fxam \n"
1432 "fnstsw %0\n"
1433 "fstpt %1\n"
1434 : "=m" (sw), "=m" (*dest)
1435 : "m" (*src)
1436 );
1437 // x86 fchs should not rise any exceptions (except stack underflow)
1438 if(sw & SW_EXCEPTION_MASK) {
1439 // _asm FNCLEX
1440 _ASM("fnclex");
1441 sw &= ~SW_EXCEPTION_MASK;
1442 }
1443 FPU_CONSISTENCY_CHECK_STOP("do_fneg");
1444 }
1445
1446 static void do_fcos( float80 dest, float80 src ) REGPARAM;
1447 static void do_fcos( float80 dest, float80 src )
1448 {
1449 FPU_CONSISTENCY_CHECK_START();
1450 /* _asm {
1451 MOV ESI, [src]
1452 MOV EDI, [dest]
1453 FLD TBYTE PTR [ESI]
1454 FCOS
1455 FXAM
1456 FNSTSW sw
1457 FSTP TBYTE PTR [EDI]
1458 } */
1459 _ASM( "fldt %2\n"
1460 "fcos \n"
1461 "fxam \n"
1462 "fnstsw %0\n"
1463 "fstpt %1\n"
1464 : "=m" (sw), "=m" (*dest)
1465 : "m" (*src)
1466 );
1467 if(sw & SW_EXCEPTION_MASK) {
1468 // _asm FNCLEX
1469 _ASM("fnclex");
1470 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_PE);
1471 sw_accrued |= sw;
1472 }
1473 FPU_CONSISTENCY_CHECK_STOP("do_fcos");
1474 }
1475
1476 static void do_fgetexp( float80 dest, float80 src ) REGPARAM;
1477 static void do_fgetexp( float80 dest, float80 src )
1478 {
1479 FPU_CONSISTENCY_CHECK_START();
1480 /* _asm {
1481 MOV ESI, [src]
1482 MOV EDI, [dest]
1483 FLD TBYTE PTR [ESI]
1484 FXTRACT
1485 FSTP ST(0) ; pop mantissa
1486 FXAM
1487 FNSTSW sw
1488 FSTP TBYTE PTR [EDI]
1489 } */
1490 _ASM( "fldt %2\n"
1491 "fxtract\n"
1492 "fstp %%st(0)\n"
1493 "fxam \n"
1494 "fnstsw %0\n"
1495 "fstpt %1\n"
1496 : "=m" (sw), "=m" (*dest)
1497 : "m" (*src)
1498 );
1499 if(sw & SW_EXCEPTION_MASK) {
1500 // _asm FNCLEX
1501 _ASM("fnclex");
1502 sw &= ~SW_EXCEPTION_MASK;
1503 }
1504 FPU_CONSISTENCY_CHECK_STOP("do_fgetexp");
1505 }
1506
1507 static void do_fgetman( float80 dest, float80 src ) REGPARAM;
1508 static void do_fgetman( float80 dest, float80 src )
1509 {
1510 FPU_CONSISTENCY_CHECK_START();
1511 /* _asm {
1512 MOV ESI, [src]
1513 MOV EDI, [dest]
1514 FLD TBYTE PTR [ESI]
1515 FXTRACT
1516 FXAM
1517 FNSTSW sw
1518 FSTP TBYTE PTR [EDI]
1519 FSTP ST(0) ; pop exponent
1520 } */
1521 _ASM( "fldt %2\n"
1522 "fxtract\n"
1523 "fxam \n"
1524 "fnstsw %0\n"
1525 "fstpt %1\n"
1526 "fstp %%st(0)\n"
1527 : "=m" (sw), "=m" (*dest)
1528 : "m" (*src)
1529 );
1530 if(sw & SW_EXCEPTION_MASK) {
1531 // _asm FNCLEX
1532 _ASM("fnclex");
1533 sw &= ~SW_EXCEPTION_MASK;
1534 }
1535 FPU_CONSISTENCY_CHECK_STOP("do_fgetman");
1536 }
1537
1538 static void do_fdiv( float80 dest, float80 src ) REGPARAM;
1539 static void do_fdiv( float80 dest, float80 src )
1540 {
1541 FPU_CONSISTENCY_CHECK_START();
1542 /* _asm {
1543 MOV ESI, [src]
1544 MOV EDI, [dest]
1545 FLD TBYTE PTR [ESI]
1546 FLD TBYTE PTR [EDI]
1547 FDIV ST(0),ST(1)
1548 FXAM
1549 FNSTSW sw
1550 FSTP TBYTE PTR [EDI]
1551 FSTP ST(0)
1552 } */
1553 _ASM( "fldt %2\n"
1554 "fldt %1\n"
1555 "fdiv %%st(1), %%st(0)\n"
1556 "fxam \n"
1557 "fnstsw %0\n"
1558 "fstpt %1\n"
1559 "fstp %%st(0)\n"
1560 : "=m" (sw), "+m" (*dest)
1561 : "m" (*src)
1562 );
1563 if(sw & SW_EXCEPTION_MASK) {
1564 // _asm FNCLEX
1565 _ASM("fnclex");
1566 sw_accrued |= sw;
1567 }
1568 FPU_CONSISTENCY_CHECK_STOP("do_fdiv");
1569 }
1570
1571 // The sign of the quotient is the exclusive-OR of the sign bits
1572 // of the source and destination operands.
1573 // Quotient Byte is loaded with the sign and least significant
1574 // seven bits of the quotient.
1575
1576 static void do_fmod( float80 dest, float80 src ) REGPARAM;
1577 static void do_fmod( float80 dest, float80 src )
1578 {
1579 FPU_CONSISTENCY_CHECK_START();
1580
1581 volatile uint16 status;
1582 uae_u32 quot;
1583 #if !USE_3_BIT_QUOTIENT
1584 WORD cw_temp;
1585 #endif
1586
1587 uae_u32 sign = (dest[9] ^ src[9]) & 0x80;
1588
1589 /* _asm {
1590 MOV ESI, [src]
1591 MOV EDI, [dest]
1592
1593 #if !USE_3_BIT_QUOTIENT
1594 MOV CX, cw
1595 AND CX, ~X86_ROUND_CONTROL_MASK
1596 OR CX, CW_RC_ZERO
1597 MOV cw_temp, CX
1598 FLDCW cw_temp
1599
1600 FLD TBYTE PTR [ESI]
1601 FLD TBYTE PTR [EDI]
1602 FDIV ST(0),ST(1)
1603 FABS
1604 FISTP DWORD PTR quot
1605 FSTP ST(0)
1606 FLDCW cw
1607 // TODO:Quotient
1608 // Should clear any possible exceptions here
1609 #endif
1610
1611 FLD TBYTE PTR [ESI]
1612 FLD TBYTE PTR [EDI]
1613
1614 // loop until the remainder is not partial any more.
1615 partial_loop:
1616 FPREM
1617 FNSTSW status
1618 TEST status, SW_C2
1619 JNE partial_loop
1620
1621
1622 FXAM
1623 FNSTSW sw
1624
1625 FSTP TBYTE PTR [EDI]
1626 FSTP ST(0)
1627 } */
1628
1629 #if !USE_3_BIT_QUOTIENT
1630
1631 _ASM( "movl %6, %%ecx\n" // %6: cw (read)
1632 "andl $(~X86_ROUND_CONTROL_MASK), %%ecx\n"
1633 "orl $CW_RC_ZERO, %%ecx\n"
1634 "movl %%ecx, %0\n" // %0: cw_temp (read/write)
1635 "fldcw %0\n"
1636 "fldt %5\n"
1637 "fldt %4\n"
1638 "fdiv %%st(1), %%st(0)\n"
1639 "fabs \n"
1640 "fistpl %1\n" // %1: quot (read/write)
1641 "fstp %%st(0)\n"
1642 "fldcw %6\n"
1643 "fldt %5\n"
1644 "fldt %4\n"
1645 "0:\n" // partial_loop
1646 "fprem \n"
1647 "fnstsw %2\n" // %2: status (read/write)
1648 "testl $SW_C2, %2\n"
1649 "jne 0b\n"
1650 "fxam \n"
1651 "fnstsw %3\n" // %3: sw (write)
1652 "fstpt %4\n"
1653 "fstp %%st(0)\n"
1654 : "+m" (cw_temp), "+m" (quot), "+m" (status), "=m" (sw), "+m" (*dest)
1655 : "m" (*src), "m" (cw)
1656 : "ecx"
1657 );
1658
1659 #else
1660
1661 _ASM( "fldt %4\n"
1662 "fldt %2\n"
1663 "0:\n" // partial_loop
1664 "fprem \n"
1665 "fnstsw %0\n" // %0: status (read/write)
1666 "testl $SW_C2, %0\n"
1667 "jne 0b\n"
1668 "fxam \n"
1669 "fnstsw %1\n" // %1: sw (write)
1670 "fstpt %2\n"
1671 "fstp %%st(0)\n"
1672 : "+m" (status), "=m" (sw), "+m" (*dest)
1673 : "m" (*src)
1674 );
1675
1676 #endif
1677
1678 if(sw & SW_EXCEPTION_MASK) {
1679 // _asm FNCLEX
1680 _ASM("fnclex");
1681 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE);
1682 sw_accrued |= sw;
1683 }
1684
1685 #if USE_3_BIT_QUOTIENT
1686 // SW_C1 Set to least significant bit of quotient (Q0).
1687 // SW_C3 Set to bit 1 (Q1) of the quotient.
1688 // SW_C0 Set to bit 2 (Q2) of the quotient.
1689 quot = ((status & SW_C0) >> 6) | ((status & SW_C3) >> 13) | ((status & SW_C1) >> 9);
1690 sw_quotient = (sign | quot) << 16;
1691 #else
1692 sw_quotient = (sign | (quot&0x7F)) << 16;
1693 #endif
1694
1695 FPU_CONSISTENCY_CHECK_STOP("do_fmod");
1696 }
1697
1698 static void do_frem( float80 dest, float80 src ) REGPARAM;
1699 static void do_frem( float80 dest, float80 src )
1700 {
1701 FPU_CONSISTENCY_CHECK_START();
1702
1703 volatile uint16 status;
1704 uae_u32 quot;
1705 #if !USE_3_BIT_QUOTIENT
1706 WORD cw_temp;
1707 #endif
1708
1709 uae_u32 sign = (dest[9] ^ src[9]) & 0x80;
1710
1711 /* _asm {
1712 MOV ESI, [src]
1713 MOV EDI, [dest]
1714
1715 #if !USE_3_BIT_QUOTIENT
1716 MOV CX, cw
1717 AND CX, ~X86_ROUND_CONTROL_MASK
1718 OR CX, CW_RC_NEAR
1719 MOV cw_temp, CX
1720 FLDCW cw_temp
1721
1722 FLD TBYTE PTR [ESI]
1723 FLD TBYTE PTR [EDI]
1724 FDIV ST(0),ST(1)
1725 FABS
1726 FISTP DWORD PTR quot
1727 FSTP ST(0)
1728 FLDCW cw
1729 // TODO:Quotient
1730 // Should clear any possible exceptions here
1731 #endif
1732
1733 FLD TBYTE PTR [ESI]
1734 FLD TBYTE PTR [EDI]
1735
1736 // loop until the remainder is not partial any more.
1737 partial_loop:
1738 FPREM1
1739 FNSTSW status
1740 TEST status, SW_C2
1741 JNE partial_loop
1742
1743 FXAM
1744 FNSTSW sw
1745 FSTP TBYTE PTR [EDI]
1746 FSTP ST(0)
1747 } */
1748
1749 #if !USE_3_BIT_QUOTIENT
1750
1751 _ASM( "movl %6, %%ecx\n" // %6: cw (read)
1752 "andl $(~X86_ROUND_CONTROL_MASK), %%ecx\n"
1753 "orl $CW_RC_NEAR, %%ecx\n"
1754 "movl %%ecx, %0\n" // %0: cw_temp (read/write)
1755 "fldcw %0\n"
1756 "fldt %5\n"
1757 "fldt %4\n"
1758 "fdiv %%st(1), %%st(0)\n"
1759 "fabs \n"
1760 "fistpl %1\n" // %1: quot (read/write)
1761 "fstp %%st(0)\n"
1762 "fldcw %6\n"
1763 "fldt %5\n"
1764 "fldt %4\n"
1765 "0:\n" // partial_loop
1766 "fprem1 \n"
1767 "fnstsw %2\n" // %2: status (read/write)
1768 "testl $SW_C2, %2\n"
1769 "jne 0b\n"
1770 "fxam \n"
1771 "fnstsw %3\n" // %3: sw (write)
1772 "fstpt %4\n"
1773 "fstp %%st(0)\n"
1774 : "+m" (cw_temp), "+m" (quot), "+m" (status), "=m" (sw), "+m" (*dest)
1775 : "m" (*src), "m" (cw)
1776 : "ecx"
1777 );
1778
1779 #else
1780
1781 _ASM( "fldt %3\n"
1782 "fldt %2\n"
1783 "0:\n" // partial_loop
1784 "fprem1 \n"
1785 "fnstsw %0\n" // %0: status (read/write)
1786 "testl $SW_C2, %0\n"
1787 "jne 0b\n"
1788 "fxam \n"
1789 "fnstsw %1\n" // %1: sw (write)
1790 "fstpt %2\n"
1791 "fstp %%st(0)\n"
1792 : "+m" (status), "=m" (sw), "+m" (*dest)
1793 : "m" (*src)
1794 );
1795
1796 #endif
1797
1798 if(sw & SW_EXCEPTION_MASK) {
1799 // _asm FNCLEX
1800 _ASM("fnclex");
1801 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE);
1802 sw_accrued |= sw;
1803 }
1804
1805 #if USE_3_BIT_QUOTIENT
1806 // SW_C1 Set to least significant bit of quotient (Q0).
1807 // SW_C3 Set to bit 1 (Q1) of the quotient.
1808 // SW_C0 Set to bit 2 (Q2) of the quotient.
1809 quot = ((status & SW_C0) >> 6) | ((status & SW_C3) >> 13) | ((status & SW_C1) >> 9);
1810 sw_quotient = (sign | quot) << 16;
1811 #else
1812 sw_quotient = (sign | (quot&0x7F)) << 16;
1813 #endif
1814
1815 FPU_CONSISTENCY_CHECK_STOP("do_frem");
1816 }
1817
1818 // Faster versions. The current rounding mode is already correct.
1819 #if !USE_3_BIT_QUOTIENT
1820 static void do_fmod_dont_set_cw( float80 dest, float80 src ) REGPARAM;
1821 static void do_fmod_dont_set_cw( float80 dest, float80 src )
1822 {
1823 FPU_CONSISTENCY_CHECK_START();
1824
1825 volatile uint16 status;
1826 uae_u32 quot;
1827
1828 uae_u32 sign = (dest[9] ^ src[9]) & 0x80;
1829
1830 _asm {
1831 MOV ESI, [src]
1832 MOV EDI, [dest]
1833
1834 FLD TBYTE PTR [ESI]
1835 FLD TBYTE PTR [EDI]
1836 FDIV ST(0),ST(1)
1837 FABS
1838 FISTP DWORD PTR quot
1839 FSTP ST(0)
1840 // TODO:Quotient
1841 // Should clear any possible exceptions here
1842
1843 FLD TBYTE PTR [ESI]
1844 FLD TBYTE PTR [EDI]
1845
1846 // loop until the remainder is not partial any more.
1847 partial_loop:
1848 FPREM
1849 FNSTSW status
1850 TEST status, SW_C2
1851 JNE partial_loop
1852
1853 FXAM
1854 FNSTSW sw
1855
1856 FSTP TBYTE PTR [EDI]
1857 FSTP ST(0)
1858 }
1859 if(sw & SW_EXCEPTION_MASK) {
1860 _asm FNCLEX
1861 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE);
1862 sw_accrued |= sw;
1863 }
1864 sw_quotient = (sign | (quot&0x7F)) << 16;
1865 FPU_CONSISTENCY_CHECK_STOP("do_fmod_dont_set_cw");
1866 }
1867
1868 static void do_frem_dont_set_cw( float80 dest, float80 src ) REGPARAM;
1869 static void do_frem_dont_set_cw( float80 dest, float80 src )
1870 {
1871 FPU_CONSISTENCY_CHECK_START();
1872
1873 volatile uint16 status;
1874 uae_u32 quot;
1875
1876 uae_u32 sign = (dest[9] ^ src[9]) & 0x80;
1877
1878 _asm {
1879 MOV ESI, [src]
1880 MOV EDI, [dest]
1881
1882 FLD TBYTE PTR [ESI]
1883 FLD TBYTE PTR [EDI]
1884 FDIV ST(0),ST(1)
1885 FABS
1886 FISTP DWORD PTR quot
1887 FSTP ST(0)
1888 // TODO:Quotient
1889 // Should clear any possible exceptions here
1890
1891 FLD TBYTE PTR [ESI]
1892 FLD TBYTE PTR [EDI]
1893
1894 // loop until the remainder is not partial any more.
1895 partial_loop:
1896 FPREM1
1897 FNSTSW status
1898 TEST status, SW_C2
1899 JNE partial_loop
1900
1901 FXAM
1902 FNSTSW sw
1903 FSTP TBYTE PTR [EDI]
1904 FSTP ST(0)
1905 }
1906 if(sw & SW_EXCEPTION_MASK) {
1907 _asm FNCLEX
1908 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE);
1909 sw_accrued |= sw;
1910 }
1911 sw_quotient = (sign | (quot&0x7F)) << 16;
1912 FPU_CONSISTENCY_CHECK_STOP("do_frem_dont_set_cw");
1913 }
1914 #endif //USE_3_BIT_QUOTIENT
1915
1916 static void do_fadd( float80 dest, float80 src ) REGPARAM;
1917 static void do_fadd( float80 dest, float80 src )
1918 {
1919 FPU_CONSISTENCY_CHECK_START();
1920 /* _asm {
1921 MOV ESI, [src]
1922 MOV EDI, [dest]
1923 FLD TBYTE PTR [ESI]
1924 FLD TBYTE PTR [EDI]
1925 FADD
1926 FXAM
1927 FNSTSW sw
1928 FSTP TBYTE PTR [EDI]
1929 } */
1930 _ASM( "fldt %2\n"
1931 "fldt %1\n"
1932 "fadd \n"
1933 "fxam \n"
1934 "fnstsw %0\n"
1935 "fstpt %1\n"
1936 : "=m" (sw), "+m" (*dest)
1937 : "m" (*src)
1938 );
1939 if(sw & SW_EXCEPTION_MASK) {
1940 // _asm FNCLEX
1941 _ASM("fnclex");
1942 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE - SW_OE - SW_PE);
1943 sw_accrued |= sw;
1944 }
1945 FPU_CONSISTENCY_CHECK_STOP("do_fadd");
1946 }
1947
1948 static void do_fmul( float80 dest, float80 src ) REGPARAM;
1949 static void do_fmul( float80 dest, float80 src )
1950 {
1951 FPU_CONSISTENCY_CHECK_START();
1952 /* _asm {
1953 MOV ESI, [src]
1954 MOV EDI, [dest]
1955 FLD TBYTE PTR [ESI]
1956 FLD TBYTE PTR [EDI]
1957 FMUL
1958 FXAM
1959 FNSTSW sw
1960 FSTP TBYTE PTR [EDI]
1961 } */
1962 _ASM( "fldt %2\n"
1963 "fldt %1\n"
1964 "fmul \n"
1965 "fxam \n"
1966 "fnstsw %0\n"
1967 "fstpt %1\n"
1968 : "=m" (sw), "+m" (*dest)
1969 : "m" (*src)
1970 );
1971 if(sw & SW_EXCEPTION_MASK) {
1972 // _asm FNCLEX
1973 _ASM("fnclex");
1974 sw_accrued |= sw;
1975 }
1976 FPU_CONSISTENCY_CHECK_STOP("do_fmul");
1977 }
1978
1979 static void do_fsgldiv( float80 dest, float80 src ) REGPARAM;
1980 static void do_fsgldiv( float80 dest, float80 src )
1981 {
1982 FPU_CONSISTENCY_CHECK_START();
1983 WORD cw_temp;
1984 /* _asm {
1985 FSTCW cw_temp
1986 and cw_temp, ~X86_PRECISION_CONTROL_MASK
1987 or cw_temp, PRECISION_CONTROL_SINGLE
1988 FLDCW cw_temp
1989
1990 MOV ESI, [src]
1991 MOV EDI, [dest]
1992 FLD TBYTE PTR [ESI]
1993 FLD TBYTE PTR [EDI]
1994 FDIV ST(0),ST(1)
1995 FXAM
1996 FNSTSW sw
1997 FSTP TBYTE PTR [EDI]
1998 FSTP ST(0)
1999 FLDCW cw
2000 } */
2001 _ASM( "fstcw %0\n"
2002 "andl $(~X86_PRECISION_CONTROL_MASK), %0\n"
2003 "orl $PRECISION_CONTROL_SINGLE, %0\n"
2004 "fldcw %0\n"
2005 "fldt %3\n"
2006 "fldt %2\n"
2007 "fdiv %%st(1), %%st(0)\n"
2008 "fxam \n"
2009 "fnstsw %1\n"
2010 "fstpt %2\n"
2011 "fstp %%st(0)\n"
2012 "fldcw %4\n"
2013 : "+m" (cw_temp), "=m" (sw), "+m" (*dest)
2014 : "m" (*src), "m" (cw)
2015 );
2016 if(sw & SW_EXCEPTION_MASK) {
2017 // _asm FNCLEX
2018 _ASM("fnclex");
2019 sw_accrued |= sw;
2020 }
2021 FPU_CONSISTENCY_CHECK_STOP("do_fsgldiv");
2022 }
2023
2024 static void do_fscale( float80 dest, float80 src ) REGPARAM;
2025 static void do_fscale( float80 dest, float80 src )
2026 {
2027 FPU_CONSISTENCY_CHECK_START();
2028 /* _asm {
2029 MOV ESI, [src]
2030 MOV EDI, [dest]
2031 FLD TBYTE PTR [ESI]
2032 FLD TBYTE PTR [EDI]
2033 FSCALE
2034 FXAM
2035 FNSTSW sw
2036 FSTP TBYTE PTR [EDI]
2037 FSTP ST(0)
2038 } */
2039 _ASM( "fldt %2\n"
2040 "fldt %1\n"
2041 "fscale \n"
2042 "fxam \n"
2043 "fnstsw %0\n"
2044 "fstpt %1\n"
2045 "fstp %%st(0)\n"
2046 : "=m" (sw), "+m" (*dest)
2047 : "m" (*src)
2048 );
2049 if(sw & SW_EXCEPTION_MASK) {
2050 // _asm FNCLEX
2051 _ASM("fnclex");
2052 sw &= ~(SW_EXCEPTION_MASK - SW_UE - SW_OE);
2053 sw_accrued |= sw;
2054 }
2055 FPU_CONSISTENCY_CHECK_STOP("do_fscale");
2056 }
2057
2058 static void do_fsglmul( float80 dest, float80 src ) REGPARAM;
2059 static void do_fsglmul( float80 dest, float80 src )
2060 {
2061 FPU_CONSISTENCY_CHECK_START();
2062 WORD cw_temp;
2063
2064 /* _asm {
2065 FSTCW cw_temp
2066 and cw_temp, ~X86_PRECISION_CONTROL_MASK
2067 or cw_temp, PRECISION_CONTROL_SINGLE
2068 FLDCW cw_temp
2069
2070 MOV ESI, [src]
2071 MOV EDI, [dest]
2072 FLD TBYTE PTR [ESI]
2073 FLD TBYTE PTR [EDI]
2074 FMUL
2075 FXAM
2076 FNSTSW sw
2077 FSTP TBYTE PTR [EDI]
2078
2079 FLDCW cw
2080 } */
2081 _ASM( "fstcw %0\n"
2082 "andl $(~X86_PRECISION_CONTROL_MASK), %0\n"
2083 "orl $PRECISION_CONTROL_SINGLE, %0\n"
2084 "fldcw %0\n"
2085 "fldt %3\n"
2086 "fldt %2\n"
2087 "fmul \n"
2088 "fxam \n"
2089 "fnstsw %1\n"
2090 "fstpt %2\n"
2091 "fldcw %4\n"
2092 : "+m" (cw_temp), "=m" (sw), "+m" (*dest)
2093 : "m" (*src), "m" (sw)
2094 );
2095 if(sw & SW_EXCEPTION_MASK) {
2096 // _asm FNCLEX
2097 _ASM("fnclex");
2098 sw_accrued |= sw;
2099 }
2100 FPU_CONSISTENCY_CHECK_STOP("do_fsglmul");
2101 }
2102
2103 static void do_fsub( float80 dest, float80 src ) REGPARAM;
2104 static void do_fsub( float80 dest, float80 src )
2105 {
2106 FPU_CONSISTENCY_CHECK_START();
2107 /* _asm {
2108 MOV ESI, [src]
2109 MOV EDI, [dest]
2110 FLD TBYTE PTR [ESI]
2111 FLD TBYTE PTR [EDI]
2112 FSUB ST(0),ST(1)
2113 FXAM
2114 FNSTSW sw
2115 FSTP TBYTE PTR [EDI]
2116 FSTP ST(0)
2117 } */
2118 _ASM( "fldt %2\n"
2119 "fldt %1\n"
2120 "fsub %%st(1), %%st(0)\n"
2121 "fxam \n"
2122 "fnstsw %0\n"
2123 "fstpt %1\n"
2124 "fstp %%st(0)\n"
2125 : "=m" (sw), "+m" (*dest)
2126 : "m" (*src)
2127 );
2128 if(sw & SW_EXCEPTION_MASK) {
2129 // _asm FNCLEX
2130 _ASM("fnclex");
2131 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE - SW_OE - SW_PE);
2132 sw_accrued |= sw;
2133 }
2134 FPU_CONSISTENCY_CHECK_STOP("do_fsub");
2135 }
2136
2137 static void do_fsincos( float80 dest_sin, float80 dest_cos, float80 src ) REGPARAM;
2138 static void do_fsincos( float80 dest_sin, float80 dest_cos, float80 src )
2139 {
2140 FPU_CONSISTENCY_CHECK_START();
2141 /* _asm {
2142 MOV ESI, [src]
2143 MOV EDI, [dest_cos]
2144 FLD TBYTE PTR [ESI]
2145 FSINCOS
2146 FSTP TBYTE PTR [EDI]
2147 FXAM
2148 MOV EDI, [dest_sin]
2149 FNSTSW sw
2150 FSTP TBYTE PTR [EDI]
2151 FSTP ST(0)
2152 } */
2153 _ASM( "fldt %3\n"
2154 "fsincos\n"
2155 "fstpt %1\n"
2156 "fxam \n"
2157 "fnstsw %0\n"
2158 "fstpt %2\n"
2159 "fstp %%st(0)\n"
2160 : "=m" (sw), "=m" (*dest_cos), "=m" (*dest_sin)
2161 : "m" (*src)
2162 );
2163 if(sw & SW_EXCEPTION_MASK) {
2164 // _asm FNCLEX
2165 _ASM("fnclex");
2166 sw &= ~(SW_EXCEPTION_MASK - SW_IE - SW_UE - SW_PE);
2167 sw_accrued |= sw;
2168 }
2169 FPU_CONSISTENCY_CHECK_STOP("do_fsincos");
2170 }
2171
2172 static void do_fcmp( float80 dest, float80 src ) REGPARAM;
2173 static void do_fcmp( float80 dest, float80 src )
2174 {
2175 FPU_CONSISTENCY_CHECK_START();
2176 /* _asm {
2177 MOV ESI, [src]
2178 MOV EDI, [dest]
2179 FLD TBYTE PTR [ESI]
2180 FLD TBYTE PTR [EDI]
2181 FSUB ST(0),ST(1)
2182 FXAM
2183 FNSTSW sw
2184 FSTP ST(0)
2185 FSTP ST(0)
2186 } */
2187 _ASM( "fldt %2\n"
2188 "fldt %1\n"
2189 "fsub %%st(1), %%st(0)\n"
2190 "fxam \n"
2191 "fnstsw %0\n"
2192 "fstp %%st(0)\n"
2193 "fstp %%st(0)\n"
2194 : "=m" (sw)
2195 : "m" (*dest), "m" (*src)
2196 );
2197 if(sw & SW_EXCEPTION_MASK) {
2198 // _asm FNCLEX
2199 _ASM("fnclex");
2200 sw &= ~SW_EXCEPTION_MASK;
2201 }
2202 FPU_CONSISTENCY_CHECK_STOP("do_fcmp");
2203 }
2204
2205 // More or less original. Should be reviewed.
2206 static double to_pack(uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3) REGPARAM;
2207 static double to_pack(uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
2208 {
2209 FPU_CONSISTENCY_CHECK_START();
2210
2211 double d;
2212 char *cp;
2213 char str[100];
2214
2215 cp = str;
2216 if (wrd1 & 0x80000000)
2217 *cp++ = '-';
2218 *cp++ = (char)((wrd1 & 0xf) + '0');
2219 *cp++ = '.';
2220 *cp++ = (char)(((wrd2 >> 28) & 0xf) + '0');
2221 *cp++ = (char)(((wrd2 >> 24) & 0xf) + '0');
2222 *cp++ = (char)(((wrd2 >> 20) & 0xf) + '0');
2223 *cp++ = (char)(((wrd2 >> 16) & 0xf) + '0');
2224 *cp++ = (char)(((wrd2 >> 12) & 0xf) + '0');
2225 *cp++ = (char)(((wrd2 >> 8) & 0xf) + '0');
2226 *cp++ = (char)(((wrd2 >> 4) & 0xf) + '0');
2227 *cp++ = (char)(((wrd2 >> 0) & 0xf) + '0');
2228 *cp++ = (char)(((wrd3 >> 28) & 0xf) + '0');
2229 *cp++ = (char)(((wrd3 >> 24) & 0xf) + '0');
2230 *cp++ = (char)(((wrd3 >> 20) & 0xf) + '0');
2231 *cp++ = (char)(((wrd3 >> 16) & 0xf) + '0');
2232 *cp++ = (char)(((wrd3 >> 12) & 0xf) + '0');
2233 *cp++ = (char)(((wrd3 >> 8) & 0xf) + '0');
2234 *cp++ = (char)(((wrd3 >> 4) & 0xf) + '0');
2235 *cp++ = (char)(((wrd3 >> 0) & 0xf) + '0');
2236 *cp++ = 'E';
2237 if (wrd1 & 0x40000000)
2238 *cp++ = '-';
2239 *cp++ = (char)(((wrd1 >> 24) & 0xf) + '0');
2240 *cp++ = (char)(((wrd1 >> 20) & 0xf) + '0');
2241 *cp++ = (char)(((wrd1 >> 16) & 0xf) + '0');
2242 *cp = 0;
2243 sscanf(str, "%le", &d);
2244
2245 D(bug("to_pack str = %s\r\n",str));
2246
2247 D(bug("to_pack(%X,%X,%X) = %.04f\r\n",wrd1,wrd2,wrd3,(float)d));
2248
2249 FPU_CONSISTENCY_CHECK_STOP("to_pack");
2250
2251 return d;
2252 }
2253
2254 // More or less original. Should be reviewed.
2255 static void from_pack(double src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3) REGPARAM;
2256 static void from_pack(double src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
2257 {
2258 FPU_CONSISTENCY_CHECK_START();
2259
2260 int i;
2261 int t;
2262 char *cp;
2263 char str[100];
2264 int exponent_digit_count = 0;
2265
2266 sprintf(str, "%.16e", src);
2267
2268 D(bug("from_pack(%.04f,%s)\r\n",(float)src,str));
2269
2270 cp = str;
2271 *wrd1 = *wrd2 = *wrd3 = 0;
2272 if (*cp == '-') {
2273 cp++;
2274 *wrd1 = 0x80000000;
2275 }
2276 if (*cp == '+')
2277 cp++;
2278 *wrd1 |= (*cp++ - '0');
2279 if (*cp == '.')
2280 cp++;
2281 for (i = 0; i < 8; i++) {
2282 *wrd2 <<= 4;
2283 if (*cp >= '0' && *cp <= '9')
2284 *wrd2 |= *cp++ - '0';
2285 }
2286 for (i = 0; i < 8; i++) {
2287 *wrd3 <<= 4;
2288 if (*cp >= '0' && *cp <= '9')
2289 *wrd3 |= *cp++ - '0';
2290 }
2291 if (*cp == 'e' || *cp == 'E') {
2292 cp++;
2293 if (*cp == '-') {
2294 cp++;
2295 *wrd1 |= 0x40000000;
2296 }
2297 if (*cp == '+')
2298 cp++;
2299 t = 0;
2300 for (i = 0; i < 3; i++) {
2301 if (*cp >= '0' && *cp <= '9') {
2302 t = (t << 4) | (*cp++ - '0');
2303 exponent_digit_count++;
2304 }
2305 }
2306 *wrd1 |= t << 16;
2307 }
2308
2309 D(bug("from_pack(%.04f) = %X,%X,%X\r\n",(float)src,*wrd1,*wrd2,*wrd3));
2310
2311 WORD sw_temp;
2312 // _asm FNSTSW sw_temp
2313 _ASM("fnstsw %0" : "=m" (sw_temp));
2314 if(sw_temp & SW_EXCEPTION_MASK) {
2315 // _asm FNCLEX
2316 _ASM("fnclex");
2317 if(sw_temp & SW_PE) {
2318 sw |= SW_PE;
2319 sw_accrued |= SW_PE;
2320 }
2321 }
2322
2323 /*
2324 OPERR is set if the k-factor > + 17 or the magnitude of
2325 the decimal exponent exceeds three digits;
2326 cleared otherwise.
2327 */
2328 if(exponent_digit_count > 3) {
2329 sw |= SW_IE;
2330 sw_accrued |= SW_IE;
2331 }
2332
2333 FPU_CONSISTENCY_CHECK_STOP("from_pack");
2334 }
2335
2336 static int sz1[8] = {4, 4, 12, 12, 2, 8, 1, 0};
2337 static int sz2[8] = {4, 4, 12, 12, 2, 8, 2, 0};
2338
2339 static int get_fp_value (uae_u32 opcode, uae_u16 extra, float80 src) REGPARAM;
2340 static int get_fp_value (uae_u32 opcode, uae_u16 extra, float80 src)
2341 {
2342 // D(bug("get_fp_value(%X,%X)\r\n",(int)opcode,(int)extra));
2343 // dump_first_bytes( regs.pc_p-4, 16 );
2344
2345 if ((extra & 0x4000) == 0) {
2346 memcpy( src, fp_reg[(extra >> 10) & 7], sizeof(float80_s) );
2347 // do_fmove_no_status( src, fp_reg[(extra >> 10) & 7] );
2348 return 1;
2349 }
2350
2351 int mode = (opcode >> 3) & 7;
2352 int reg = opcode & 7;
2353 int size = (extra >> 10) & 7;
2354 uae_u32 ad = 0;
2355
2356 // D(bug("get_fp_value mode=%d, reg=%d, size=%d\r\n",(int)mode,(int)reg,(int)size));
2357
2358 switch ((uae_u8)mode) {
2359 case 0:
2360 switch ((uae_u8)size) {
2361 case 6:
2362 signed_to_extended( (uae_s32)(uae_s8) m68k_dreg (regs, reg), src );
2363 break;
2364 case 4:
2365 signed_to_extended( (uae_s32)(uae_s16) m68k_dreg (regs, reg), src );
2366 break;
2367 case 0:
2368 signed_to_extended( (uae_s32) m68k_dreg (regs, reg), src );
2369 break;
2370 case 1:
2371 to_single( m68k_dreg (regs, reg), src );
2372 break;
2373 default:
2374 return 0;
2375 }
2376 return 1;
2377 case 1:
2378 return 0;
2379 case 2:
2380 ad = m68k_areg (regs, reg);
2381 break;
2382 case 3:
2383 ad = m68k_areg (regs, reg);
2384 m68k_areg (regs, reg) += reg == 7 ? sz2[size] : sz1[size];
2385 break;
2386 case 4:
2387 m68k_areg (regs, reg) -= reg == 7 ? sz2[size] : sz1[size];
2388 ad = m68k_areg (regs, reg);
2389 break;
2390 case 5:
2391 ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) next_iword();
2392 break;
2393 case 6:
2394 ad = get_disp_ea_020 (m68k_areg (regs, reg), next_iword());
2395 break;
2396 case 7:
2397 switch ((uae_u8)reg) {
2398 case 0:
2399 ad = (uae_s32) (uae_s16) next_iword();
2400 break;
2401 case 1:
2402 ad = next_ilong();
2403 break;
2404 case 2:
2405 ad = m68k_getpc ();
2406 ad += (uae_s32) (uae_s16) next_iword();
2407 break;
2408 case 3: {
2409 uaecptr tmppc = m68k_getpc ();
2410 uae_u16 tmp = (uae_u16)next_iword();
2411 ad = get_disp_ea_020 (tmppc, tmp);
2412 }
2413 break;
2414 case 4:
2415 ad = m68k_getpc ();
2416 m68k_setpc (ad + sz2[size]);
2417
2418 /*
2419 +0000 000004 FSCALE.B #$01,FP2 | F23C 5926 0001
2420 F23C 1111001000111100
2421 5926 0101100100100110
2422 0001 0000000000000001
2423 mode = 7
2424 reg = 4
2425 size = 6
2426 */
2427 // Immediate addressing mode && Operation Length == Byte ->
2428 // Use the low-order byte of the extension word.
2429
2430 if(size == 6) ad++;
2431
2432 // May be faster on a PII(I), sz2[size] is already in register
2433 // ad += sz2[size] - sz1[size];
2434
2435 break;
2436 default:
2437 return 0;
2438 }
2439 }
2440
2441 switch ((uae_u8)size) {
2442 case 0:
2443 signed_to_extended( (uae_s32) get_long (ad), src );
2444 break;
2445 case 1:
2446 to_single( get_long (ad), src );
2447 break;
2448
2449 case 2:{
2450 uae_u32 wrd1, wrd2, wrd3;
2451 wrd1 = get_long (ad);
2452 ad += 4;
2453 wrd2 = get_long (ad);
2454 ad += 4;
2455 wrd3 = get_long (ad);
2456 to_exten( wrd1, wrd2, wrd3, src );
2457 }
2458 break;
2459 case 3:{
2460 uae_u32 wrd1, wrd2, wrd3;
2461 wrd1 = get_long (ad);
2462 ad += 4;
2463 wrd2 = get_long (ad);
2464 ad += 4;
2465 wrd3 = get_long (ad);
2466 double_to_extended( to_pack(wrd1, wrd2, wrd3), src );
2467 }
2468 break;
2469 case 4:
2470 signed_to_extended( (uae_s32)(uae_s16) get_word(ad), src );
2471 break;
2472 case 5:{
2473 uae_u32 wrd1, wrd2;
2474 wrd1 = get_long (ad);
2475 ad += 4;
2476 wrd2 = get_long (ad);
2477 to_double(wrd1, wrd2, src);
2478 }
2479 break;
2480 case 6:
2481 signed_to_extended( (uae_s32)(uae_s8) get_byte(ad), src );
2482 break;
2483 default:
2484 return 0;
2485 }
2486
2487 // D(bug("get_fp_value result = %.04f\r\n",(float)*src));
2488
2489 return 1;
2490 }
2491
2492 static int put_fp_value (float80 value, uae_u32 opcode, uae_u16 extra) REGPARAM;
2493 static int put_fp_value (float80 value, uae_u32 opcode, uae_u16 extra)
2494 {
2495 // D(bug("put_fp_value(%.04f,%X,%X)\r\n",(float)value,(int)opcode,(int)extra));
2496
2497 if ((extra & 0x4000) == 0) {
2498 int dest_reg = (extra >> 10) & 7;
2499 do_fmove( fp_reg[dest_reg], value );
2500 build_ex_status();
2501 return 1;
2502 }
2503
2504 int mode = (opcode >> 3) & 7;
2505 int reg = opcode & 7;
2506 int size = (extra >> 10) & 7;
2507 uae_u32 ad = 0xffffffff;
2508
2509 // Clear exception status
2510 sw &= ~SW_EXCEPTION_MASK;
2511
2512 switch ((uae_u8)mode) {
2513 case 0:
2514 switch ((uae_u8)size) {
2515 case 6:
2516 *((uae_u8 *)&m68k_dreg(regs, reg)) = extended_to_signed_8(value);
2517 break;
2518 case 4:
2519 // TODO_BIGENDIAN
2520 *((uae_u16 *)&m68k_dreg(regs, reg)) = extended_to_signed_16(value);
2521 break;
2522 case 0:
2523 m68k_dreg (regs, reg) = extended_to_signed_32(value);
2524 break;
2525 case 1:
2526 m68k_dreg (regs, reg) = from_single(value);
2527 break;
2528 default:
2529 return 0;
2530 }
2531 return 1;
2532 case 1:
2533 return 0;
2534 case 2:
2535 ad = m68k_areg (regs, reg);
2536 break;
2537 case 3:
2538 ad = m68k_areg (regs, reg);
2539 m68k_areg (regs, reg) += reg == 7 ? sz2[size] : sz1[size];
2540 break;
2541 case 4:
2542 m68k_areg (regs, reg) -= reg == 7 ? sz2[size] : sz1[size];
2543 ad = m68k_areg (regs, reg);
2544 break;
2545 case 5:
2546 ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) next_iword();
2547 break;
2548 case 6:
2549 ad = get_disp_ea_020 (m68k_areg (regs, reg), next_iword());
2550 break;
2551 case 7:
2552 switch ((uae_u8)reg) {
2553 case 0:
2554 ad = (uae_s32) (uae_s16) next_iword();
2555 break;
2556 case 1:
2557 ad = next_ilong();
2558 break;
2559 case 2:
2560 ad = m68k_getpc ();
2561 ad += (uae_s32) (uae_s16) next_iword();
2562 break;
2563 case 3: {
2564 uaecptr tmppc = m68k_getpc ();
2565 uae_u16 tmp = (uae_u16)next_iword();
2566 ad = get_disp_ea_020 (tmppc, tmp);
2567 }
2568 break;
2569 case 4:
2570 ad = m68k_getpc ();
2571 m68k_setpc (ad + sz2[size]);
2572 break;
2573 default:
2574 return 0;
2575 }
2576 }
2577 switch ((uae_u8)size) {
2578 case 0:
2579 put_long (ad, (uae_s32) extended_to_signed_32(value));
2580 break;
2581 case 1:
2582 put_long (ad, from_single(value));
2583 break;
2584 case 2: {
2585 uae_u32 wrd1, wrd2, wrd3;
2586 from_exten(value, &wrd1, &wrd2, &wrd3);
2587
2588 sw &= ~SW_EXCEPTION_MASK;
2589 if(wrd3) { // TODO: not correct! Just a "smart" guess.
2590 sw |= SW_PE;
2591 sw_accrued |= SW_PE;
2592 }
2593
2594 put_long (ad, wrd1);
2595 ad += 4;
2596 put_long (ad, wrd2);
2597 ad += 4;
2598 put_long (ad, wrd3);
2599 }
2600 break;
2601 case 3: {
2602 uae_u32 wrd1, wrd2, wrd3;
2603 from_pack(extended_to_double(value), &wrd1, &wrd2, &wrd3);
2604 put_long (ad, wrd1);
2605 ad += 4;
2606 put_long (ad, wrd2);
2607 ad += 4;
2608 put_long (ad, wrd3);
2609 }
2610 break;
2611 case 4:
2612 put_word(ad, extended_to_signed_16(value));
2613 break;
2614 case 5:{
2615 uae_u32 wrd1, wrd2;
2616 from_double(value, &wrd1, &wrd2);
2617 put_long (ad, wrd1);
2618 ad += 4;
2619 put_long (ad, wrd2);
2620 }
2621 break;
2622 case 6:
2623 put_byte(ad, extended_to_signed_8(value));
2624
2625 break;
2626 default:
2627 return 0;
2628 }
2629 return 1;
2630 }
2631
2632 static int get_fp_ad(uae_u32 opcode, uae_u32 * ad) REGPARAM;
2633 static int get_fp_ad(uae_u32 opcode, uae_u32 * ad)
2634 {
2635 int mode = (opcode >> 3) & 7;
2636 int reg = opcode & 7;
2637 switch ( (uae_u8)mode ) {
2638 case 0:
2639 case 1:
2640 if( (opcode & 0xFF00) == 0xF300 ) {
2641 // fsave, frestore
2642 m68k_setpc (m68k_getpc () - 2);
2643 } else {
2644 m68k_setpc (m68k_getpc () - 4);
2645 }
2646 op_illg (opcode);
2647 dump_fp_regs( "END ");
2648 return 0;
2649 case 2:
2650 *ad = m68k_areg (regs, reg);
2651 break;
2652 case 3:
2653 *ad = m68k_areg (regs, reg);
2654 break;
2655 case 4:
2656 *ad = m68k_areg (regs, reg);
2657 break;
2658 case 5:
2659 *ad = m68k_areg (regs, reg) + (uae_s32) (uae_s16) next_iword();
2660 break;
2661 case 6:
2662 *ad = get_disp_ea_020 (m68k_areg (regs, reg), next_iword());
2663 break;
2664 case 7:
2665 switch ( (uae_u8)reg ) {
2666 case 0:
2667 *ad = (uae_s32) (uae_s16) next_iword();
2668 break;
2669 case 1:
2670 *ad = next_ilong();
2671 break;
2672 case 2:
2673 *ad = m68k_getpc ();
2674 *ad += (uae_s32) (uae_s16) next_iword();
2675 break;
2676 case 3: {
2677 uaecptr tmppc = m68k_getpc ();
2678 uae_u16 tmp = (uae_u16)next_iword();
2679 *ad = get_disp_ea_020 (tmppc, tmp);
2680 }
2681 break;
2682 default:
2683 if( (opcode & 0xFF00) == 0xF300 ) {
2684 // fsave, frestore
2685 m68k_setpc (m68k_getpc () - 2);
2686 } else {
2687 m68k_setpc (m68k_getpc () - 4);
2688 }
2689 op_illg (opcode);
2690 dump_fp_regs( "END ");
2691 return 0;
2692 }
2693 }
2694 return 1;
2695 }
2696
2697 static int fpp_cond(uae_u32 opcode, int condition) REGPARAM;
2698 static int fpp_cond(uae_u32 opcode, int condition)
2699 {
2700
2701 #define N (sw & SW_N)
2702 #define Z ((sw & (SW_Z_I_NAN_MASK)) == SW_Z)
2703 #define I ((sw & (SW_Z_I_NAN_MASK)) == (SW_I))
2704 #define NotANumber ((sw & (SW_Z_I_NAN_MASK)) == SW_NAN)
2705
2706 switch (condition) {
2707 // Common Tests, no BSUN
2708 case 0x01:
2709 CONDRET("Equal",Z);
2710 case 0x0e:
2711 CONDRET("Not Equal",!Z);
2712
2713 // IEEE Nonaware Tests, BSUN
2714 case 0x12:
2715 SET_BSUN_ON_NAN();
2716 CONDRET("Greater Than",!(NotANumber || Z || N));
2717 case 0x1d:
2718 SET_BSUN_ON_NAN();
2719 CONDRET("Not Greater Than",NotANumber || Z || N);
2720 case 0x13:
2721 SET_BSUN_ON_NAN();
2722 CONDRET("Greater Than or Equal",Z || !(NotANumber || N));
2723 case 0x1c:
2724 SET_BSUN_ON_NAN();
2725 CONDRET("Not Greater Than or Equal",!Z && (NotANumber || N));
2726 case 0x14:
2727 SET_BSUN_ON_NAN();
2728 CONDRET("Less Than",N && !(NotANumber || Z));
2729 case 0x1b:
2730 SET_BSUN_ON_NAN();
2731 CONDRET("Not Less Than",NotANumber || Z || !N);
2732 case 0x15:
2733 SET_BSUN_ON_NAN();
2734 CONDRET("Less Than or Equal",Z || (N && !NotANumber));
2735 case 0x1a:
2736 SET_BSUN_ON_NAN();
2737 CONDRET("Not Less Than or Equal",NotANumber || !(N || Z));
2738 case 0x16:
2739 SET_BSUN_ON_NAN();
2740 CONDRET("Greater or Less Than",!(NotANumber || Z));
2741 case 0x19:
2742 SET_BSUN_ON_NAN();
2743 CONDRET("Not Greater or Less Than",NotANumber || Z);
2744 case 0x17:
2745 CONDRET("Greater, Less or Equal",!NotANumber);
2746 case 0x18:
2747 SET_BSUN_ON_NAN();
2748 CONDRET("Not Greater, Less or Equal",NotANumber);
2749
2750 // IEEE Aware Tests, no BSUN
2751 case 0x02:
2752 CONDRET("Ordered Greater Than",!(NotANumber || Z || N));
2753 case 0x0d:
2754 CONDRET("Unordered or Less or Equal",NotANumber || Z || N);
2755 case 0x03:
2756 CONDRET("Ordered Greater Than or Equal",Z || !(NotANumber || N));
2757 case 0x0c:
2758 CONDRET("Unordered or Less Than",NotANumber || (N && !Z));
2759 case 0x04:
2760 CONDRET("Ordered Less Than",N && !(NotANumber || Z));
2761 case 0x0b:
2762 CONDRET("Unordered or Greater or Equal",NotANumber || Z || !N);
2763 case 0x05:
2764 CONDRET("Ordered Less Than or Equal",Z || (N && !NotANumber));
2765 case 0x0a:
2766 CONDRET("Unordered or Greater Than",NotANumber || !(N || Z));
2767 case 0x06:
2768 CONDRET("Ordered Greater or Less Than",!(NotANumber || Z));
2769 case 0x09:
2770 CONDRET("Unordered or Equal",NotANumber || Z);
2771 case 0x07:
2772 CONDRET("Ordered",!NotANumber);
2773 case 0x08:
2774 CONDRET("Unordered",NotANumber);
2775
2776 // Miscellaneous Tests, no BSUN
2777 case 0x00:
2778 CONDRET("False",0);
2779 case 0x0f:
2780 CONDRET("True",1);
2781
2782 // Miscellaneous Tests, BSUN
2783 case 0x10:
2784 SET_BSUN_ON_NAN();
2785 CONDRET("Signaling False",0);
2786 case 0x1f:
2787 SET_BSUN_ON_NAN();
2788 CONDRET("Signaling True",1);
2789 case 0x11:
2790 SET_BSUN_ON_NAN();
2791 CONDRET("Signaling Equal",Z);
2792 case 0x1e:
2793 SET_BSUN_ON_NAN();
2794 CONDRET("Signaling Not Equal",!Z);
2795 }
2796 CONDRET("",-1);
2797
2798 #undef N
2799 #undef Z
2800 #undef I
2801 #undef NotANumber
2802
2803 }
2804
2805 void REGPARAM2 fdbcc_opp(uae_u32 opcode, uae_u16 extra)
2806 {
2807 uaecptr pc = (uae_u32) m68k_getpc ();
2808 uae_s32 disp = (uae_s32) (uae_s16) next_iword();
2809 int cc;
2810
2811 D(bug("fdbcc_opp %X, %X at %08lx\r\n", (uae_u32)opcode, (uae_u32)extra, m68k_getpc ()));
2812
2813 cc = fpp_cond(opcode, extra & 0x3f);
2814 if (cc < 0) {
2815 m68k_setpc (pc - 4);
2816 op_illg (opcode);
2817 } else if (!cc) {
2818 int reg = opcode & 0x7;
2819
2820 // TODO_BIGENDIAN
2821 uae_u16 newv = (uae_u16)(m68k_dreg (regs, reg) & 0xffff) - 1;
2822 *((uae_u16 *)&m68k_dreg(regs, reg)) = newv;
2823
2824 if (newv != 0xffff)
2825 m68k_setpc (pc + disp);
2826 }
2827 }
2828
2829 void REGPARAM2 fscc_opp(uae_u32 opcode, uae_u16 extra)
2830 {
2831 uae_u32 ad;
2832 int cc;
2833
2834 D(bug("fscc_opp %X, %X at %08lx\r\n", (uae_u32)opcode, (uae_u32)extra, m68k_getpc ()));
2835
2836 cc = fpp_cond(opcode, extra & 0x3f);
2837 if (cc < 0) {
2838 m68k_setpc (m68k_getpc () - 4);
2839 op_illg (opcode);
2840 } else if ((opcode & 0x38) == 0) {
2841 // TODO_BIGENDIAN
2842 m68k_dreg (regs, opcode & 7) = (m68k_dreg (regs, opcode & 7) & ~0xff) |
2843 (cc ? 0xff : 0x00);
2844 } else {
2845 if (get_fp_ad(opcode, &ad)) {
2846 put_byte(ad, cc ? 0xff : 0x00);
2847 }
2848 }
2849 }
2850
2851 void REGPARAM2 ftrapcc_opp(uae_u32 opcode, uaecptr oldpc)
2852 {
2853 int cc;
2854
2855 D(bug("ftrapcc_opp %X at %08lx\r\n", (uae_u32)opcode, m68k_getpc ()));
2856
2857 #if I3_ON_FTRAPCC
2858 #error "FIXME: _asm int 3"
2859 _asm int 3
2860 #endif
2861
2862 // This must be broken.
2863 cc = fpp_cond(opcode, opcode & 0x3f);
2864
2865 if (cc < 0) {
2866 m68k_setpc (oldpc);
2867 op_illg (opcode);
2868 } else if (cc)
2869 Exception(7, oldpc - 2);
2870 }
2871
2872 // NOTE that we get here also when there is a FNOP (nontrapping false, displ 0)
2873 void REGPARAM2 fbcc_opp(uae_u32 opcode, uaecptr pc, uae_u32 extra)
2874 {
2875 int cc;
2876
2877 D(bug("fbcc_opp %X, %X at %08lx, jumpto=%X\r\n", (uae_u32)opcode, (uae_u32)extra, m68k_getpc (), extra ));
2878
2879 cc = fpp_cond(opcode, opcode & 0x3f);
2880 if (cc < 0) {
2881 m68k_setpc (pc);
2882 op_illg (opcode);
2883 } else if (cc) {
2884 if ((opcode & 0x40) == 0)
2885 extra = (uae_s32) (uae_s16) extra;
2886 m68k_setpc (pc + extra);
2887 }
2888 }
2889
2890 // FSAVE has no post-increment
2891 // 0x1f180000 == IDLE state frame, coprocessor version number 1F
2892 void REGPARAM2 fsave_opp(uae_u32 opcode)
2893 {
2894 uae_u32 ad;
2895 int incr = (opcode & 0x38) == 0x20 ? -1 : 1;
2896 int i;
2897
2898 D(bug("fsave_opp at %08lx\r\n", m68k_getpc ()));
2899
2900 if (get_fp_ad(opcode, &ad)) {
2901 if (is_integral_68040_fpu) {
2902 // Put 4 byte 68040 IDLE frame.
2903 if (incr < 0) {
2904 ad -= 4;
2905 put_long (ad, 0x41000000);
2906 } else {
2907 put_long (ad, 0x41000000);
2908 ad += 4;
2909 }
2910 } else {
2911 // Put 28 byte 68881 IDLE frame.
2912 if (incr < 0) {
2913 D(bug("fsave_opp pre-decrement\r\n"));
2914 ad -= 4;
2915 // What's this? Some BIU flags, or (incorrectly placed) command/condition?
2916 put_long (ad, 0x70000000);
2917 for (i = 0; i < 5; i++) {
2918 ad -= 4;
2919 put_long (ad, 0x00000000);
2920 }
2921 ad -= 4;
2922 put_long (ad, 0x1f180000); // IDLE, vers 1f
2923 } else {
2924 put_long (ad, 0x1f180000); // IDLE, vers 1f
2925 ad += 4;
2926 for (i = 0; i < 5; i++) {
2927 put_long (ad, 0x00000000);
2928 ad += 4;
2929 }
2930 // What's this? Some BIU flags, or (incorrectly placed) command/condition?
2931 put_long (ad, 0x70000000);
2932 ad += 4;
2933 }
2934 }
2935 if ((opcode & 0x38) == 0x18) {
2936 m68k_areg (regs, opcode & 7) = ad; // Never executed on a 68881
2937 D(bug("PROBLEM: fsave_opp post-increment\r\n"));
2938 }
2939 if ((opcode & 0x38) == 0x20) {
2940 m68k_areg (regs, opcode & 7) = ad;
2941 D(bug("fsave_opp pre-decrement %X -> A%d\r\n",ad,opcode & 7));
2942 }
2943 }
2944 }
2945
2946 static void do_null_frestore()
2947 {
2948 // A null-restore operation sets FP7-FP0 positive, nonsignaling NANs.
2949 for( int i=0; i<8; i++ ) {
2950 MAKE_NAN( fp_reg[i] );
2951 }
2952
2953 regs.fpiar = 0;
2954 regs.fpcr = 0;
2955 regs.fpsr = 0;
2956
2957 sw = SW_INITIAL;
2958 sw_accrued = 0;
2959 sw_quotient = 0;
2960
2961 cw = CW_INITIAL;
2962 /* _asm FLDCW cw
2963 _asm FNCLEX */
2964 _ASM("fldcw %0\n\tfnclex" : : "m" (cw));
2965 }
2966
2967 // FSAVE has no pre-decrement
2968 void REGPARAM2 frestore_opp(uae_u32 opcode)
2969 {
2970 uae_u32 ad;
2971 uae_u32 d;
2972 int incr = (opcode & 0x38) == 0x20 ? -1 : 1;
2973
2974 D(bug("frestore_opp at %08lx\r\n", m68k_getpc ()));
2975
2976 if (get_fp_ad(opcode, &ad)) {
2977 if (is_integral_68040_fpu) {
2978 // 68040
2979 if (incr < 0) {
2980 D(bug("PROBLEM: frestore_opp incr < 0\r\n"));
2981 // this may be wrong, but it's never called.
2982 ad -= 4;
2983 d = get_long (ad);
2984 if ((d & 0xff000000) == 0) { // NULL
2985 D(bug("frestore_opp found NULL frame at %X\r\n",ad-4));
2986 do_null_frestore();
2987 } else if ((d & 0x00ff0000) == 0) { // IDLE
2988 D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
2989 } else if ((d & 0x00ff0000) == 0x00300000) { // UNIMP
2990 D(bug("PROBLEM: frestore_opp found UNIMP frame at %X\r\n",ad-4));
2991 ad -= 44;
2992 } else if ((d & 0x00ff0000) == 0x00600000) { // BUSY
2993 D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
2994 ad -= 92;
2995 } else {
2996 D(bug("PROBLEM: frestore_opp did not find a frame at %X, d=%X\r\n",ad-4,d));
2997 }
2998 } else {
2999 d = get_long (ad);
3000 D(bug("frestore_opp frame at %X = %X\r\n",ad,d));
3001 ad += 4;
3002 if ((d & 0xff000000) == 0) { // NULL
3003 D(bug("frestore_opp found NULL frame at %X\r\n",ad-4));
3004 do_null_frestore();
3005 } else if ((d & 0x00ff0000) == 0) { // IDLE
3006 D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
3007 } else if ((d & 0x00ff0000) == 0x00300000) { // UNIMP
3008 D(bug("PROBLEM: frestore_opp found UNIMP frame at %X\r\n",ad-4));
3009 ad += 44;
3010 } else if ((d & 0x00ff0000) == 0x00600000) { // BUSY
3011 D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
3012 ad += 92;
3013 } else {
3014 D(bug("PROBLEM: frestore_opp did not find a frame at %X, d=%X\r\n",ad-4,d));
3015 }
3016 }
3017 } else {
3018 // 68881
3019 if (incr < 0) {
3020 D(bug("PROBLEM: frestore_opp incr < 0\r\n"));
3021 // this may be wrong, but it's never called.
3022 ad -= 4;
3023 d = get_long (ad);
3024 if ((d & 0xff000000) == 0) { // NULL
3025 do_null_frestore();
3026 } else if ((d & 0x00ff0000) == 0x00180000) {
3027 ad -= 6 * 4;
3028 } else if ((d & 0x00ff0000) == 0x00380000) {
3029 ad -= 14 * 4;
3030 } else if ((d & 0x00ff0000) == 0x00b40000) {
3031 ad -= 45 * 4;
3032 }
3033 } else {
3034 d = get_long (ad);
3035 D(bug("frestore_opp frame at %X = %X\r\n",ad,d));
3036 ad += 4;
3037 if ((d & 0xff000000) == 0) { // NULL
3038 D(bug("frestore_opp found NULL frame at %X\r\n",ad-4));
3039 do_null_frestore();
3040 } else if ((d & 0x00ff0000) == 0x00180000) { // IDLE
3041 D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
3042 ad += 6 * 4;
3043 } else if ((d & 0x00ff0000) == 0x00380000) {// UNIMP? shouldn't it be 3C?
3044 ad += 14 * 4;
3045 D(bug("PROBLEM: frestore_opp found UNIMP? frame at %X\r\n",ad-4));
3046 } else if ((d & 0x00ff0000) == 0x00b40000) {// BUSY
3047 D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
3048 ad += 45 * 4;
3049 } else {
3050 D(bug("PROBLEM: frestore_opp did not find a frame at %X, d=%X\r\n",ad-4,d));
3051 }
3052 }
3053 }
3054
3055 if ((opcode & 0x38) == 0x18) {
3056 m68k_areg (regs, opcode & 7) = ad;
3057 D(bug("frestore_opp post-increment %X -> A%d\r\n",ad,opcode & 7));
3058 }
3059 if ((opcode & 0x38) == 0x20) {
3060 m68k_areg (regs, opcode & 7) = ad; // Never executed on a 68881
3061 D(bug("PROBLEM: frestore_opp pre-decrement\r\n"));
3062 }
3063 }
3064 }
3065
3066
3067 /* ---------------------------- Old-style interface ---------------------------- */
3068
3069 // #ifndef OPTIMIZED_8BIT_MEMORY_ACCESS
3070 void REGPARAM2 fpp_opp(uae_u32 opcode, uae_u16 extra)
3071 {
3072 uae_u32 mask = (extra & 0xFC7F) | ((opcode & 0x0038) << 4);
3073 (*fpufunctbl[mask])(opcode,extra);
3074 }
3075 // #endif
3076
3077
3078 /* ---------------------------- Illegal ---------------------------- */
3079
3080 void REGPARAM2 fpuop_illg( uae_u32 opcode, uae_u16 extra )
3081 {
3082 D(bug("ILLEGAL F OP 2 %X\r\n",opcode));
3083
3084 #if I3_ON_ILLEGAL_FPU_OP
3085 #error "FIXME: asm int 3"
3086 _asm int 3
3087 #endif
3088
3089 m68k_setpc (m68k_getpc () - 4);
3090 op_illg (opcode);
3091 dump_fp_regs( "END ");
3092 }
3093
3094
3095 /* ---------------------------- FPP -> <ea> ---------------------------- */
3096
3097 void REGPARAM2 fpuop_fmove_2_ea( uae_u32 opcode, uae_u16 extra )
3098 {
3099 D(bug("FMOVE -> <ea>\r\n"));
3100
3101 if (put_fp_value (fp_reg[(extra >> 7) & 7], opcode, extra) == 0) {
3102 m68k_setpc (m68k_getpc () - 4);
3103 op_illg (opcode);
3104 }
3105
3106 /*
3107 Needed (among other things) by some Pack5/Elems68k transcendental
3108 functions, they require the ACCR_INEX flag after a "MOVE.D, Dreg".
3109 However, now put_fp_value() is responsible of clearing the exceptions
3110 and merging statuses.
3111 */
3112
3113 /*
3114 WORD sw_temp;
3115 _asm FNSTSW sw_temp
3116 if(sw_temp & SW_PE) {
3117 _asm FNCLEX
3118 sw |= SW_PE;
3119 sw_accrued |= SW_PE;
3120 }
3121 */
3122
3123 dump_fp_regs( "END ");
3124 }
3125
3126
3127 /* ---------------------------- CONTROL REGS -> Dreg ---------------------------- */
3128
3129 void REGPARAM2 fpuop_fmovem_none_2_Dreg( uae_u32 opcode, uae_u16 extra )
3130 {
3131 D(bug("FMOVEM control(none) -> D%d\r\n", opcode & 7));
3132 dump_fp_regs( "END ");
3133 }
3134
3135 void REGPARAM2 fpuop_fmovem_fpiar_2_Dreg( uae_u32 opcode, uae_u16 extra )
3136 {
3137 D(bug("FMOVEM regs.fpiar (%X) -> D%d\r\n", regs.fpiar, opcode & 7));
3138 m68k_dreg (regs, opcode & 7) = regs.fpiar;
3139 dump_fp_regs( "END ");
3140 }
3141
3142 void REGPARAM2 fpuop_fmovem_fpsr_2_Dreg( uae_u32 opcode, uae_u16 extra )
3143 {
3144 to_fpsr();
3145 D(bug("FMOVEM regs.fpsr (%X) -> D%d\r\n", regs.fpsr, opcode & 7));
3146 m68k_dreg (regs, opcode & 7) = regs.fpsr;
3147 dump_fp_regs( "END ");
3148 }
3149
3150 void REGPARAM2 fpuop_fmovem_fpcr_2_Dreg( uae_u32 opcode, uae_u16 extra )
3151 {
3152 D(bug("FMOVEM regs.fpcr (%X) -> D%d\r\n", regs.fpcr, opcode & 7));
3153 m68k_dreg (regs, opcode & 7) = regs.fpcr;
3154 dump_fp_regs( "END ");
3155 }
3156
3157 void REGPARAM2 fpuop_fmovem_fpsr_fpiar_2_Dreg( uae_u32 opcode, uae_u16 extra )
3158 {
3159 to_fpsr();
3160 D(bug("FMOVEM regs.fpsr (%X) -> D%d\r\n", regs.fpsr, opcode & 7));
3161 m68k_dreg (regs, opcode & 7) = regs.fpsr;
3162 D(bug("FMOVEM regs.fpiar (%X) -> D%d\r\n", regs.fpiar, opcode & 7));
3163 m68k_dreg (regs, opcode & 7) = regs.fpiar;
3164 dump_fp_regs( "END ");
3165 }
3166
3167 void REGPARAM2 fpuop_fmovem_fpcr_fpiar_2_Dreg( uae_u32 opcode, uae_u16 extra )
3168 {
3169 D(bug("FMOVEM regs.fpcr (%X) -> D%d\r\n", regs.fpcr, opcode & 7));
3170 m68k_dreg (regs, opcode & 7) = regs.fpcr;
3171 D(bug("FMOVEM regs.fpiar (%X) -> D%d\r\n", regs.fpiar, opcode & 7));
3172 m68k_dreg (regs, opcode & 7) = regs.fpiar;
3173 dump_fp_regs( "END ");
3174 }
3175
3176 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_2_Dreg( uae_u32 opcode, uae_u16 extra )
3177 {
3178 D(bug("FMOVEM regs.fpcr (%X) -> D%d\r\n", regs.fpcr, opcode & 7));
3179 m68k_dreg (regs, opcode & 7) = regs.fpcr;
3180 to_fpsr();
3181 D(bug("FMOVEM regs.fpsr (%X) -> D%d\r\n", regs.fpsr, opcode & 7));
3182 m68k_dreg (regs, opcode & 7) = regs.fpsr;
3183 dump_fp_regs( "END ");
3184 }
3185
3186 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_fpiar_2_Dreg( uae_u32 opcode, uae_u16 extra )
3187 {
3188 D(bug("FMOVEM regs.fpcr (%X) -> D%d\r\n", regs.fpcr, opcode & 7));
3189 m68k_dreg (regs, opcode & 7) = regs.fpcr;
3190 to_fpsr();
3191 D(bug("FMOVEM regs.fpsr (%X) -> D%d\r\n", regs.fpsr, opcode & 7));
3192 m68k_dreg (regs, opcode & 7) = regs.fpsr;
3193 D(bug("FMOVEM regs.fpiar (%X) -> D%d\r\n", regs.fpiar, opcode & 7));
3194 m68k_dreg (regs, opcode & 7) = regs.fpiar;
3195 dump_fp_regs( "END ");
3196 }
3197
3198
3199 /* ---------------------------- Dreg -> CONTROL REGS ---------------------------- */
3200
3201 void REGPARAM2 fpuop_fmovem_Dreg_2_none( uae_u32 opcode, uae_u16 extra )
3202 {
3203 D(bug("FMOVEM D%d -> control(none)\r\n", opcode & 7));
3204 dump_fp_regs( "END ");
3205 }
3206
3207 void REGPARAM2 fpuop_fmovem_Dreg_2_fpiar( uae_u32 opcode, uae_u16 extra )
3208 {
3209 regs.fpiar = m68k_dreg (regs, opcode & 7);
3210 D(bug("FMOVEM D%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3211 dump_fp_regs( "END ");
3212 }
3213
3214 void REGPARAM2 fpuop_fmovem_Dreg_2_fpsr( uae_u32 opcode, uae_u16 extra )
3215 {
3216 regs.fpsr = m68k_dreg (regs, opcode & 7);
3217 from_fpsr();
3218 D(bug("FMOVEM D%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3219 dump_fp_regs( "END ");
3220 }
3221
3222 void REGPARAM2 fpuop_fmovem_Dreg_2_fpsr_fpiar( uae_u32 opcode, uae_u16 extra )
3223 {
3224 regs.fpsr = m68k_dreg (regs, opcode & 7);
3225 from_fpsr();
3226 D(bug("FMOVEM D%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3227 regs.fpiar = m68k_dreg (regs, opcode & 7);
3228 D(bug("FMOVEM D%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3229 dump_fp_regs( "END ");
3230 }
3231
3232 void REGPARAM2 fpuop_fmovem_Dreg_2_fpcr( uae_u32 opcode, uae_u16 extra )
3233 {
3234 regs.fpcr = m68k_dreg (regs, opcode & 7);
3235 set_host_fpu_control_word();
3236 D(bug("FMOVEM D%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3237 dump_fp_regs( "END ");
3238 }
3239
3240 void REGPARAM2 fpuop_fmovem_Dreg_2_fpcr_fpiar( uae_u32 opcode, uae_u16 extra )
3241 {
3242 regs.fpcr = m68k_dreg (regs, opcode & 7);
3243 set_host_fpu_control_word();
3244 D(bug("FMOVEM D%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3245 regs.fpiar = m68k_dreg (regs, opcode & 7);
3246 D(bug("FMOVEM D%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3247 dump_fp_regs( "END ");
3248 }
3249
3250 void REGPARAM2 fpuop_fmovem_Dreg_2_fpcr_fpsr( uae_u32 opcode, uae_u16 extra )
3251 {
3252 regs.fpcr = m68k_dreg (regs, opcode & 7);
3253 set_host_fpu_control_word();
3254 D(bug("FMOVEM D%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3255 regs.fpsr = m68k_dreg (regs, opcode & 7);
3256 from_fpsr();
3257 D(bug("FMOVEM D%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3258 dump_fp_regs( "END ");
3259 }
3260
3261 void REGPARAM2 fpuop_fmovem_Dreg_2_fpcr_fpsr_fpiar( uae_u32 opcode, uae_u16 extra )
3262 {
3263 regs.fpcr = m68k_dreg (regs, opcode & 7);
3264 set_host_fpu_control_word();
3265 D(bug("FMOVEM D%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3266 regs.fpsr = m68k_dreg (regs, opcode & 7);
3267 from_fpsr();
3268 D(bug("FMOVEM D%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3269 regs.fpiar = m68k_dreg (regs, opcode & 7);
3270 D(bug("FMOVEM D%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3271 dump_fp_regs( "END ");
3272 }
3273
3274
3275 /* ---------------------------- CONTROL REGS -> Areg ---------------------------- */
3276
3277 void REGPARAM2 fpuop_fmovem_none_2_Areg( uae_u32 opcode, uae_u16 extra )
3278 {
3279 D(bug("FMOVEM control(none) -> A%d\r\n", opcode & 7));
3280 dump_fp_regs( "END ");
3281 }
3282
3283 void REGPARAM2 fpuop_fmovem_fpiar_2_Areg( uae_u32 opcode, uae_u16 extra )
3284 {
3285 D(bug("FMOVEM regs.fpiar (%X) -> A%d\r\n", regs.fpiar, opcode & 7));
3286 m68k_areg (regs, opcode & 7) = regs.fpiar;
3287 dump_fp_regs( "END ");
3288 }
3289
3290 void REGPARAM2 fpuop_fmovem_fpsr_2_Areg( uae_u32 opcode, uae_u16 extra )
3291 {
3292 to_fpsr();
3293 D(bug("FMOVEM regs.fpsr (%X) -> A%d\r\n", regs.fpsr, opcode & 7));
3294 m68k_areg (regs, opcode & 7) = regs.fpsr;
3295 dump_fp_regs( "END ");
3296 }
3297
3298 void REGPARAM2 fpuop_fmovem_fpcr_2_Areg( uae_u32 opcode, uae_u16 extra )
3299 {
3300 D(bug("FMOVEM regs.fpcr (%X) -> A%d\r\n", regs.fpcr, opcode & 7));
3301 m68k_areg (regs, opcode & 7) = regs.fpcr;
3302 dump_fp_regs( "END ");
3303 }
3304
3305 void REGPARAM2 fpuop_fmovem_fpsr_fpiar_2_Areg( uae_u32 opcode, uae_u16 extra )
3306 {
3307 to_fpsr();
3308 D(bug("FMOVEM regs.fpsr (%X) -> A%d\r\n", regs.fpsr, opcode & 7));
3309 m68k_areg (regs, opcode & 7) = regs.fpsr;
3310 D(bug("FMOVEM regs.fpiar (%X) -> A%d\r\n", regs.fpiar, opcode & 7));
3311 m68k_areg (regs, opcode & 7) = regs.fpiar;
3312 dump_fp_regs( "END ");
3313 }
3314
3315 void REGPARAM2 fpuop_fmovem_fpcr_fpiar_2_Areg( uae_u32 opcode, uae_u16 extra )
3316 {
3317 D(bug("FMOVEM regs.fpcr (%X) -> A%d\r\n", regs.fpcr, opcode & 7));
3318 m68k_areg (regs, opcode & 7) = regs.fpcr;
3319 D(bug("FMOVEM regs.fpiar (%X) -> A%d\r\n", regs.fpiar, opcode & 7));
3320 m68k_areg (regs, opcode & 7) = regs.fpiar;
3321 dump_fp_regs( "END ");
3322 }
3323
3324 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_2_Areg( uae_u32 opcode, uae_u16 extra )
3325 {
3326 D(bug("FMOVEM regs.fpcr (%X) -> A%d\r\n", regs.fpcr, opcode & 7));
3327 m68k_areg (regs, opcode & 7) = regs.fpcr;
3328 to_fpsr();
3329 D(bug("FMOVEM regs.fpsr (%X) -> A%d\r\n", regs.fpsr, opcode & 7));
3330 m68k_areg (regs, opcode & 7) = regs.fpsr;
3331 dump_fp_regs( "END ");
3332 }
3333
3334 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_fpiar_2_Areg( uae_u32 opcode, uae_u16 extra )
3335 {
3336 D(bug("FMOVEM regs.fpcr (%X) -> A%d\r\n", regs.fpcr, opcode & 7));
3337 m68k_areg (regs, opcode & 7) = regs.fpcr;
3338 to_fpsr();
3339 D(bug("FMOVEM regs.fpsr (%X) -> A%d\r\n", regs.fpsr, opcode & 7));
3340 m68k_areg (regs, opcode & 7) = regs.fpsr;
3341 D(bug("FMOVEM regs.fpiar (%X) -> A%d\r\n", regs.fpiar, opcode & 7));
3342 m68k_areg (regs, opcode & 7) = regs.fpiar;
3343 dump_fp_regs( "END ");
3344 }
3345
3346
3347 /* ---------------------------- Areg -> CONTROL REGS ---------------------------- */
3348
3349 void REGPARAM2 fpuop_fmovem_Areg_2_none( uae_u32 opcode, uae_u16 extra )
3350 {
3351 D(bug("FMOVEM A%d -> control(none)\r\n", opcode & 7));
3352 dump_fp_regs( "END ");
3353 }
3354
3355 void REGPARAM2 fpuop_fmovem_Areg_2_fpiar( uae_u32 opcode, uae_u16 extra )
3356 {
3357 regs.fpiar = m68k_areg (regs, opcode & 7);
3358 D(bug("FMOVEM A%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3359 dump_fp_regs( "END ");
3360 }
3361
3362 void REGPARAM2 fpuop_fmovem_Areg_2_fpsr( uae_u32 opcode, uae_u16 extra )
3363 {
3364 regs.fpsr = m68k_areg (regs, opcode & 7);
3365 from_fpsr();
3366 D(bug("FMOVEM A%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3367 dump_fp_regs( "END ");
3368 }
3369
3370 void REGPARAM2 fpuop_fmovem_Areg_2_fpsr_fpiar( uae_u32 opcode, uae_u16 extra )
3371 {
3372 regs.fpsr = m68k_areg (regs, opcode & 7);
3373 from_fpsr();
3374 D(bug("FMOVEM A%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3375 regs.fpiar = m68k_areg (regs, opcode & 7);
3376 D(bug("FMOVEM A%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3377 dump_fp_regs( "END ");
3378 }
3379
3380 void REGPARAM2 fpuop_fmovem_Areg_2_fpcr( uae_u32 opcode, uae_u16 extra )
3381 {
3382 regs.fpcr = m68k_areg (regs, opcode & 7);
3383 set_host_fpu_control_word();
3384 D(bug("FMOVEM A%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3385 dump_fp_regs( "END ");
3386 }
3387
3388 void REGPARAM2 fpuop_fmovem_Areg_2_fpcr_fpiar( uae_u32 opcode, uae_u16 extra )
3389 {
3390 regs.fpcr = m68k_areg (regs, opcode & 7);
3391 set_host_fpu_control_word();
3392 D(bug("FMOVEM A%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3393 regs.fpiar = m68k_areg (regs, opcode & 7);
3394 D(bug("FMOVEM A%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3395 dump_fp_regs( "END ");
3396 }
3397
3398 void REGPARAM2 fpuop_fmovem_Areg_2_fpcr_fpsr( uae_u32 opcode, uae_u16 extra )
3399 {
3400 regs.fpcr = m68k_areg (regs, opcode & 7);
3401 set_host_fpu_control_word();
3402 D(bug("FMOVEM A%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3403 regs.fpsr = m68k_areg (regs, opcode & 7);
3404 from_fpsr();
3405 D(bug("FMOVEM A%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3406 dump_fp_regs( "END ");
3407 }
3408
3409 void REGPARAM2 fpuop_fmovem_Areg_2_fpcr_fpsr_fpiar( uae_u32 opcode, uae_u16 extra )
3410 {
3411 regs.fpcr = m68k_areg (regs, opcode & 7);
3412 set_host_fpu_control_word();
3413 D(bug("FMOVEM A%d (%X) -> regs.fpcr\r\n", opcode & 7, regs.fpcr));
3414 regs.fpsr = m68k_areg (regs, opcode & 7);
3415 from_fpsr();
3416 D(bug("FMOVEM A%d (%X) -> regs.fpsr\r\n", opcode & 7, regs.fpsr));
3417 regs.fpiar = m68k_areg (regs, opcode & 7);
3418 D(bug("FMOVEM A%d (%X) -> regs.fpiar\r\n", opcode & 7, regs.fpiar));
3419 dump_fp_regs( "END ");
3420 }
3421
3422
3423 /* ---------------------------- CONTROL REGS -> --MEMORY---------------------------- */
3424
3425 void REGPARAM2 fpuop_fmovem_none_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3426 {
3427 D(bug("FMOVEM Control regs (none) -> mem\r\n" ));
3428 dump_fp_regs( "END ");
3429 }
3430
3431 void REGPARAM2 fpuop_fmovem_fpiar_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3432 {
3433 uae_u32 ad;
3434 if (get_fp_ad(opcode, &ad)) {
3435 ad -= 4;
3436 put_long (ad, regs.fpiar);
3437 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad ));
3438 m68k_areg (regs, opcode & 7) = ad;
3439 dump_fp_regs( "END ");
3440 }
3441 }
3442
3443 void REGPARAM2 fpuop_fmovem_fpsr_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3444 {
3445 uae_u32 ad;
3446 if (get_fp_ad(opcode, &ad)) {
3447 ad -= 4;
3448 to_fpsr();
3449 put_long (ad, regs.fpsr);
3450 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3451 m68k_areg (regs, opcode & 7) = ad;
3452 dump_fp_regs( "END ");
3453 }
3454 }
3455
3456 void REGPARAM2 fpuop_fmovem_fpsr_fpiar_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3457 {
3458 uae_u32 ad;
3459 if (get_fp_ad(opcode, &ad)) {
3460 ad -= 8;
3461 to_fpsr();
3462 put_long (ad, regs.fpsr);
3463 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3464 put_long (ad+4, regs.fpiar);
3465 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3466 m68k_areg (regs, opcode & 7) = ad;
3467 dump_fp_regs( "END ");
3468 }
3469 }
3470
3471 void REGPARAM2 fpuop_fmovem_fpcr_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3472 {
3473 uae_u32 ad;
3474 if (get_fp_ad(opcode, &ad)) {
3475 ad -= 4;
3476 put_long (ad, regs.fpcr);
3477 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3478 m68k_areg (regs, opcode & 7) = ad;
3479 dump_fp_regs( "END ");
3480 }
3481 }
3482
3483 void REGPARAM2 fpuop_fmovem_fpcr_fpiar_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3484 {
3485 uae_u32 ad;
3486 if (get_fp_ad(opcode, &ad)) {
3487 ad -= 8;
3488 put_long (ad, regs.fpcr);
3489 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3490 put_long (ad+4, regs.fpiar);
3491 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3492 m68k_areg (regs, opcode & 7) = ad;
3493 dump_fp_regs( "END ");
3494 }
3495 }
3496
3497 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3498 {
3499 uae_u32 ad;
3500 if (get_fp_ad(opcode, &ad)) {
3501 ad -= 8;
3502 put_long (ad, regs.fpcr);
3503 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3504 to_fpsr();
3505 put_long (ad+4, regs.fpsr);
3506 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3507 m68k_areg (regs, opcode & 7) = ad;
3508 dump_fp_regs( "END ");
3509 }
3510 }
3511
3512 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem_predecrement( uae_u32 opcode, uae_u16 extra )
3513 {
3514 uae_u32 ad;
3515 if (get_fp_ad(opcode, &ad)) {
3516 ad -= 12;
3517 put_long (ad, regs.fpcr);
3518 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3519 to_fpsr();
3520 put_long (ad+4, regs.fpsr);
3521 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3522 put_long (ad+8, regs.fpiar);
3523 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+8 ));
3524 m68k_areg (regs, opcode & 7) = ad;
3525 dump_fp_regs( "END ");
3526 }
3527 }
3528
3529
3530 /* ---------------------------- CONTROL REGS -> MEMORY++ ---------------------------- */
3531
3532 void REGPARAM2 fpuop_fmovem_none_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3533 {
3534 D(bug("FMOVEM Control regs (none) -> mem\r\n" ));
3535 dump_fp_regs( "END ");
3536 }
3537
3538 void REGPARAM2 fpuop_fmovem_fpiar_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3539 {
3540 uae_u32 ad;
3541 if (get_fp_ad(opcode, &ad)) {
3542 put_long (ad, regs.fpiar);
3543 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad ));
3544 m68k_areg (regs, opcode & 7) = ad+4;
3545 dump_fp_regs( "END ");
3546 }
3547 }
3548
3549 void REGPARAM2 fpuop_fmovem_fpsr_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3550 {
3551 uae_u32 ad;
3552 if (get_fp_ad(opcode, &ad)) {
3553 to_fpsr();
3554 put_long (ad, regs.fpsr);
3555 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3556 m68k_areg (regs, opcode & 7) = ad+4;
3557 dump_fp_regs( "END ");
3558 }
3559 }
3560
3561 void REGPARAM2 fpuop_fmovem_fpsr_fpiar_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3562 {
3563 uae_u32 ad;
3564 if (get_fp_ad(opcode, &ad)) {
3565 to_fpsr();
3566 put_long (ad, regs.fpsr);
3567 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3568 put_long (ad+4, regs.fpiar);
3569 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3570 m68k_areg (regs, opcode & 7) = ad+8;
3571 dump_fp_regs( "END ");
3572 }
3573 }
3574
3575 void REGPARAM2 fpuop_fmovem_fpcr_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3576 {
3577 uae_u32 ad;
3578 if (get_fp_ad(opcode, &ad)) {
3579 put_long (ad, regs.fpcr);
3580 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3581 m68k_areg (regs, opcode & 7) = ad+4;
3582 dump_fp_regs( "END ");
3583 }
3584 }
3585
3586 void REGPARAM2 fpuop_fmovem_fpcr_fpiar_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3587 {
3588 uae_u32 ad;
3589 if (get_fp_ad(opcode, &ad)) {
3590 put_long (ad, regs.fpcr);
3591 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3592 put_long (ad+4, regs.fpiar);
3593 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3594 m68k_areg (regs, opcode & 7) = ad+8;
3595 dump_fp_regs( "END ");
3596 }
3597 }
3598
3599 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3600 {
3601 dump_fp_regs( "END ");
3602 uae_u32 ad;
3603 if (get_fp_ad(opcode, &ad)) {
3604 put_long (ad, regs.fpcr);
3605 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3606 to_fpsr();
3607 put_long (ad+4, regs.fpsr);
3608 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3609 m68k_areg (regs, opcode & 7) = ad+8;
3610 }
3611 }
3612
3613 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem_postincrement( uae_u32 opcode, uae_u16 extra )
3614 {
3615 uae_u32 ad;
3616 if (get_fp_ad(opcode, &ad)) {
3617 put_long (ad, regs.fpcr);
3618 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3619 to_fpsr();
3620 put_long (ad+4, regs.fpsr);
3621 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3622 put_long (ad+8, regs.fpiar);
3623 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+8 ));
3624 m68k_areg (regs, opcode & 7) = ad+12;
3625 dump_fp_regs( "END ");
3626 }
3627 }
3628
3629
3630 /* ---------------------------- CONTROL REGS -> MEMORY ---------------------------- */
3631
3632 void REGPARAM2 fpuop_fmovem_none_2_Mem( uae_u32 opcode, uae_u16 extra )
3633 {
3634 D(bug("FMOVEM Control regs (none) -> mem\r\n" ));
3635 dump_fp_regs( "END ");
3636 }
3637
3638 void REGPARAM2 fpuop_fmovem_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3639 {
3640 uae_u32 ad;
3641 if (get_fp_ad(opcode, &ad)) {
3642 put_long (ad, regs.fpiar);
3643 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad ));
3644 dump_fp_regs( "END ");
3645 }
3646 }
3647
3648 void REGPARAM2 fpuop_fmovem_fpsr_2_Mem( uae_u32 opcode, uae_u16 extra )
3649 {
3650 uae_u32 ad;
3651 if (get_fp_ad(opcode, &ad)) {
3652 to_fpsr();
3653 put_long (ad, regs.fpsr);
3654 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3655 dump_fp_regs( "END ");
3656 }
3657 }
3658
3659 void REGPARAM2 fpuop_fmovem_fpsr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3660 {
3661 uae_u32 ad;
3662 if (get_fp_ad(opcode, &ad)) {
3663 to_fpsr();
3664 put_long (ad, regs.fpsr);
3665 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad ));
3666 put_long (ad+4, regs.fpiar);
3667 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3668 dump_fp_regs( "END ");
3669 }
3670 }
3671
3672 void REGPARAM2 fpuop_fmovem_fpcr_2_Mem( uae_u32 opcode, uae_u16 extra )
3673 {
3674 uae_u32 ad;
3675 if (get_fp_ad(opcode, &ad)) {
3676 put_long (ad, regs.fpcr);
3677 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3678 dump_fp_regs( "END ");
3679 }
3680 }
3681
3682 void REGPARAM2 fpuop_fmovem_fpcr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3683 {
3684 uae_u32 ad;
3685 if (get_fp_ad(opcode, &ad)) {
3686 put_long (ad, regs.fpcr);
3687 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3688 put_long (ad+4, regs.fpiar);
3689 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+4 ));
3690 dump_fp_regs( "END ");
3691 }
3692 }
3693
3694 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_2_Mem( uae_u32 opcode, uae_u16 extra )
3695 {
3696 uae_u32 ad;
3697 if (get_fp_ad(opcode, &ad)) {
3698 put_long (ad, regs.fpcr);
3699 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3700 to_fpsr();
3701 put_long (ad+4, regs.fpsr);
3702 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3703 dump_fp_regs( "END ");
3704 }
3705 }
3706
3707 void REGPARAM2 fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3708 {
3709 uae_u32 ad;
3710 if (get_fp_ad(opcode, &ad)) {
3711 put_long (ad, regs.fpcr);
3712 D(bug("FMOVEM regs.fpcr (%X) -> mem %X\r\n", regs.fpcr, ad ));
3713 to_fpsr();
3714 put_long (ad+4, regs.fpsr);
3715 D(bug("FMOVEM regs.fpsr (%X) -> mem %X\r\n", regs.fpsr, ad+4 ));
3716 put_long (ad+8, regs.fpiar);
3717 D(bug("FMOVEM regs.fpiar (%X) -> mem %X\r\n", regs.fpiar, ad+8 ));
3718 dump_fp_regs( "END ");
3719 }
3720 }
3721
3722
3723 /* ---------------------------- --MEMORY -> CONTROL REGS ---------------------------- */
3724
3725 void REGPARAM2 fpuop_fmovem_Mem_2_none_predecrement( uae_u32 opcode, uae_u16 extra )
3726 {
3727 D(bug("FMOVEM --Mem -> control(none)\r\n"));
3728 dump_fp_regs( "END ");
3729 }
3730
3731 void REGPARAM2 fpuop_fmovem_Mem_2_fpiar_predecrement( uae_u32 opcode, uae_u16 extra )
3732 {
3733 uae_u32 ad;
3734 if (get_fp_ad(opcode, &ad)) {
3735 ad -= 4;
3736 regs.fpiar = get_long (ad);
3737 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad, regs.fpiar ));
3738 m68k_areg (regs, opcode & 7) = ad;
3739 dump_fp_regs( "END ");
3740 }
3741 }
3742
3743 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_predecrement( uae_u32 opcode, uae_u16 extra )
3744 {
3745 uae_u32 ad;
3746 if (get_fp_ad(opcode, &ad)) {
3747 ad -= 4;
3748 regs.fpsr = get_long (ad);
3749 from_fpsr();
3750 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3751 m68k_areg (regs, opcode & 7) = ad;
3752 dump_fp_regs( "END ");
3753 }
3754 }
3755
3756 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_fpiar_predecrement( uae_u32 opcode, uae_u16 extra )
3757 {
3758 uae_u32 ad;
3759 if (get_fp_ad(opcode, &ad)) {
3760 ad -= 8;
3761 regs.fpsr = get_long (ad);
3762 from_fpsr();
3763 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3764 regs.fpiar = get_long (ad+4);
3765 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
3766 m68k_areg (regs, opcode & 7) = ad;
3767 dump_fp_regs( "END ");
3768 }
3769 }
3770
3771 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_predecrement( uae_u32 opcode, uae_u16 extra )
3772 {
3773 uae_u32 ad;
3774 if (get_fp_ad(opcode, &ad)) {
3775 ad -= 4;
3776 regs.fpcr = get_long (ad);
3777 set_host_fpu_control_word();
3778 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3779 m68k_areg (regs, opcode & 7) = ad;
3780 dump_fp_regs( "END ");
3781 }
3782 }
3783
3784 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpiar_predecrement( uae_u32 opcode, uae_u16 extra )
3785 {
3786 uae_u32 ad;
3787 if (get_fp_ad(opcode, &ad)) {
3788 ad -= 8;
3789 regs.fpcr = get_long (ad);
3790 set_host_fpu_control_word();
3791 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3792 regs.fpiar = get_long (ad+4);
3793 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
3794 m68k_areg (regs, opcode & 7) = ad;
3795 dump_fp_regs( "END ");
3796 }
3797 }
3798
3799 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_predecrement( uae_u32 opcode, uae_u16 extra )
3800 {
3801 uae_u32 ad;
3802 if (get_fp_ad(opcode, &ad)) {
3803 ad -= 8;
3804 regs.fpcr = get_long (ad);
3805 set_host_fpu_control_word();
3806 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3807 regs.fpsr = get_long (ad+4);
3808 from_fpsr();
3809 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
3810 m68k_areg (regs, opcode & 7) = ad;
3811 dump_fp_regs( "END ");
3812 }
3813 }
3814
3815 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_predecrement( uae_u32 opcode, uae_u16 extra )
3816 {
3817 uae_u32 ad;
3818 if (get_fp_ad(opcode, &ad)) {
3819 ad -= 12;
3820 regs.fpcr = get_long (ad);
3821 set_host_fpu_control_word();
3822 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3823 regs.fpsr = get_long (ad+4);
3824 from_fpsr();
3825 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
3826 regs.fpiar = get_long (ad+8);
3827 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+8, regs.fpiar ));
3828 m68k_areg (regs, opcode & 7) = ad;
3829 dump_fp_regs( "END ");
3830 }
3831 }
3832
3833
3834 /* ---------------------------- CONTROL REGS -> MEMORY++ ---------------------------- */
3835
3836 void REGPARAM2 fpuop_fmovem_Mem_2_none_postincrement( uae_u32 opcode, uae_u16 extra )
3837 {
3838 D(bug("FMOVEM Mem++ -> control(none)\r\n"));
3839 dump_fp_regs( "END ");
3840 }
3841
3842 void REGPARAM2 fpuop_fmovem_Mem_2_fpiar_postincrement( uae_u32 opcode, uae_u16 extra )
3843 {
3844 uae_u32 ad;
3845 if (get_fp_ad(opcode, &ad)) {
3846 regs.fpiar = get_long (ad);
3847 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad, regs.fpiar ));
3848 m68k_areg (regs, opcode & 7) = ad+4;
3849 dump_fp_regs( "END ");
3850 }
3851 }
3852
3853 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_postincrement( uae_u32 opcode, uae_u16 extra )
3854 {
3855 uae_u32 ad;
3856 if (get_fp_ad(opcode, &ad)) {
3857 regs.fpsr = get_long (ad);
3858 from_fpsr();
3859 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3860 m68k_areg (regs, opcode & 7) = ad+4;
3861 dump_fp_regs( "END ");
3862 }
3863 }
3864
3865 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_fpiar_postincrement( uae_u32 opcode, uae_u16 extra )
3866 {
3867 uae_u32 ad;
3868 if (get_fp_ad(opcode, &ad)) {
3869 regs.fpsr = get_long (ad);
3870 from_fpsr();
3871 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3872 regs.fpiar = get_long (ad+4);
3873 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
3874 m68k_areg (regs, opcode & 7) = ad+8;
3875 dump_fp_regs( "END ");
3876 }
3877 }
3878
3879 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_postincrement( uae_u32 opcode, uae_u16 extra )
3880 {
3881 uae_u32 ad;
3882 if (get_fp_ad(opcode, &ad)) {
3883 regs.fpcr = get_long (ad);
3884 set_host_fpu_control_word();
3885 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3886 m68k_areg (regs, opcode & 7) = ad+4;
3887 dump_fp_regs( "END ");
3888 }
3889 }
3890
3891 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpiar_postincrement( uae_u32 opcode, uae_u16 extra )
3892 {
3893 uae_u32 ad;
3894 if (get_fp_ad(opcode, &ad)) {
3895 regs.fpcr = get_long (ad);
3896 set_host_fpu_control_word();
3897 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3898 regs.fpiar = get_long (ad+4);
3899 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
3900 m68k_areg (regs, opcode & 7) = ad+8;
3901 dump_fp_regs( "END ");
3902 }
3903 }
3904
3905 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_postincrement( uae_u32 opcode, uae_u16 extra )
3906 {
3907 uae_u32 ad;
3908 if (get_fp_ad(opcode, &ad)) {
3909 regs.fpcr = get_long (ad);
3910 set_host_fpu_control_word();
3911 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3912 regs.fpsr = get_long (ad+4);
3913 from_fpsr();
3914 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
3915 m68k_areg (regs, opcode & 7) = ad+8;
3916 dump_fp_regs( "END ");
3917 }
3918 }
3919
3920 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_postincrement( uae_u32 opcode, uae_u16 extra )
3921 {
3922 uae_u32 ad;
3923 if (get_fp_ad(opcode, &ad)) {
3924 regs.fpcr = get_long (ad);
3925 set_host_fpu_control_word();
3926 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
3927 regs.fpsr = get_long (ad+4);
3928 from_fpsr();
3929 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
3930 regs.fpiar = get_long (ad+8);
3931 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+8, regs.fpiar ));
3932 m68k_areg (regs, opcode & 7) = ad+12;
3933 dump_fp_regs( "END ");
3934 }
3935 }
3936
3937
3938 /* ---------------------------- MEMORY -> CONTROL REGS ---------------------------- */
3939 /* ---------------------------- and ---------------------------- */
3940 /* ---------------------------- IMMEDIATE -> CONTROL REGS ---------------------------- */
3941
3942 void REGPARAM2 fpuop_fmovem_Mem_2_none_2_Mem( uae_u32 opcode, uae_u16 extra )
3943 {
3944 D(bug("FMOVEM Mem -> control(none)\r\n"));
3945 dump_fp_regs( "END ");
3946 }
3947
3948 void REGPARAM2 fpuop_fmovem_Mem_2_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3949 {
3950 if ((opcode & 0x3f) == 0x3c) {
3951 regs.fpiar = next_ilong();
3952 D(bug("FMOVEM #<%X> -> regs.fpiar\r\n", regs.fpiar));
3953 } else {
3954 uae_u32 ad;
3955 if (get_fp_ad(opcode, &ad)) {
3956 regs.fpiar = get_long (ad);
3957 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad, regs.fpiar ));
3958 }
3959 }
3960 dump_fp_regs( "END ");
3961 }
3962
3963 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_2_Mem( uae_u32 opcode, uae_u16 extra )
3964 {
3965 if ((opcode & 0x3f) == 0x3c) {
3966 regs.fpsr = next_ilong();
3967 from_fpsr();
3968 D(bug("FMOVEM #<%X> -> regs.fpsr\r\n", regs.fpsr));
3969 } else {
3970 uae_u32 ad;
3971 if (get_fp_ad(opcode, &ad)) {
3972 regs.fpsr = get_long (ad);
3973 from_fpsr();
3974 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3975 }
3976 }
3977 dump_fp_regs( "END ");
3978 }
3979
3980 void REGPARAM2 fpuop_fmovem_Mem_2_fpsr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
3981 {
3982 if ((opcode & 0x3f) == 0x3c) {
3983 regs.fpsr = next_ilong();
3984 from_fpsr();
3985 D(bug("FMOVEM #<%X> -> regs.fpsr\r\n", regs.fpsr));
3986 regs.fpiar = next_ilong();
3987 D(bug("FMOVEM #<%X> -> regs.fpiar\r\n", regs.fpiar));
3988 } else {
3989 uae_u32 ad;
3990 if (get_fp_ad(opcode, &ad)) {
3991 regs.fpsr = get_long (ad);
3992 from_fpsr();
3993 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad, regs.fpsr ));
3994 regs.fpiar = get_long (ad+4);
3995 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
3996 }
3997 }
3998 dump_fp_regs( "END ");
3999 }
4000
4001 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_2_Mem( uae_u32 opcode, uae_u16 extra )
4002 {
4003 if ((opcode & 0x3f) == 0x3c) {
4004 regs.fpcr = next_ilong();
4005 set_host_fpu_control_word();
4006 D(bug("FMOVEM #<%X> -> regs.fpcr\r\n", regs.fpcr));
4007 } else {
4008 uae_u32 ad;
4009 if (get_fp_ad(opcode, &ad)) {
4010 regs.fpcr = get_long (ad);
4011 set_host_fpu_control_word();
4012 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
4013 }
4014 }
4015 dump_fp_regs( "END ");
4016 }
4017
4018 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
4019 {
4020 if ((opcode & 0x3f) == 0x3c) {
4021 regs.fpcr = next_ilong();
4022 set_host_fpu_control_word();
4023 D(bug("FMOVEM #<%X> -> regs.fpcr\r\n", regs.fpcr));
4024 regs.fpiar = next_ilong();
4025 D(bug("FMOVEM #<%X> -> regs.fpiar\r\n", regs.fpiar));
4026 } else {
4027 uae_u32 ad;
4028 if (get_fp_ad(opcode, &ad)) {
4029 regs.fpcr = get_long (ad);
4030 set_host_fpu_control_word();
4031 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
4032 regs.fpiar = get_long (ad+4);
4033 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+4, regs.fpiar ));
4034 }
4035 }
4036 dump_fp_regs( "END ");
4037 }
4038
4039 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_2_Mem( uae_u32 opcode, uae_u16 extra )
4040 {
4041 if ((opcode & 0x3f) == 0x3c) {
4042 regs.fpcr = next_ilong();
4043 set_host_fpu_control_word();
4044 D(bug("FMOVEM #<%X> -> regs.fpcr\r\n", regs.fpcr));
4045 regs.fpsr = next_ilong();
4046 from_fpsr();
4047 D(bug("FMOVEM #<%X> -> regs.fpsr\r\n", regs.fpsr));
4048 } else {
4049 uae_u32 ad;
4050 if (get_fp_ad(opcode, &ad)) {
4051 regs.fpcr = get_long (ad);
4052 set_host_fpu_control_word();
4053 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
4054 regs.fpsr = get_long (ad+4);
4055 from_fpsr();
4056 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
4057 }
4058 }
4059 dump_fp_regs( "END ");
4060 }
4061
4062 void REGPARAM2 fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_2_Mem( uae_u32 opcode, uae_u16 extra )
4063 {
4064 if ((opcode & 0x3f) == 0x3c) {
4065 regs.fpcr = next_ilong();
4066 set_host_fpu_control_word();
4067 D(bug("FMOVEM #<%X> -> regs.fpcr\r\n", regs.fpcr));
4068 regs.fpsr = next_ilong();
4069 from_fpsr();
4070 D(bug("FMOVEM #<%X> -> regs.fpsr\r\n", regs.fpsr));
4071 regs.fpiar = next_ilong();
4072 D(bug("FMOVEM #<%X> -> regs.fpiar\r\n", regs.fpiar));
4073 } else {
4074 uae_u32 ad;
4075 if (get_fp_ad(opcode, &ad)) {
4076 regs.fpcr = get_long (ad);
4077 set_host_fpu_control_word();
4078 D(bug("FMOVEM mem %X (%X) -> regs.fpcr\r\n", ad, regs.fpcr ));
4079 regs.fpsr = get_long (ad+4);
4080 from_fpsr();
4081 D(bug("FMOVEM mem %X (%X) -> regs.fpsr\r\n", ad+4, regs.fpsr ));
4082 regs.fpiar = get_long (ad+8);
4083 D(bug("FMOVEM mem %X (%X) -> regs.fpiar\r\n", ad+8, regs.fpiar ));
4084 }
4085 }
4086 dump_fp_regs( "END ");
4087 }
4088
4089
4090 /* ---------------------------- FMOVEM MEMORY -> FPP ---------------------------- */
4091
4092 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_pred_postincrement( uae_u32 opcode, uae_u16 extra )
4093 {
4094 uae_u32 ad, list = extra & 0xff;
4095 D(bug("FMOVEM memory->FPP\r\n"));
4096 if (get_fp_ad(opcode, &ad)) {
4097 for( int reg=7; reg>=0; reg-- ) {
4098 uae_u32 wrd1, wrd2, wrd3;
4099 if( list & 0x80 ) {
4100 ad -= 4;
4101 wrd3 = get_long (ad);
4102 ad -= 4;
4103 wrd2 = get_long (ad);
4104 ad -= 4;
4105 wrd1 = get_long (ad);
4106 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4107 }
4108 list <<= 1;
4109 }
4110 m68k_areg (regs, opcode & 7) = ad;
4111 dump_fp_regs( "END ");
4112 }
4113 }
4114
4115 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_pred_predecrement( uae_u32 opcode, uae_u16 extra )
4116 {
4117 uae_u32 ad, list = extra & 0xff;
4118 D(bug("FMOVEM memory->FPP\r\n"));
4119 if (get_fp_ad(opcode, &ad)) {
4120 for( int reg=7; reg>=0; reg-- ) {
4121 uae_u32 wrd1, wrd2, wrd3;
4122 if( list & 0x80 ) {
4123 ad -= 4;
4124 wrd3 = get_long (ad);
4125 ad -= 4;
4126 wrd2 = get_long (ad);
4127 ad -= 4;
4128 wrd1 = get_long (ad);
4129 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4130 }
4131 list <<= 1;
4132 }
4133 m68k_areg (regs, opcode & 7) = ad;
4134 dump_fp_regs( "END ");
4135 }
4136 }
4137
4138 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_pred( uae_u32 opcode, uae_u16 extra )
4139 {
4140 uae_u32 ad, list = extra & 0xff;
4141 D(bug("FMOVEM memory->FPP\r\n"));
4142 if (get_fp_ad(opcode, &ad)) {
4143 for( int reg=7; reg>=0; reg-- ) {
4144 uae_u32 wrd1, wrd2, wrd3;
4145 if( list & 0x80 ) {
4146 ad -= 4;
4147 wrd3 = get_long (ad);
4148 ad -= 4;
4149 wrd2 = get_long (ad);
4150 ad -= 4;
4151 wrd1 = get_long (ad);
4152 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4153 }
4154 list <<= 1;
4155 }
4156 dump_fp_regs( "END ");
4157 }
4158 }
4159
4160 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_pred_postincrement( uae_u32 opcode, uae_u16 extra )
4161 {
4162 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4163 D(bug("FMOVEM memory->FPP\r\n"));
4164 if (get_fp_ad(opcode, &ad)) {
4165 for( int reg=7; reg>=0; reg-- ) {
4166 uae_u32 wrd1, wrd2, wrd3;
4167 if( list & 0x80 ) {
4168 ad -= 4;
4169 wrd3 = get_long (ad);
4170 ad -= 4;
4171 wrd2 = get_long (ad);
4172 ad -= 4;
4173 wrd1 = get_long (ad);
4174 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4175 }
4176 list <<= 1;
4177 }
4178 m68k_areg (regs, opcode & 7) = ad;
4179 dump_fp_regs( "END ");
4180 }
4181 }
4182
4183 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_pred_predecrement( uae_u32 opcode, uae_u16 extra )
4184 {
4185 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4186 D(bug("FMOVEM memory->FPP\r\n"));
4187 if (get_fp_ad(opcode, &ad)) {
4188 for( int reg=7; reg>=0; reg-- ) {
4189 uae_u32 wrd1, wrd2, wrd3;
4190 if( list & 0x80 ) {
4191 ad -= 4;
4192 wrd3 = get_long (ad);
4193 ad -= 4;
4194 wrd2 = get_long (ad);
4195 ad -= 4;
4196 wrd1 = get_long (ad);
4197 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4198 }
4199 list <<= 1;
4200 }
4201 m68k_areg (regs, opcode & 7) = ad;
4202 dump_fp_regs( "END ");
4203 }
4204 }
4205
4206 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_pred( uae_u32 opcode, uae_u16 extra )
4207 {
4208 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4209 D(bug("FMOVEM memory->FPP\r\n"));
4210 if (get_fp_ad(opcode, &ad)) {
4211 for( int reg=7; reg>=0; reg-- ) {
4212 uae_u32 wrd1, wrd2, wrd3;
4213 if( list & 0x80 ) {
4214 ad -= 4;
4215 wrd3 = get_long (ad);
4216 ad -= 4;
4217 wrd2 = get_long (ad);
4218 ad -= 4;
4219 wrd1 = get_long (ad);
4220 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4221 }
4222 list <<= 1;
4223 }
4224 dump_fp_regs( "END ");
4225 }
4226 }
4227
4228 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_postinc_postincrement( uae_u32 opcode, uae_u16 extra )
4229 {
4230 uae_u32 ad, list = extra & 0xff;
4231 D(bug("FMOVEM memory->FPP\r\n"));
4232 if (get_fp_ad(opcode, &ad)) {
4233 for( int reg=0; reg<8; reg++ ) {
4234 uae_u32 wrd1, wrd2, wrd3;
4235 if( list & 0x80 ) {
4236 wrd1 = get_long (ad);
4237 ad += 4;
4238 wrd2 = get_long (ad);
4239 ad += 4;
4240 wrd3 = get_long (ad);
4241 ad += 4;
4242 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4243 }
4244 list <<= 1;
4245 }
4246 m68k_areg (regs, opcode & 7) = ad;
4247 dump_fp_regs( "END ");
4248 }
4249 }
4250
4251 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_postinc_predecrement( uae_u32 opcode, uae_u16 extra )
4252 {
4253 uae_u32 ad, list = extra & 0xff;
4254 D(bug("FMOVEM memory->FPP\r\n"));
4255 if (get_fp_ad(opcode, &ad)) {
4256 for( int reg=0; reg<8; reg++ ) {
4257 uae_u32 wrd1, wrd2, wrd3;
4258 if( list & 0x80 ) {
4259 wrd1 = get_long (ad);
4260 ad += 4;
4261 wrd2 = get_long (ad);
4262 ad += 4;
4263 wrd3 = get_long (ad);
4264 ad += 4;
4265 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4266 }
4267 list <<= 1;
4268 }
4269 m68k_areg (regs, opcode & 7) = ad;
4270 dump_fp_regs( "END ");
4271 }
4272 }
4273
4274 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_static_postinc( uae_u32 opcode, uae_u16 extra )
4275 {
4276 uae_u32 ad, list = extra & 0xff;
4277 D(bug("FMOVEM memory->FPP\r\n"));
4278 if (get_fp_ad(opcode, &ad)) {
4279 for( int reg=0; reg<8; reg++ ) {
4280 uae_u32 wrd1, wrd2, wrd3;
4281 if( list & 0x80 ) {
4282 wrd1 = get_long (ad);
4283 ad += 4;
4284 wrd2 = get_long (ad);
4285 ad += 4;
4286 wrd3 = get_long (ad);
4287 ad += 4;
4288 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4289 }
4290 list <<= 1;
4291 }
4292 dump_fp_regs( "END ");
4293 }
4294 }
4295
4296 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_postinc_postincrement( uae_u32 opcode, uae_u16 extra )
4297 {
4298 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4299 D(bug("FMOVEM memory->FPP\r\n"));
4300 if (get_fp_ad(opcode, &ad)) {
4301 for( int reg=0; reg<8; reg++ ) {
4302 uae_u32 wrd1, wrd2, wrd3;
4303 if( list & 0x80 ) {
4304 wrd1 = get_long (ad);
4305 ad += 4;
4306 wrd2 = get_long (ad);
4307 ad += 4;
4308 wrd3 = get_long (ad);
4309 ad += 4;
4310 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4311 }
4312 list <<= 1;
4313 }
4314 m68k_areg (regs, opcode & 7) = ad;
4315 dump_fp_regs( "END ");
4316 }
4317 }
4318
4319 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_postinc_predecrement( uae_u32 opcode, uae_u16 extra )
4320 {
4321 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4322 D(bug("FMOVEM memory->FPP\r\n"));
4323 if (get_fp_ad(opcode, &ad)) {
4324 for( int reg=0; reg<8; reg++ ) {
4325 uae_u32 wrd1, wrd2, wrd3;
4326 if( list & 0x80 ) {
4327 wrd1 = get_long (ad);
4328 ad += 4;
4329 wrd2 = get_long (ad);
4330 ad += 4;
4331 wrd3 = get_long (ad);
4332 ad += 4;
4333 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4334 }
4335 list <<= 1;
4336 }
4337 m68k_areg (regs, opcode & 7) = ad;
4338 dump_fp_regs( "END ");
4339 }
4340 }
4341
4342 void REGPARAM2 fpuop_fmovem_Mem_2_fpp_dynamic_postinc( uae_u32 opcode, uae_u16 extra )
4343 {
4344 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4345 D(bug("FMOVEM memory->FPP\r\n"));
4346 if (get_fp_ad(opcode, &ad)) {
4347 for( int reg=0; reg<8; reg++ ) {
4348 uae_u32 wrd1, wrd2, wrd3;
4349 if( list & 0x80 ) {
4350 wrd1 = get_long (ad);
4351 ad += 4;
4352 wrd2 = get_long (ad);
4353 ad += 4;
4354 wrd3 = get_long (ad);
4355 ad += 4;
4356 to_exten_no_normalize (wrd1, wrd2, wrd3,fp_reg[reg]);
4357 }
4358 list <<= 1;
4359 }
4360 dump_fp_regs( "END ");
4361 }
4362 }
4363
4364
4365 /* ---------------------------- FPP -> FMOVEM MEMORY ---------------------------- */
4366
4367 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_pred_postincrement( uae_u32 opcode, uae_u16 extra )
4368 {
4369 uae_u32 ad, list = extra & 0xff;
4370 D(bug("FMOVEM FPP->memory\r\n"));
4371 if (get_fp_ad(opcode, &ad)) {
4372 for( int reg=7; reg>=0; reg-- ) {
4373 uae_u32 wrd1, wrd2, wrd3;
4374 if( list & 0x80 ) {
4375 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4376 ad -= 4;
4377 put_long (ad, wrd3);
4378 ad -= 4;
4379 put_long (ad, wrd2);
4380 ad -= 4;
4381 put_long (ad, wrd1);
4382 }
4383 list <<= 1;
4384 }
4385 m68k_areg (regs, opcode & 7) = ad;
4386 dump_fp_regs( "END ");
4387 }
4388 }
4389 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_pred_predecrement( uae_u32 opcode, uae_u16 extra )
4390 {
4391 uae_u32 ad, list = extra & 0xff;
4392 D(bug("FMOVEM FPP->memory\r\n"));
4393 if (get_fp_ad(opcode, &ad)) {
4394 for( int reg=7; reg>=0; reg-- ) {
4395 uae_u32 wrd1, wrd2, wrd3;
4396 if( list & 0x80 ) {
4397 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4398 ad -= 4;
4399 put_long (ad, wrd3);
4400 ad -= 4;
4401 put_long (ad, wrd2);
4402 ad -= 4;
4403 put_long (ad, wrd1);
4404 }
4405 list <<= 1;
4406 }
4407 m68k_areg (regs, opcode & 7) = ad;
4408 dump_fp_regs( "END ");
4409 }
4410 }
4411 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_pred( uae_u32 opcode, uae_u16 extra )
4412 {
4413 uae_u32 ad, list = extra & 0xff;
4414 D(bug("FMOVEM FPP->memory\r\n"));
4415 if (get_fp_ad(opcode, &ad)) {
4416 for( int reg=7; reg>=0; reg-- ) {
4417 uae_u32 wrd1, wrd2, wrd3;
4418 if( list & 0x80 ) {
4419 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4420 ad -= 4;
4421 put_long (ad, wrd3);
4422 ad -= 4;
4423 put_long (ad, wrd2);
4424 ad -= 4;
4425 put_long (ad, wrd1);
4426 }
4427 list <<= 1;
4428 }
4429 dump_fp_regs( "END ");
4430 }
4431 }
4432 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_pred_postincrement( uae_u32 opcode, uae_u16 extra )
4433 {
4434 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4435 D(bug("FMOVEM FPP->memory\r\n"));
4436 if (get_fp_ad(opcode, &ad)) {
4437 for( int reg=7; reg>=0; reg-- ) {
4438 uae_u32 wrd1, wrd2, wrd3;
4439 if( list & 0x80 ) {
4440 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4441 ad -= 4;
4442 put_long (ad, wrd3);
4443 ad -= 4;
4444 put_long (ad, wrd2);
4445 ad -= 4;
4446 put_long (ad, wrd1);
4447 }
4448 list <<= 1;
4449 }
4450 m68k_areg (regs, opcode & 7) = ad;
4451 dump_fp_regs( "END ");
4452 }
4453 }
4454 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_pred_predecrement( uae_u32 opcode, uae_u16 extra )
4455 {
4456 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4457 D(bug("FMOVEM FPP->memory\r\n"));
4458 if (get_fp_ad(opcode, &ad)) {
4459 for( int reg=7; reg>=0; reg-- ) {
4460 uae_u32 wrd1, wrd2, wrd3;
4461 if( list & 0x80 ) {
4462 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4463 ad -= 4;
4464 put_long (ad, wrd3);
4465 ad -= 4;
4466 put_long (ad, wrd2);
4467 ad -= 4;
4468 put_long (ad, wrd1);
4469 }
4470 list <<= 1;
4471 }
4472 m68k_areg (regs, opcode & 7) = ad;
4473 dump_fp_regs( "END ");
4474 }
4475 }
4476 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_pred( uae_u32 opcode, uae_u16 extra )
4477 {
4478 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4479 D(bug("FMOVEM FPP->memory\r\n"));
4480 if (get_fp_ad(opcode, &ad)) {
4481 for( int reg=7; reg>=0; reg-- ) {
4482 uae_u32 wrd1, wrd2, wrd3;
4483 if( list & 0x80 ) {
4484 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4485 ad -= 4;
4486 put_long (ad, wrd3);
4487 ad -= 4;
4488 put_long (ad, wrd2);
4489 ad -= 4;
4490 put_long (ad, wrd1);
4491 }
4492 list <<= 1;
4493 }
4494 dump_fp_regs( "END ");
4495 }
4496 }
4497 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_postinc_postincrement( uae_u32 opcode, uae_u16 extra )
4498 {
4499 uae_u32 ad, list = extra & 0xff;
4500 D(bug("FMOVEM FPP->memory\r\n"));
4501 if (get_fp_ad(opcode, &ad)) {
4502 for( int reg=0; reg<8; reg++ ) {
4503 uae_u32 wrd1, wrd2, wrd3;
4504 if( list & 0x80 ) {
4505 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4506 put_long (ad, wrd1);
4507 ad += 4;
4508 put_long (ad, wrd2);
4509 ad += 4;
4510 put_long (ad, wrd3);
4511 ad += 4;
4512 }
4513 list <<= 1;
4514 }
4515 m68k_areg (regs, opcode & 7) = ad;
4516 dump_fp_regs( "END ");
4517 }
4518 }
4519 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_postinc_predecrement( uae_u32 opcode, uae_u16 extra )
4520 {
4521 uae_u32 ad, list = extra & 0xff;
4522 D(bug("FMOVEM FPP->memory\r\n"));
4523 if (get_fp_ad(opcode, &ad)) {
4524 for( int reg=0; reg<8; reg++ ) {
4525 uae_u32 wrd1, wrd2, wrd3;
4526 if( list & 0x80 ) {
4527 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4528 put_long (ad, wrd1);
4529 ad += 4;
4530 put_long (ad, wrd2);
4531 ad += 4;
4532 put_long (ad, wrd3);
4533 ad += 4;
4534 }
4535 list <<= 1;
4536 }
4537 m68k_areg (regs, opcode & 7) = ad;
4538 dump_fp_regs( "END ");
4539 }
4540 }
4541 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_static_postinc( uae_u32 opcode, uae_u16 extra )
4542 {
4543 uae_u32 ad, list = extra & 0xff;
4544 D(bug("FMOVEM FPP->memory\r\n"));
4545 if (get_fp_ad(opcode, &ad)) {
4546 for( int reg=0; reg<8; reg++ ) {
4547 uae_u32 wrd1, wrd2, wrd3;
4548 if( list & 0x80 ) {
4549 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4550 put_long (ad, wrd1);
4551 ad += 4;
4552 put_long (ad, wrd2);
4553 ad += 4;
4554 put_long (ad, wrd3);
4555 ad += 4;
4556 }
4557 list <<= 1;
4558 }
4559 dump_fp_regs( "END ");
4560 }
4561 }
4562 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_postinc_postincrement( uae_u32 opcode, uae_u16 extra )
4563 {
4564 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4565 D(bug("FMOVEM FPP->memory\r\n"));
4566 if (get_fp_ad(opcode, &ad)) {
4567 for( int reg=0; reg<8; reg++ ) {
4568 uae_u32 wrd1, wrd2, wrd3;
4569 if( list & 0x80 ) {
4570 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4571 put_long (ad, wrd1);
4572 ad += 4;
4573 put_long (ad, wrd2);
4574 ad += 4;
4575 put_long (ad, wrd3);
4576 ad += 4;
4577 }
4578 list <<= 1;
4579 }
4580 m68k_areg (regs, opcode & 7) = ad;
4581 dump_fp_regs( "END ");
4582 }
4583 }
4584 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_postinc_predecrement( uae_u32 opcode, uae_u16 extra )
4585 {
4586 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4587 D(bug("FMOVEM FPP->memory\r\n"));
4588 if (get_fp_ad(opcode, &ad)) {
4589 for( int reg=0; reg<8; reg++ ) {
4590 uae_u32 wrd1, wrd2, wrd3;
4591 if( list & 0x80 ) {
4592 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4593 put_long (ad, wrd1);
4594 ad += 4;
4595 put_long (ad, wrd2);
4596 ad += 4;
4597 put_long (ad, wrd3);
4598 ad += 4;
4599 }
4600 list <<= 1;
4601 }
4602 m68k_areg (regs, opcode & 7) = ad;
4603 dump_fp_regs( "END ");
4604 }
4605 }
4606 void REGPARAM2 fpuop_fmovem_fpp_2_Mem_dynamic_postinc( uae_u32 opcode, uae_u16 extra )
4607 {
4608 uae_u32 ad, list = m68k_dreg (regs, (extra >> 4) & 3) & 0xff;
4609 D(bug("FMOVEM FPP->memory\r\n"));
4610 if (get_fp_ad(opcode, &ad)) {
4611 for( int reg=0; reg<8; reg++ ) {
4612 uae_u32 wrd1, wrd2, wrd3;
4613 if( list & 0x80 ) {
4614 from_exten(fp_reg[reg],&wrd1, &wrd2, &wrd3);
4615 put_long (ad, wrd1);
4616 ad += 4;
4617 put_long (ad, wrd2);
4618 ad += 4;
4619 put_long (ad, wrd3);
4620 ad += 4;
4621 }
4622 list <<= 1;
4623 }
4624 dump_fp_regs( "END ");
4625 }
4626 }
4627
4628
4629 /* ---------------------------- FMOVEM CONSTANT ROM -> FPP ---------------------------- */
4630
4631 void REGPARAM2 fpuop_do_fldpi( uae_u32 opcode, uae_u16 extra )
4632 {
4633 D(bug("FMOVECR memory->FPP FP const: Pi\r\n"));
4634 memcpy( fp_reg[(extra>>7) & 7], const_pi, sizeof(float80_s) );
4635 sw = SW_FINITE | INEX2;
4636 dump_fp_regs( "END ");
4637 }
4638
4639 void REGPARAM2 fpuop_do_fldlg2( uae_u32 opcode, uae_u16 extra )
4640 {
4641 D(bug("FMOVECR memory->FPP FP const: Log 10 (2)\r\n"));
4642 memcpy( fp_reg[(extra>>7) & 7], const_lg2, sizeof(float80_s) );
4643 sw = SW_FINITE | INEX2;
4644 dump_fp_regs( "END ");
4645 }
4646
4647 void REGPARAM2 fpuop_do_load_const_e( uae_u32 opcode, uae_u16 extra )
4648 {
4649 D(bug("FMOVECR memory->FPP FP const: e\r\n"));
4650 memcpy( fp_reg[(extra>>7) & 7], const_e, sizeof(float80_s) );
4651 sw = SW_FINITE | INEX2;
4652 dump_fp_regs( "END ");
4653 }
4654
4655 void REGPARAM2 fpuop_do_fldl2e( uae_u32 opcode, uae_u16 extra )
4656 {
4657 D(bug("FMOVECR memory->FPP FP const: Log 2 (e)\r\n"));
4658 memcpy( fp_reg[(extra>>7) & 7], const_l2e, sizeof(float80_s) );
4659 sw = SW_FINITE | INEX2;
4660 dump_fp_regs( "END ");
4661 }
4662
4663 void REGPARAM2 fpuop_do_load_const_log_10_e( uae_u32 opcode, uae_u16 extra )
4664 {
4665 D(bug("FMOVECR memory->FPP FP const: Log 10 (e)\r\n"));
4666 memcpy( fp_reg[(extra>>7) & 7], const_log_10_e, sizeof(float80_s) );
4667 sw = SW_FINITE | INEX2;
4668 dump_fp_regs( "END ");
4669 }
4670
4671 void REGPARAM2 fpuop_do_fldz( uae_u32 opcode, uae_u16 extra )
4672 {
4673 D(bug("FMOVECR memory->FPP FP const: zero\r\n"));
4674 memcpy( fp_reg[(extra>>7) & 7], const_z, sizeof(float80_s) );
4675 sw = SW_Z;
4676 dump_fp_regs( "END ");
4677 }
4678
4679 void REGPARAM2 fpuop_do_fldln2( uae_u32 opcode, uae_u16 extra )
4680 {
4681 D(bug("FMOVECR memory->FPP FP const: ln(2)\r\n"));
4682 memcpy( fp_reg[(extra>>7) & 7], const_ln2, sizeof(float80_s) );
4683 sw = SW_FINITE | INEX2;
4684 dump_fp_regs( "END ");
4685 }
4686
4687 void REGPARAM2 fpuop_do_load_const_ln_10( uae_u32 opcode, uae_u16 extra )
4688 {
4689 D(bug("FMOVECR memory->FPP FP const: ln(10)\r\n"));
4690 memcpy( fp_reg[(extra>>7) & 7], const_ln_10, sizeof(float80_s) );
4691 sw = SW_FINITE | INEX2;
4692 dump_fp_regs( "END ");
4693 }
4694
4695 void REGPARAM2 fpuop_do_fld1( uae_u32 opcode, uae_u16 extra )
4696 {
4697 D(bug("FMOVECR memory->FPP FP const: 1.0e0\r\n"));
4698 memcpy( fp_reg[(extra>>7) & 7], const_1, sizeof(float80_s) );
4699 sw = SW_FINITE;
4700 dump_fp_regs( "END ");
4701 }
4702
4703 void REGPARAM2 fpuop_do_load_const_1e1( uae_u32 opcode, uae_u16 extra )
4704 {
4705 D(bug("FMOVECR memory->FPP FP const: 1.0e1\r\n"));
4706 memcpy( fp_reg[(extra>>7) & 7], const_1e1, sizeof(float80_s) );
4707 sw = SW_FINITE;
4708 dump_fp_regs( "END ");
4709 }
4710
4711 void REGPARAM2 fpuop_do_load_const_1e2( uae_u32 opcode, uae_u16 extra )
4712 {
4713 D(bug("FMOVECR memory->FPP FP const: 1.0e2\r\n"));
4714 memcpy( fp_reg[(extra>>7) & 7], const_1e2, sizeof(float80_s) );
4715 sw = SW_FINITE;
4716 dump_fp_regs( "END ");
4717 }
4718
4719 void REGPARAM2 fpuop_do_load_const_1e4( uae_u32 opcode, uae_u16 extra )
4720 {
4721 D(bug("FMOVECR memory->FPP FP const: 1.0e4\r\n"));
4722 memcpy( fp_reg[(extra>>7) & 7], const_1e4, sizeof(float80_s) );
4723 sw = SW_FINITE;
4724 dump_fp_regs( "END ");
4725 }
4726
4727 void REGPARAM2 fpuop_do_load_const_1e8( uae_u32 opcode, uae_u16 extra )
4728 {
4729 D(bug("FMOVECR memory->FPP FP const: 1.0e8\r\n"));
4730 memcpy( fp_reg[(extra>>7) & 7], const_1e8, sizeof(float80_s) );
4731 sw = SW_FINITE | INEX2; // Is it really INEX2?
4732 dump_fp_regs( "END ");
4733 }
4734
4735 void REGPARAM2 fpuop_do_load_const_1e16( uae_u32 opcode, uae_u16 extra )
4736 {
4737 D(bug("FMOVECR memory->FPP FP const: 1.0e16\r\n"));
4738 memcpy( fp_reg[(extra>>7) & 7], const_1e16, sizeof(float80_s) );
4739 sw = SW_FINITE | INEX2;
4740 dump_fp_regs( "END ");
4741 }
4742
4743 void REGPARAM2 fpuop_do_load_const_1e32( uae_u32 opcode, uae_u16 extra )
4744 {
4745 D(bug("FMOVECR memory->FPP FP const: 1.0e32\r\n"));
4746 memcpy( fp_reg[(extra>>7) & 7], const_1e32, sizeof(float80_s) );
4747 sw = SW_FINITE | INEX2;
4748 dump_fp_regs( "END ");
4749 }
4750
4751 void REGPARAM2 fpuop_do_load_const_1e64( uae_u32 opcode, uae_u16 extra )
4752 {
4753 D(bug("FMOVECR memory->FPP FP const: 1.0e64\r\n"));
4754 memcpy( fp_reg[(extra>>7) & 7], const_1e64, sizeof(float80_s) );
4755 sw = SW_FINITE | INEX2;
4756 dump_fp_regs( "END ");
4757 }
4758
4759 void REGPARAM2 fpuop_do_load_const_1e128( uae_u32 opcode, uae_u16 extra )
4760 {
4761 D(bug("FMOVECR memory->FPP FP const: 1.0e128\r\n"));
4762 memcpy( fp_reg[(extra>>7) & 7], const_1e128, sizeof(float80_s) );
4763 sw = SW_FINITE | INEX2;
4764 dump_fp_regs( "END ");
4765 }
4766
4767 void REGPARAM2 fpuop_do_load_const_1e256( uae_u32 opcode, uae_u16 extra )
4768 {
4769 D(bug("FMOVECR memory->FPP FP const: 1.0e256\r\n"));
4770 memcpy( fp_reg[(extra>>7) & 7], const_1e256, sizeof(float80_s) );
4771 sw = SW_FINITE | INEX2;
4772 dump_fp_regs( "END ");
4773 }
4774
4775 void REGPARAM2 fpuop_do_load_const_1e512( uae_u32 opcode, uae_u16 extra )
4776 {
4777 D(bug("FMOVECR memory->FPP FP const: 1.0e512\r\n"));
4778 memcpy( fp_reg[(extra>>7) & 7], const_1e512, sizeof(float80_s) );
4779 sw = SW_FINITE | INEX2;
4780 dump_fp_regs( "END ");
4781 }
4782
4783 void REGPARAM2 fpuop_do_load_const_1e1024( uae_u32 opcode, uae_u16 extra )
4784 {
4785 D(bug("FMOVECR memory->FPP FP const: 1.0e1024\r\n"));
4786 memcpy( fp_reg[(extra>>7) & 7], const_1e1024, sizeof(float80_s) );
4787 sw = SW_FINITE | INEX2;
4788 dump_fp_regs( "END ");
4789 }
4790
4791 void REGPARAM2 fpuop_do_load_const_1e2048( uae_u32 opcode, uae_u16 extra )
4792 {
4793 D(bug("FMOVECR memory->FPP FP const: 1.0e2048\r\n"));
4794 memcpy( fp_reg[(extra>>7) & 7], const_1e2048, sizeof(float80_s) );
4795 sw = SW_FINITE | INEX2;
4796 dump_fp_regs( "END ");
4797 }
4798
4799 void REGPARAM2 fpuop_do_load_const_1e4096( uae_u32 opcode, uae_u16 extra )
4800 {
4801 D(bug("FMOVECR memory->FPP FP const: 1.0e4096\r\n"));
4802 memcpy( fp_reg[(extra>>7) & 7], const_1e4096, sizeof(float80_s) );
4803 sw = SW_FINITE | INEX2;
4804 dump_fp_regs( "END ");
4805 }
4806
4807
4808 /* ---------------------------- ALU ---------------------------- */
4809
4810 void REGPARAM2 fpuop_do_fmove( uae_u32 opcode, uae_u16 extra )
4811 {
4812 int reg = (extra >> 7) & 7;
4813 float80_s src;
4814 if (get_fp_value (opcode, extra, src) == 0) {
4815 m68k_setpc (m68k_getpc () - 4);
4816 op_illg (opcode);
4817 dump_fp_regs( "END ");
4818 return;
4819 }
4820 D(bug("FMOVE %s\r\n",etos(src)));
4821 do_fmove( fp_reg[reg], src );
4822 build_ex_status();
4823 dump_fp_regs( "END ");
4824 }
4825
4826 void REGPARAM2 fpuop_do_fint( uae_u32 opcode, uae_u16 extra )
4827 {
4828 int reg = (extra >> 7) & 7;
4829 float80_s src;
4830 if (get_fp_value (opcode, extra, src) == 0) {
4831 m68k_setpc (m68k_getpc () - 4);
4832 op_illg (opcode);
4833 dump_fp_regs( "END ");
4834 return;
4835 }
4836 D(bug("FINT %s, opcode=%X, extra=%X, ta %X\r\n",etos(src),opcode,extra,m68k_getpc()));
4837 do_fint( fp_reg[reg], src );
4838 dump_fp_regs( "END ");
4839 }
4840
4841 void REGPARAM2 fpuop_do_fsinh( uae_u32 opcode, uae_u16 extra )
4842 {
4843 int reg = (extra >> 7) & 7;
4844 float80_s src;
4845 if (get_fp_value (opcode, extra, src) == 0) {
4846 m68k_setpc (m68k_getpc () - 4);
4847 op_illg (opcode);
4848 dump_fp_regs( "END ");
4849 return;
4850 }
4851 D(bug("FSINH %s\r\n",etos(src)));
4852 do_fsinh( fp_reg[reg], src );
4853 build_ex_status();
4854 dump_fp_regs( "END ");
4855 }
4856
4857 void REGPARAM2 fpuop_do_fintrz( uae_u32 opcode, uae_u16 extra )
4858 {
4859 int reg = (extra >> 7) & 7;
4860 float80_s src;
4861 if (get_fp_value (opcode, extra, src) == 0) {
4862 m68k_setpc (m68k_getpc () - 4);
4863 op_illg (opcode);
4864 dump_fp_regs( "END ");
4865 return;
4866 }
4867 D(bug("FINTRZ %s\r\n",etos(src)));
4868 do_fintrz( fp_reg[reg], src );
4869 dump_fp_regs( "END ");
4870 }
4871
4872 void REGPARAM2 fpuop_do_fsqrt( uae_u32 opcode, uae_u16 extra )
4873 {
4874 int reg = (extra >> 7) & 7;
4875 float80_s src;
4876 if (get_fp_value (opcode, extra, src) == 0) {
4877 m68k_setpc (m68k_getpc () - 4);
4878 op_illg (opcode);
4879 dump_fp_regs( "END ");
4880 return;
4881 }
4882 D(bug("FSQRT %s\r\n",etos(src)));
4883 do_fsqrt( fp_reg[reg], src );
4884 dump_fp_regs( "END ");
4885 }
4886
4887 void REGPARAM2 fpuop_do_flognp1( uae_u32 opcode, uae_u16 extra )
4888 {
4889 int reg = (extra >> 7) & 7;
4890 float80_s src;
4891 if (get_fp_value (opcode, extra, src) == 0) {
4892 m68k_setpc (m68k_getpc () - 4);
4893 op_illg (opcode);
4894 dump_fp_regs( "END ");
4895 return;
4896 }
4897 D(bug("FLOGNP1 %s\r\n",etos(src)));
4898 do_flognp1( fp_reg[reg], src );
4899 build_ex_status();
4900 dump_fp_regs( "END ");
4901 }
4902
4903 void REGPARAM2 fpuop_do_fetoxm1( uae_u32 opcode, uae_u16 extra )
4904 {
4905 int reg = (extra >> 7) & 7;
4906 float80_s src;
4907 if (get_fp_value (opcode, extra, src) == 0) {
4908 m68k_setpc (m68k_getpc () - 4);
4909 op_illg (opcode);
4910 dump_fp_regs( "END ");
4911 return;
4912 }
4913 D(bug("FETOXM1 %s\r\n",etos(src)));
4914 do_fetoxm1( fp_reg[reg], src );
4915 build_ex_status();
4916 dump_fp_regs( "END ");
4917 }
4918
4919 void REGPARAM2 fpuop_do_ftanh( uae_u32 opcode, uae_u16 extra )
4920 {
4921 int reg = (extra >> 7) & 7;
4922 float80_s src;
4923 if (get_fp_value (opcode, extra, src) == 0) {
4924 m68k_setpc (m68k_getpc () - 4);
4925 op_illg (opcode);
4926 dump_fp_regs( "END ");
4927 return;
4928 }
4929 D(bug("FTANH %s\r\n",etos(src)));
4930 do_ftanh( fp_reg[reg], src );
4931 build_ex_status();
4932 dump_fp_regs( "END ");
4933 }
4934
4935 void REGPARAM2 fpuop_do_fatan( uae_u32 opcode, uae_u16 extra )
4936 {
4937 int reg = (extra >> 7) & 7;
4938 float80_s src;
4939 if (get_fp_value (opcode, extra, src) == 0) {
4940 m68k_setpc (m68k_getpc () - 4);
4941 op_illg (opcode);
4942 dump_fp_regs( "END ");
4943 return;
4944 }
4945 D(bug("FATAN %s\r\n",etos(src)));
4946 do_fatan( fp_reg[reg], src );
4947 build_ex_status();
4948 dump_fp_regs( "END ");
4949 }
4950
4951 void REGPARAM2 fpuop_do_fasin( uae_u32 opcode, uae_u16 extra )
4952 {
4953 int reg = (extra >> 7) & 7;
4954 float80_s src;
4955 if (get_fp_value (opcode, extra, src) == 0) {
4956 m68k_setpc (m68k_getpc () - 4);
4957 op_illg (opcode);
4958 dump_fp_regs( "END ");
4959 return;
4960 }
4961 D(bug("FASIN %s\r\n",etos(src)));
4962 do_fasin( fp_reg[reg], src );
4963 build_ex_status();
4964 dump_fp_regs( "END ");
4965 }
4966
4967 void REGPARAM2 fpuop_do_fatanh( uae_u32 opcode, uae_u16 extra )
4968 {
4969 int reg = (extra >> 7) & 7;
4970 float80_s src;
4971 if (get_fp_value (opcode, extra, src) == 0) {
4972 m68k_setpc (m68k_getpc () - 4);
4973 op_illg (opcode);
4974 dump_fp_regs( "END ");
4975 return;
4976 }
4977 D(bug("FATANH %s\r\n",etos(src)));
4978 do_fatanh( fp_reg[reg], src );
4979 build_ex_status();
4980 dump_fp_regs( "END ");
4981 }
4982
4983 void REGPARAM2 fpuop_do_fsin( uae_u32 opcode, uae_u16 extra )
4984 {
4985 int reg = (extra >> 7) & 7;
4986 float80_s src;
4987 if (get_fp_value (opcode, extra, src) == 0) {
4988 m68k_setpc (m68k_getpc () - 4);
4989 op_illg (opcode);
4990 dump_fp_regs( "END ");
4991 return;
4992 }
4993 D(bug("FSIN %s\r\n",etos(src)));
4994 do_fsin( fp_reg[reg], src );
4995 dump_fp_regs( "END ");
4996 }
4997
4998 void REGPARAM2 fpuop_do_ftan( uae_u32 opcode, uae_u16 extra )
4999 {
5000 int reg = (extra >> 7) & 7;
5001 float80_s src;
5002 if (get_fp_value (opcode, extra, src) == 0) {
5003 m68k_setpc (m68k_getpc () - 4);
5004 op_illg (opcode);
5005 dump_fp_regs( "END ");
5006 return;
5007 }
5008 D(bug("FTAN %s\r\n",etos(src)));
5009 do_ftan( fp_reg[reg], src );
5010 dump_fp_regs( "END ");
5011 }
5012
5013 void REGPARAM2 fpuop_do_fetox( uae_u32 opcode, uae_u16 extra )
5014 {
5015 int reg = (extra >> 7) & 7;
5016 float80_s src;
5017 if (get_fp_value (opcode, extra, src) == 0) {
5018 m68k_setpc (m68k_getpc () - 4);
5019 op_illg (opcode);
5020 dump_fp_regs( "END ");
5021 return;
5022 }
5023 D(bug("FETOX %s\r\n",etos(src)));
5024 do_fetox( fp_reg[reg], src );
5025 build_ex_status();
5026 dump_fp_regs( "END ");
5027 }
5028
5029 void REGPARAM2 fpuop_do_ftwotox( uae_u32 opcode, uae_u16 extra )
5030 {
5031 int reg = (extra >> 7) & 7;
5032 float80_s src;
5033 if (get_fp_value (opcode, extra, src) == 0) {
5034 m68k_setpc (m68k_getpc () - 4);
5035 op_illg (opcode);
5036 dump_fp_regs( "END ");
5037 return;
5038 }
5039 D(bug("FTWOTOX %s\r\n",etos(src)));
5040 do_ftwotox( fp_reg[reg], src );
5041 build_ex_status();
5042 dump_fp_regs( "END ");
5043 }
5044
5045 void REGPARAM2 fpuop_do_ftentox( uae_u32 opcode, uae_u16 extra )
5046 {
5047 int reg = (extra >> 7) & 7;
5048 float80_s src;
5049 if (get_fp_value (opcode, extra, src) == 0) {
5050 m68k_setpc (m68k_getpc () - 4);
5051 op_illg (opcode);
5052 dump_fp_regs( "END ");
5053 return;
5054 }
5055 D(bug("FTENTOX %s\r\n",etos(src)));
5056 do_ftentox( fp_reg[reg], src );
5057 build_ex_status();
5058 dump_fp_regs( "END ");
5059 }
5060
5061 void REGPARAM2 fpuop_do_flogn( uae_u32 opcode, uae_u16 extra )
5062 {
5063 int reg = (extra >> 7) & 7;
5064 float80_s src;
5065 if (get_fp_value (opcode, extra, src) == 0) {
5066 m68k_setpc (m68k_getpc () - 4);
5067 op_illg (opcode);
5068 dump_fp_regs( "END ");
5069 return;
5070 }
5071 D(bug("FLOGN %s\r\n",etos(src)));
5072 do_flogn( fp_reg[reg], src );
5073 build_ex_status();
5074 dump_fp_regs( "END ");
5075 }
5076
5077 void REGPARAM2 fpuop_do_flog10( uae_u32 opcode, uae_u16 extra )
5078 {
5079 int reg = (extra >> 7) & 7;
5080 float80_s src;
5081 if (get_fp_value (opcode, extra, src) == 0) {
5082 m68k_setpc (m68k_getpc () - 4);
5083 op_illg (opcode);
5084 dump_fp_regs( "END ");
5085 return;
5086 }
5087 D(bug("FLOG10 %s\r\n",etos(src)));
5088 do_flog10( fp_reg[reg], src );
5089 build_ex_status();
5090 dump_fp_regs( "END ");
5091 }
5092
5093 void REGPARAM2 fpuop_do_flog2( uae_u32 opcode, uae_u16 extra )
5094 {
5095 int reg = (extra >> 7) & 7;
5096 float80_s src;
5097 if (get_fp_value (opcode, extra, src) == 0) {
5098 m68k_setpc (m68k_getpc () - 4);
5099 op_illg (opcode);
5100 dump_fp_regs( "END ");
5101 return;
5102 }
5103 D(bug("FLOG2 %s\r\n",etos(src)));
5104 do_flog2( fp_reg[reg], src );
5105 build_ex_status();
5106 dump_fp_regs( "END ");
5107 }
5108
5109 void REGPARAM2 fpuop_do_fabs( uae_u32 opcode, uae_u16 extra )
5110 {
5111 int reg = (extra >> 7) & 7;
5112 float80_s src;
5113 if (get_fp_value (opcode, extra, src) == 0) {
5114 m68k_setpc (m68k_getpc () - 4);
5115 op_illg (opcode);
5116 dump_fp_regs( "END ");
5117 return;
5118 }
5119 D(bug("FABS %s\r\n",etos(src)));
5120 do_fabs( fp_reg[reg], src );
5121 dump_fp_regs( "END ");
5122 }
5123
5124 void REGPARAM2 fpuop_do_fcosh( uae_u32 opcode, uae_u16 extra )
5125 {
5126 int reg = (extra >> 7) & 7;
5127 float80_s src;
5128 if (get_fp_value (opcode, extra, src) == 0) {
5129 m68k_setpc (m68k_getpc () - 4);
5130 op_illg (opcode);
5131 dump_fp_regs( "END ");
5132 return;
5133 }
5134 D(bug("FCOSH %s\r\n",etos(src)));
5135 do_fcosh( fp_reg[reg], src );
5136 build_ex_status();
5137 dump_fp_regs( "END ");
5138 }
5139
5140 void REGPARAM2 fpuop_do_fneg( uae_u32 opcode, uae_u16 extra )
5141 {
5142 int reg = (extra >> 7) & 7;
5143 float80_s src;
5144 if (get_fp_value (opcode, extra, src) == 0) {
5145 m68k_setpc (m68k_getpc () - 4);
5146 op_illg (opcode);
5147 dump_fp_regs( "END ");
5148 return;
5149 }
5150 D(bug("FNEG %s\r\n",etos(src)));
5151 do_fneg( fp_reg[reg], src );
5152 dump_fp_regs( "END ");
5153 }
5154
5155 void REGPARAM2 fpuop_do_facos( uae_u32 opcode, uae_u16 extra )
5156 {
5157 int reg = (extra >> 7) & 7;
5158 float80_s src;
5159 if (get_fp_value (opcode, extra, src) == 0) {
5160 m68k_setpc (m68k_getpc () - 4);
5161 op_illg (opcode);
5162 dump_fp_regs( "END ");
5163 return;
5164 }
5165 D(bug("FACOS %s\r\n",etos(src)));
5166 do_facos( fp_reg[reg], src );
5167 build_ex_status();
5168 dump_fp_regs( "END ");
5169 }
5170
5171 void REGPARAM2 fpuop_do_fcos( uae_u32 opcode, uae_u16 extra )
5172 {
5173 int reg = (extra >> 7) & 7;
5174 float80_s src;
5175 if (get_fp_value (opcode, extra, src) == 0) {
5176 m68k_setpc (m68k_getpc () - 4);
5177 op_illg (opcode);
5178 dump_fp_regs( "END ");
5179 return;
5180 }
5181 D(bug("FCOS %s\r\n",etos(src)));
5182 do_fcos( fp_reg[reg], src );
5183 dump_fp_regs( "END ");
5184 }
5185
5186 void REGPARAM2 fpuop_do_fgetexp( uae_u32 opcode, uae_u16 extra )
5187 {
5188 int reg = (extra >> 7) & 7;
5189 float80_s src;
5190 if (get_fp_value (opcode, extra, src) == 0) {
5191 m68k_setpc (m68k_getpc () - 4);
5192 op_illg (opcode);
5193 dump_fp_regs( "END ");
5194 return;
5195 }
5196 D(bug("FGETEXP %s\r\n",etos(src)));
5197
5198 if( IS_INFINITY(src) ) {
5199 MAKE_NAN( fp_reg[reg] );
5200 do_ftst( fp_reg[reg] );
5201 sw |= SW_IE;
5202 } else {
5203 do_fgetexp( fp_reg[reg], src );
5204 }
5205 dump_fp_regs( "END ");
5206 }
5207
5208 void REGPARAM2 fpuop_do_fgetman( uae_u32 opcode, uae_u16 extra )
5209 {
5210 int reg = (extra >> 7) & 7;
5211 float80_s src;
5212 if (get_fp_value (opcode, extra, src) == 0) {
5213 m68k_setpc (m68k_getpc () - 4);
5214 op_illg (opcode);
5215 dump_fp_regs( "END ");
5216 return;
5217 }
5218 D(bug("FGETMAN %s\r\n",etos(src)));
5219 if( IS_INFINITY(src) ) {
5220 MAKE_NAN( fp_reg[reg] );
5221 do_ftst( fp_reg[reg] );
5222 sw |= SW_IE;
5223 } else {
5224 do_fgetman( fp_reg[reg], src );
5225 }
5226 dump_fp_regs( "END ");
5227 }
5228
5229 void REGPARAM2 fpuop_do_fdiv( uae_u32 opcode, uae_u16 extra )
5230 {
5231 int reg = (extra >> 7) & 7;
5232 float80_s src;
5233 if (get_fp_value (opcode, extra, src) == 0) {
5234 m68k_setpc (m68k_getpc () - 4);
5235 op_illg (opcode);
5236 dump_fp_regs( "END ");
5237 return;
5238 }
5239 D(bug("FDIV %s\r\n",etos(src)));
5240 do_fdiv( fp_reg[reg], src );
5241 dump_fp_regs( "END ");
5242 }
5243
5244 void REGPARAM2 fpuop_do_fmod( uae_u32 opcode, uae_u16 extra )
5245 {
5246 int reg = (extra >> 7) & 7;
5247 float80_s src;
5248 if (get_fp_value (opcode, extra, src) == 0) {
5249 m68k_setpc (m68k_getpc () - 4);
5250 op_illg (opcode);
5251 dump_fp_regs( "END ");
5252 return;
5253 }
5254 D(bug("FMOD %s\r\n",etos(src)));
5255
5256 #if USE_3_BIT_QUOTIENT
5257 do_fmod( fp_reg[reg], src );
5258 #else
5259 if( (cw & X86_ROUND_CONTROL_MASK) == CW_RC_ZERO ) {
5260 do_fmod_dont_set_cw( fp_reg[reg], src );
5261 } else {
5262 do_fmod( fp_reg[reg], src );
5263 }
5264 #endif
5265 dump_fp_regs( "END ");
5266 }
5267
5268 void REGPARAM2 fpuop_do_frem( uae_u32 opcode, uae_u16 extra )
5269 {
5270 int reg = (extra >> 7) & 7;
5271 float80_s src;
5272 if (get_fp_value (opcode, extra, src) == 0) {
5273 m68k_setpc (m68k_getpc () - 4);
5274 op_illg (opcode);
5275 dump_fp_regs( "END ");
5276 return;
5277 }
5278 D(bug("FREM %s\r\n",etos(src)));
5279 #if USE_3_BIT_QUOTIENT
5280 do_frem( fp_reg[reg], src );
5281 #else
5282 if( (cw & X86_ROUND_CONTROL_MASK) == CW_RC_NEAR ) {
5283 do_frem_dont_set_cw( fp_reg[reg], src );
5284 } else {
5285 do_frem( fp_reg[reg], src );
5286 }
5287 #endif
5288 dump_fp_regs( "END ");
5289 }
5290
5291 void REGPARAM2 fpuop_do_fadd( uae_u32 opcode, uae_u16 extra )
5292 {
5293 int reg = (extra >> 7) & 7;
5294 float80_s src;
5295 if (get_fp_value (opcode, extra, src) == 0) {
5296 m68k_setpc (m68k_getpc () - 4);
5297 op_illg (opcode);
5298 dump_fp_regs( "END ");
5299 return;
5300 }
5301 D(bug("FADD %s\r\n",etos(src)));
5302 do_fadd( fp_reg[reg], src );
5303 dump_fp_regs( "END ");
5304 }
5305
5306 void REGPARAM2 fpuop_do_fmul( uae_u32 opcode, uae_u16 extra )
5307 {
5308 int reg = (extra >> 7) & 7;
5309 float80_s src;
5310 if (get_fp_value (opcode, extra, src) == 0) {
5311 m68k_setpc (m68k_getpc () - 4);
5312 op_illg (opcode);
5313 dump_fp_regs( "END ");
5314 return;
5315 }
5316 D(bug("FMUL %s\r\n",etos(src)));
5317 do_fmul( fp_reg[reg], src );
5318 dump_fp_regs( "END ");
5319 }
5320
5321 void REGPARAM2 fpuop_do_fsgldiv( uae_u32 opcode, uae_u16 extra )
5322 {
5323 int reg = (extra >> 7) & 7;
5324 float80_s src;
5325 if (get_fp_value (opcode, extra, src) == 0) {
5326 m68k_setpc (m68k_getpc () - 4);
5327 op_illg (opcode);
5328 dump_fp_regs( "END ");
5329 return;
5330 }
5331 D(bug("FSGLDIV %s\r\n",etos(src)));
5332 do_fsgldiv( fp_reg[reg], src );
5333 dump_fp_regs( "END ");
5334 }
5335
5336 void REGPARAM2 fpuop_do_fscale( uae_u32 opcode, uae_u16 extra )
5337 {
5338 int reg = (extra >> 7) & 7;
5339 float80_s src;
5340 if (get_fp_value (opcode, extra, src) == 0) {
5341 m68k_setpc (m68k_getpc () - 4);
5342 op_illg (opcode);
5343 dump_fp_regs( "END ");
5344 return;
5345 }
5346 D(bug("FSCALE %s, opcode=%X, extra=%X, ta %X\r\n",etos(src),opcode,extra,m68k_getpc()));
5347 if( IS_INFINITY(fp_reg[reg]) ) {
5348 MAKE_NAN( fp_reg[reg] );
5349 do_ftst( fp_reg[reg] );
5350 sw |= SW_IE;
5351 } else {
5352 // When the absolute value of the source operand is >= 2^14,
5353 // an overflow or underflow always results.
5354 do_fscale( fp_reg[reg], src );
5355 }
5356 dump_fp_regs( "END ");
5357 }
5358
5359 void REGPARAM2 fpuop_do_fsglmul( uae_u32 opcode, uae_u16 extra )
5360 {
5361 int reg = (extra >> 7) & 7;
5362 float80_s src;
5363 if (get_fp_value (opcode, extra, src) == 0) {
5364 m68k_setpc (m68k_getpc () - 4);
5365 op_illg (opcode);
5366 dump_fp_regs( "END ");
5367 return;
5368 }
5369 D(bug("FSGLMUL %s\r\n",etos(src)));
5370 do_fsglmul( fp_reg[reg], src );
5371 dump_fp_regs( "END ");
5372 }
5373
5374 void REGPARAM2 fpuop_do_fsub( uae_u32 opcode, uae_u16 extra )
5375 {
5376 int reg = (extra >> 7) & 7;
5377 float80_s src;
5378 if (get_fp_value (opcode, extra, src) == 0) {
5379 m68k_setpc (m68k_getpc () - 4);
5380 op_illg (opcode);
5381 dump_fp_regs( "END ");
5382 return;
5383 }
5384 D(bug("FSUB %s\r\n",etos(src)));
5385 do_fsub( fp_reg[reg], src );
5386 dump_fp_regs( "END ");
5387 }
5388
5389 void REGPARAM2 fpuop_do_fsincos( uae_u32 opcode, uae_u16 extra )
5390 {
5391 int reg = (extra >> 7) & 7;
5392 float80_s src;
5393 if (get_fp_value (opcode, extra, src) == 0) {
5394 m68k_setpc (m68k_getpc () - 4);
5395 op_illg (opcode);
5396 dump_fp_regs( "END ");
5397 return;
5398 }
5399 D(bug("FSINCOS %s\r\n",etos(src)));
5400 do_fsincos( fp_reg[reg], fp_reg[extra & 7], src );
5401 dump_fp_regs( "END ");
5402 }
5403
5404 void REGPARAM2 fpuop_do_fcmp( uae_u32 opcode, uae_u16 extra )
5405 {
5406 int reg = (extra >> 7) & 7;
5407 float80_s src;
5408 if (get_fp_value (opcode, extra, src) == 0) {
5409 m68k_setpc (m68k_getpc () - 4);
5410 op_illg (opcode);
5411 dump_fp_regs( "END ");
5412 return;
5413 }
5414 D(bug("FCMP %s\r\n",etos(src)));
5415
5416 if( IS_INFINITY(src) ) {
5417 if( IS_NEGATIVE(src) ) {
5418 if( IS_INFINITY(fp_reg[reg]) && IS_NEGATIVE(fp_reg[reg]) ) {
5419 sw = SW_Z | SW_N;
5420 D(bug("-INF FCMP -INF -> NZ\r\n"));
5421 } else {
5422 sw = SW_FINITE;
5423 D(bug("X FCMP -INF -> None\r\n"));
5424 }
5425 } else {
5426 if( IS_INFINITY(fp_reg[reg]) && !IS_NEGATIVE(fp_reg[reg]) ) {
5427 sw = SW_Z;
5428 D(bug("+INF FCMP +INF -> Z\r\n"));
5429 } else {
5430 sw = SW_N;
5431 D(bug("X FCMP +INF -> N\r\n"));
5432 }
5433 }
5434 } else if( IS_INFINITY(fp_reg[reg]) ) {
5435 if( IS_NEGATIVE(fp_reg[reg]) ) {
5436 sw = SW_N;
5437 D(bug("-INF FCMP X -> Negative\r\n"));
5438 } else {
5439 sw = SW_FINITE;
5440 D(bug("+INF FCMP X -> None\r\n"));
5441 }
5442 } else {
5443 do_fcmp( fp_reg[reg], src );
5444 }
5445
5446 dump_fp_regs( "END ");
5447 }
5448
5449 void REGPARAM2 fpuop_do_ftst( uae_u32 opcode, uae_u16 extra )
5450 {
5451 int reg = (extra >> 7) & 7;
5452 float80_s src;
5453 if (get_fp_value (opcode, extra, src) == 0) {
5454 m68k_setpc (m68k_getpc () - 4);
5455 op_illg (opcode);
5456 dump_fp_regs( "END ");
5457 return;
5458 }
5459 D(bug("FTST %s\r\n",etos(src)));
5460 do_ftst( src );
5461 build_ex_status();
5462 dump_fp_regs( "END ");
5463 }
5464
5465
5466
5467 /* ---------------------------- SET FPU MODE ---------------------------- */
5468
5469 void fpu_set_integral_fpu( bool is_integral )
5470 {
5471 is_integral_68040_fpu = (uae_u32)is_integral;
5472 }
5473
5474
5475 /* ---------------------------- SETUP TABLES ---------------------------- */
5476
5477 static void build_fpp_opp_lookup_table()
5478 {
5479 for( uae_u32 opcode=0; opcode<=0x38; opcode+=8 ) {
5480 for( uae_u32 extra=0; extra<65536; extra++ ) {
5481 uae_u32 mask = (extra & 0xFC7F) | ((opcode & 0x0038) << 4);
5482 fpufunctbl[mask] = fpuop_illg;
5483
5484 switch ((extra >> 13) & 0x7) {
5485 case 3:
5486 fpufunctbl[mask] = fpuop_fmove_2_ea;
5487 break;
5488 case 4:
5489 case 5:
5490 if ((opcode & 0x38) == 0) {
5491 if (extra & 0x2000) { // dr bit
5492 switch( extra & 0x1C00 ) {
5493 case 0x0000:
5494 fpufunctbl[mask] = fpuop_fmovem_none_2_Dreg;
5495 break;
5496 case 0x0400:
5497 fpufunctbl[mask] = fpuop_fmovem_fpiar_2_Dreg;
5498 break;
5499 case 0x0800:
5500 fpufunctbl[mask] = fpuop_fmovem_fpsr_2_Dreg;
5501 break;
5502 case 0x0C00:
5503 fpufunctbl[mask] = fpuop_fmovem_fpsr_fpiar_2_Dreg;
5504 break;
5505 case 0x1000:
5506 fpufunctbl[mask] = fpuop_fmovem_fpcr_2_Dreg;
5507 break;
5508 case 0x1400:
5509 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpiar_2_Dreg;
5510 break;
5511 case 0x1800:
5512 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_2_Dreg;
5513 break;
5514 case 0x1C00:
5515 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_fpiar_2_Dreg;
5516 break;
5517 }
5518 } else {
5519 switch( extra & 0x1C00 ) {
5520 case 0x0000:
5521 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_none;
5522 break;
5523 case 0x0400:
5524 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpiar;
5525 break;
5526 case 0x0800:
5527 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpsr;
5528 break;
5529 case 0x0C00:
5530 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpsr_fpiar;
5531 break;
5532 case 0x1000:
5533 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpcr;
5534 break;
5535 case 0x1400:
5536 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpcr_fpiar;
5537 break;
5538 case 0x1800:
5539 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpcr_fpsr;
5540 break;
5541 case 0x1C00:
5542 fpufunctbl[mask] = fpuop_fmovem_Dreg_2_fpcr_fpsr_fpiar;
5543 break;
5544 }
5545 }
5546 } else if ((opcode & 0x38) == 8) {
5547 if (extra & 0x2000) { // dr bit
5548 switch( extra & 0x1C00 ) {
5549 case 0x0000:
5550 fpufunctbl[mask] = fpuop_fmovem_none_2_Areg;
5551 break;
5552 case 0x0400:
5553 fpufunctbl[mask] = fpuop_fmovem_fpiar_2_Areg;
5554 break;
5555 case 0x0800:
5556 fpufunctbl[mask] = fpuop_fmovem_fpsr_2_Areg;
5557 break;
5558 case 0x0C00:
5559 fpufunctbl[mask] = fpuop_fmovem_fpsr_fpiar_2_Areg;
5560 break;
5561 case 0x1000:
5562 fpufunctbl[mask] = fpuop_fmovem_fpcr_2_Areg;
5563 break;
5564 case 0x1400:
5565 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpiar_2_Areg;
5566 break;
5567 case 0x1800:
5568 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_2_Areg;
5569 break;
5570 case 0x1C00:
5571 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_fpiar_2_Areg;
5572 break;
5573 }
5574 } else {
5575 switch( extra & 0x1C00 ) {
5576 case 0x0000:
5577 fpufunctbl[mask] = fpuop_fmovem_Areg_2_none;
5578 break;
5579 case 0x0400:
5580 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpiar;
5581 break;
5582 case 0x0800:
5583 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpsr;
5584 break;
5585 case 0x0C00:
5586 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpsr_fpiar;
5587 break;
5588 case 0x1000:
5589 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpcr;
5590 break;
5591 case 0x1400:
5592 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpcr_fpiar;
5593 break;
5594 case 0x1800:
5595 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpcr_fpsr;
5596 break;
5597 case 0x1C00:
5598 fpufunctbl[mask] = fpuop_fmovem_Areg_2_fpcr_fpsr_fpiar;
5599 break;
5600 }
5601 }
5602 } else if (extra & 0x2000) {
5603 if ((opcode & 0x38) == 0x20) {
5604 switch( extra & 0x1C00 ) {
5605 case 0x0000:
5606 fpufunctbl[mask] = fpuop_fmovem_none_2_Mem_predecrement;
5607 break;
5608 case 0x0400:
5609 fpufunctbl[mask] = fpuop_fmovem_fpiar_2_Mem_predecrement;
5610 break;
5611 case 0x0800:
5612 fpufunctbl[mask] = fpuop_fmovem_fpsr_2_Mem_predecrement;
5613 break;
5614 case 0x0C00:
5615 fpufunctbl[mask] = fpuop_fmovem_fpsr_fpiar_2_Mem_predecrement;
5616 break;
5617 case 0x1000:
5618 fpufunctbl[mask] = fpuop_fmovem_fpcr_2_Mem_predecrement;
5619 break;
5620 case 0x1400:
5621 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpiar_2_Mem_predecrement;
5622 break;
5623 case 0x1800:
5624 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_2_Mem_predecrement;
5625 break;
5626 case 0x1C00:
5627 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem_predecrement;
5628 break;
5629 }
5630 } else if ((opcode & 0x38) == 0x18) {
5631 switch( extra & 0x1C00 ) {
5632 case 0x0000:
5633 fpufunctbl[mask] = fpuop_fmovem_none_2_Mem_postincrement;
5634 break;
5635 case 0x0400:
5636 fpufunctbl[mask] = fpuop_fmovem_fpiar_2_Mem_postincrement;
5637 break;
5638 case 0x0800:
5639 fpufunctbl[mask] = fpuop_fmovem_fpsr_2_Mem_postincrement;
5640 break;
5641 case 0x0C00:
5642 fpufunctbl[mask] = fpuop_fmovem_fpsr_fpiar_2_Mem_postincrement;
5643 break;
5644 case 0x1000:
5645 fpufunctbl[mask] = fpuop_fmovem_fpcr_2_Mem_postincrement;
5646 break;
5647 case 0x1400:
5648 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpiar_2_Mem_postincrement;
5649 break;
5650 case 0x1800:
5651 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_2_Mem_postincrement;
5652 break;
5653 case 0x1C00:
5654 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem_postincrement;
5655 break;
5656 }
5657 } else {
5658 switch( extra & 0x1C00 ) {
5659 case 0x0000:
5660 fpufunctbl[mask] = fpuop_fmovem_none_2_Mem;
5661 break;
5662 case 0x0400:
5663 fpufunctbl[mask] = fpuop_fmovem_fpiar_2_Mem;
5664 break;
5665 case 0x0800:
5666 fpufunctbl[mask] = fpuop_fmovem_fpsr_2_Mem;
5667 break;
5668 case 0x0C00:
5669 fpufunctbl[mask] = fpuop_fmovem_fpsr_fpiar_2_Mem;
5670 break;
5671 case 0x1000:
5672 fpufunctbl[mask] = fpuop_fmovem_fpcr_2_Mem;
5673 break;
5674 case 0x1400:
5675 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpiar_2_Mem;
5676 break;
5677 case 0x1800:
5678 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_2_Mem;
5679 break;
5680 case 0x1C00:
5681 fpufunctbl[mask] = fpuop_fmovem_fpcr_fpsr_fpiar_2_Mem;
5682 break;
5683 }
5684 }
5685 } else {
5686 if ((opcode & 0x38) == 0x20) {
5687 switch( extra & 0x1C00 ) {
5688 case 0x0000:
5689 fpufunctbl[mask] = fpuop_fmovem_Mem_2_none_predecrement;
5690 break;
5691 case 0x0400:
5692 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpiar_predecrement;
5693 break;
5694 case 0x0800:
5695 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_predecrement;
5696 break;
5697 case 0x0C00:
5698 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_fpiar_predecrement;
5699 break;
5700 case 0x1000:
5701 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_predecrement;
5702 break;
5703 case 0x1400:
5704 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpiar_predecrement;
5705 break;
5706 case 0x1800:
5707 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_predecrement;
5708 break;
5709 case 0x1C00:
5710 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_predecrement;
5711 break;
5712 }
5713 } else if ((opcode & 0x38) == 0x18) {
5714 switch( extra & 0x1C00 ) {
5715 case 0x0000:
5716 fpufunctbl[mask] = fpuop_fmovem_Mem_2_none_postincrement;
5717 break;
5718 case 0x0400:
5719 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpiar_postincrement;
5720 break;
5721 case 0x0800:
5722 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_postincrement;
5723 break;
5724 case 0x0C00:
5725 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_fpiar_postincrement;
5726 break;
5727 case 0x1000:
5728 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_postincrement;
5729 break;
5730 case 0x1400:
5731 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpiar_postincrement;
5732 break;
5733 case 0x1800:
5734 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_postincrement;
5735 break;
5736 case 0x1C00:
5737 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_postincrement;
5738 break;
5739 }
5740 } else {
5741 switch( extra & 0x1C00 ) {
5742 case 0x0000:
5743 fpufunctbl[mask] = fpuop_fmovem_Mem_2_none_2_Mem;
5744 break;
5745 case 0x0400:
5746 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpiar_2_Mem;
5747 break;
5748 case 0x0800:
5749 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_2_Mem;
5750 break;
5751 case 0x0C00:
5752 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpsr_fpiar_2_Mem;
5753 break;
5754 case 0x1000:
5755 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_2_Mem;
5756 break;
5757 case 0x1400:
5758 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpiar_2_Mem;
5759 break;
5760 case 0x1800:
5761 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_2_Mem;
5762 break;
5763 case 0x1C00:
5764 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpcr_fpsr_fpiar_2_Mem;
5765 break;
5766 }
5767 }
5768 break;
5769 case 6:
5770 switch ((extra >> 11) & 3) {
5771 case 0: /* static pred */
5772 if ((opcode & 0x38) == 0x18) // post-increment?
5773 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_pred_postincrement;
5774 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5775 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_pred_predecrement;
5776 else
5777 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_pred;
5778 break;
5779 case 1: /* dynamic pred */
5780 if ((opcode & 0x38) == 0x18) // post-increment?
5781 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_pred_postincrement;
5782 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5783 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_pred_predecrement;
5784 else
5785 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_pred;
5786 break;
5787 case 2: /* static postinc */
5788 if ((opcode & 0x38) == 0x18) // post-increment?
5789 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_postinc_postincrement;
5790 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5791 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_postinc_predecrement;
5792 else
5793 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_static_postinc;
5794 break;
5795 case 3: /* dynamic postinc */
5796 if ((opcode & 0x38) == 0x18) // post-increment?
5797 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_postinc_postincrement;
5798 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5799 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_postinc_predecrement;
5800 else
5801 fpufunctbl[mask] = fpuop_fmovem_Mem_2_fpp_dynamic_postinc;
5802 break;
5803 }
5804 break;
5805 case 7:
5806 switch ((extra >> 11) & 3) {
5807 case 0: /* static pred */
5808 if ((opcode & 0x38) == 0x18) // post-increment?
5809 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_pred_postincrement;
5810 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5811 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_pred_predecrement;
5812 else
5813 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_pred;
5814 break;
5815 case 1: /* dynamic pred */
5816 if ((opcode & 0x38) == 0x18) // post-increment?
5817 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_pred_postincrement;
5818 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5819 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_pred_predecrement;
5820 else
5821 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_pred;
5822 break;
5823 case 2: /* static postinc */
5824 if ((opcode & 0x38) == 0x18) // post-increment?
5825 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_postinc_postincrement;
5826 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5827 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_postinc_predecrement;
5828 else
5829 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_static_postinc;
5830 break;
5831 case 3: /* dynamic postinc */
5832 if ((opcode & 0x38) == 0x18) // post-increment?
5833 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_postinc_postincrement;
5834 else if ((opcode & 0x38) == 0x20) // pre-decrement?
5835 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_postinc_predecrement;
5836 else
5837 fpufunctbl[mask] = fpuop_fmovem_fpp_2_Mem_dynamic_postinc;
5838 break;
5839 }
5840 break;
5841 case 0:
5842 case 2:
5843 if ((extra & 0xfc00) == 0x5c00) {
5844 switch (extra & 0x7f) {
5845 case 0x00:
5846 fpufunctbl[mask] = fpuop_do_fldpi;
5847 break;
5848 case 0x0b:
5849 fpufunctbl[mask] = fpuop_do_fldlg2;
5850 break;
5851 case 0x0c:
5852 fpufunctbl[mask] = fpuop_do_load_const_e;
5853 break;
5854 case 0x0d:
5855 fpufunctbl[mask] = fpuop_do_fldl2e;
5856 break;
5857 case 0x0e:
5858 fpufunctbl[mask] = fpuop_do_load_const_log_10_e;
5859 break;
5860 case 0x0f:
5861 fpufunctbl[mask] = fpuop_do_fldz;
5862 break;
5863 case 0x30:
5864 fpufunctbl[mask] = fpuop_do_fldln2;
5865 break;
5866 case 0x31:
5867 fpufunctbl[mask] = fpuop_do_load_const_ln_10;
5868 break;
5869 case 0x32:
5870 fpufunctbl[mask] = fpuop_do_fld1;
5871 break;
5872 case 0x33:
5873 fpufunctbl[mask] = fpuop_do_load_const_1e1;
5874 break;
5875 case 0x34:
5876 fpufunctbl[mask] = fpuop_do_load_const_1e2;
5877 break;
5878 case 0x35:
5879 fpufunctbl[mask] = fpuop_do_load_const_1e4;
5880 break;
5881 case 0x36:
5882 fpufunctbl[mask] = fpuop_do_load_const_1e8;
5883 break;
5884 case 0x37:
5885 fpufunctbl[mask] = fpuop_do_load_const_1e16;
5886 break;
5887 case 0x38:
5888 fpufunctbl[mask] = fpuop_do_load_const_1e32;
5889 break;
5890 case 0x39:
5891 fpufunctbl[mask] = fpuop_do_load_const_1e64;
5892 break;
5893 case 0x3a:
5894 fpufunctbl[mask] = fpuop_do_load_const_1e128;
5895 break;
5896 case 0x3b:
5897 fpufunctbl[mask] = fpuop_do_load_const_1e256;
5898 break;
5899 case 0x3c:
5900 fpufunctbl[mask] = fpuop_do_load_const_1e512;
5901 break;
5902 case 0x3d:
5903 fpufunctbl[mask] = fpuop_do_load_const_1e1024;
5904 break;
5905 case 0x3e:
5906 fpufunctbl[mask] = fpuop_do_load_const_1e2048;
5907 break;
5908 case 0x3f:
5909 fpufunctbl[mask] = fpuop_do_load_const_1e4096;
5910 break;
5911 }
5912 break;
5913 }
5914
5915 switch (extra & 0x7f) {
5916 case 0x00:
5917 fpufunctbl[mask] = fpuop_do_fmove;
5918 break;
5919 case 0x01:
5920 fpufunctbl[mask] = fpuop_do_fint;
5921 break;
5922 case 0x02:
5923 fpufunctbl[mask] = fpuop_do_fsinh;
5924 break;
5925 case 0x03:
5926 fpufunctbl[mask] = fpuop_do_fintrz;
5927 break;
5928 case 0x04:
5929 fpufunctbl[mask] = fpuop_do_fsqrt;
5930 break;
5931 case 0x06:
5932 fpufunctbl[mask] = fpuop_do_flognp1;
5933 break;
5934 case 0x08:
5935 fpufunctbl[mask] = fpuop_do_fetoxm1;
5936 break;
5937 case 0x09:
5938 fpufunctbl[mask] = fpuop_do_ftanh;
5939 break;
5940 case 0x0a:
5941 fpufunctbl[mask] = fpuop_do_fatan;
5942 break;
5943 case 0x0c:
5944 fpufunctbl[mask] = fpuop_do_fasin;
5945 break;
5946 case 0x0d:
5947 fpufunctbl[mask] = fpuop_do_fatanh;
5948 break;
5949 case 0x0e:
5950 fpufunctbl[mask] = fpuop_do_fsin;
5951 break;
5952 case 0x0f:
5953 fpufunctbl[mask] = fpuop_do_ftan;
5954 break;
5955 case 0x10:
5956 fpufunctbl[mask] = fpuop_do_fetox;
5957 break;
5958 case 0x11:
5959 fpufunctbl[mask] = fpuop_do_ftwotox;
5960 break;
5961 case 0x12:
5962 fpufunctbl[mask] = fpuop_do_ftentox;
5963 break;
5964 case 0x14:
5965 fpufunctbl[mask] = fpuop_do_flogn;
5966 break;
5967 case 0x15:
5968 fpufunctbl[mask] = fpuop_do_flog10;
5969 break;
5970 case 0x16:
5971 fpufunctbl[mask] = fpuop_do_flog2;
5972 break;
5973 case 0x18:
5974 fpufunctbl[mask] = fpuop_do_fabs;
5975 break;
5976 case 0x19:
5977 fpufunctbl[mask] = fpuop_do_fcosh;
5978 break;
5979 case 0x1a:
5980 fpufunctbl[mask] = fpuop_do_fneg;
5981 break;
5982 case 0x1c:
5983 fpufunctbl[mask] = fpuop_do_facos;
5984 break;
5985 case 0x1d:
5986 fpufunctbl[mask] = fpuop_do_fcos;
5987 break;
5988 case 0x1e:
5989 fpufunctbl[mask] = fpuop_do_fgetexp;
5990 break;
5991 case 0x1f:
5992 fpufunctbl[mask] = fpuop_do_fgetman;
5993 break;
5994 case 0x20:
5995 fpufunctbl[mask] = fpuop_do_fdiv;
5996 break;
5997 case 0x21:
5998 fpufunctbl[mask] = fpuop_do_fmod;
5999 break;
6000 case 0x22:
6001 fpufunctbl[mask] = fpuop_do_fadd;
6002 break;
6003 case 0x23:
6004 fpufunctbl[mask] = fpuop_do_fmul;
6005 break;
6006 case 0x24:
6007 fpufunctbl[mask] = fpuop_do_fsgldiv;
6008 break;
6009 case 0x25:
6010 fpufunctbl[mask] = fpuop_do_frem;
6011 break;
6012 case 0x26:
6013 fpufunctbl[mask] = fpuop_do_fscale;
6014 break;
6015 case 0x27:
6016 fpufunctbl[mask] = fpuop_do_fsglmul;
6017 break;
6018 case 0x28:
6019 fpufunctbl[mask] = fpuop_do_fsub;
6020 break;
6021 case 0x30:
6022 case 0x31:
6023 case 0x32:
6024 case 0x33:
6025 case 0x34:
6026 case 0x35:
6027 case 0x36:
6028 case 0x37:
6029 fpufunctbl[mask] = fpuop_do_fsincos;
6030 break;
6031 case 0x38:
6032 fpufunctbl[mask] = fpuop_do_fcmp;
6033 break;
6034 case 0x3a:
6035 fpufunctbl[mask] = fpuop_do_ftst;
6036 break;
6037 }
6038 }
6039 }
6040 }
6041 }
6042 }
6043
6044 static void build_fpsr_lookup_tables()
6045 {
6046 uae_u32 i;
6047
6048 // Mapping for "sw" -> fpsr condition code
6049 for( i=0; i<0x48; i++ ) {
6050 sw_cond_host2mac[i] = 0;
6051 switch( (i << 8) & (SW_Z_I_NAN_MASK) ) {
6052 case SW_UNSUPPORTED:
6053 case SW_NAN:
6054 case SW_EMPTY_REGISTER:
6055 sw_cond_host2mac[i] |= 0x1000000;
6056 break;
6057 case SW_FINITE:
6058 case SW_DENORMAL:
6059 break;
6060 case SW_I:
6061 sw_cond_host2mac[i] |= 0x2000000;
6062 break;
6063 case SW_Z:
6064 sw_cond_host2mac[i] |= 0x4000000;
6065 break;
6066 }
6067 if( (i << 8) & SW_N ) {
6068 sw_cond_host2mac[i] |= 0x8000000;
6069 }
6070 }
6071
6072 // Mapping for fpsr condition code -> "sw"
6073 for( i=0; i<16; i++ ) {
6074 if( (i << 24) & 0x1000000 ) {
6075 sw_cond_mac2host[i] = SW_NAN;
6076 } else if( (i << 24) & 0x4000000 ) {
6077 sw_cond_mac2host[i] = SW_Z;
6078 } else if( (i << 24) & 0x2000000 ) {
6079 sw_cond_mac2host[i] = SW_I;
6080 } else {
6081 sw_cond_mac2host[i] = SW_FINITE;
6082 }
6083 if( (i << 24) & 0x8000000 ) {
6084 sw_cond_mac2host[i] |= SW_N;
6085 }
6086 }
6087
6088 // Mapping for "sw" -> fpsr exception byte
6089 for( i=0; i<0x80; i++ ) {
6090 exception_host2mac[i] = 0;
6091
6092 if(i & SW_FAKE_BSUN) {
6093 exception_host2mac[i] |= BSUN;
6094 }
6095 // precision exception
6096 if(i & SW_PE) {
6097 exception_host2mac[i] |= INEX2;
6098 }
6099 // underflow exception
6100 if(i & SW_UE) {
6101 exception_host2mac[i] |= UNFL;
6102 }
6103 // overflow exception
6104 if(i & SW_OE) {
6105 exception_host2mac[i] |= OVFL;
6106 }
6107 // zero divide exception
6108 if(i & SW_ZE) {
6109 exception_host2mac[i] |= DZ;
6110 }
6111 // denormalized operand exception.
6112 // wrong, but should not get here, normalization is done in elsewhere
6113 if(i & SW_DE) {
6114 exception_host2mac[i] |= SNAN;
6115 }
6116 // invalid operation exception
6117 if(i & SW_IE) {
6118 exception_host2mac[i] |= OPERR;
6119 }
6120 }
6121
6122 // Mapping for fpsr exception byte -> "sw"
6123 for( i=0; i<0x100; i++ ) {
6124 int fpsr = (i << 8);
6125 exception_mac2host[i] = 0;
6126
6127 // BSUN; make sure that you don't generate FPU stack faults.
6128 if(fpsr & BSUN) {
6129 exception_mac2host[i] |= SW_FAKE_BSUN;
6130 }
6131 // precision exception
6132 if(fpsr & INEX2) {
6133 exception_mac2host[i] |= SW_PE;
6134 }
6135 // underflow exception
6136 if(fpsr & UNFL) {
6137 exception_mac2host[i] |= SW_UE;
6138 }
6139 // overflow exception
6140 if(fpsr & OVFL) {
6141 exception_mac2host[i] |= SW_OE;
6142 }
6143 // zero divide exception
6144 if(fpsr & DZ) {
6145 exception_mac2host[i] |= SW_ZE;
6146 }
6147 // denormalized operand exception
6148 if(fpsr & SNAN) {
6149 exception_mac2host[i] |= SW_DE; //Wrong
6150 }
6151 // invalid operation exception
6152 if(fpsr & OPERR) {
6153 exception_mac2host[i] |= SW_IE;
6154 }
6155 }
6156
6157 /*
6158 68881/68040 accrued exceptions accumulate as follows:
6159 Accrued.IOP |= (Exception.SNAN | Exception.OPERR)
6160 Accrued.OVFL |= (Exception.OVFL)
6161 Accrued.UNFL |= (Exception.UNFL | Exception.INEX2)
6162 Accrued.DZ |= (Exception.DZ)
6163 Accrued.INEX |= (Exception.INEX1 | Exception.INEX2 | Exception.OVFL)
6164 */
6165
6166 // Mapping for "sw_accrued" -> fpsr accrued exception byte
6167 for( i=0; i<0x40; i++ ) {
6168 accrued_exception_host2mac[i] = 0;
6169
6170 // precision exception
6171 if(i & SW_PE) {
6172 accrued_exception_host2mac[i] |= ACCR_INEX;
6173 }
6174 // underflow exception
6175 if(i & SW_UE) {
6176 accrued_exception_host2mac[i] |= ACCR_UNFL;
6177 }
6178 // overflow exception
6179 if(i & SW_OE) {
6180 accrued_exception_host2mac[i] |= ACCR_OVFL;
6181 }
6182 // zero divide exception
6183 if(i & SW_ZE) {
6184 accrued_exception_host2mac[i] |= ACCR_DZ;
6185 }
6186 // denormalized operand exception
6187 if(i & SW_DE) {
6188 accrued_exception_host2mac[i] |= ACCR_IOP; //??????
6189 }
6190 // invalid operation exception
6191 if(i & SW_IE) {
6192 accrued_exception_host2mac[i] |= ACCR_IOP;
6193 }
6194 }
6195
6196 // Mapping for fpsr accrued exception byte -> "sw_accrued"
6197 for( i=0; i<0x20; i++ ) {
6198 int fpsr = (i << 3);
6199 accrued_exception_mac2host[i] = 0;
6200
6201 // precision exception
6202 if(fpsr & ACCR_INEX) {
6203 accrued_exception_mac2host[i] |= SW_PE;
6204 }
6205 // underflow exception
6206 if(fpsr & ACCR_UNFL) {
6207 accrued_exception_mac2host[i] |= SW_UE;
6208 }
6209 // overflow exception
6210 if(fpsr & ACCR_OVFL) {
6211 accrued_exception_mac2host[i] |= SW_OE;
6212 }
6213 // zero divide exception
6214 if(fpsr & ACCR_DZ) {
6215 accrued_exception_mac2host[i] |= SW_ZE;
6216 }
6217 // What about SW_DE; //??????
6218 // invalid operation exception
6219 if(fpsr & ACCR_IOP) {
6220 accrued_exception_mac2host[i] |= SW_IE;
6221 }
6222 }
6223 }
6224
6225 /* ---------------------------- CONSTANTS ---------------------------- */
6226
6227 static void set_constant( float80 f, char *name, double value, uae_s32 mult )
6228 {
6229 FPU_CONSISTENCY_CHECK_START();
6230 if(mult == 1) {
6231 /* _asm {
6232 MOV ESI, [f]
6233 FLD QWORD PTR [value]
6234 FSTP TBYTE PTR [ESI]
6235 } */
6236 _ASM( "fldl %1\n"
6237 "fstpt %0\n"
6238 : "=m" (*f)
6239 : "m" (value)
6240 );
6241 } else {
6242 /* _asm {
6243 MOV ESI, [f]
6244 FILD DWORD PTR [mult]
6245 FLD QWORD PTR [value]
6246 FMUL
6247 FSTP TBYTE PTR [ESI]
6248 } */
6249 _ASM( "fildl %2\n"
6250 "fldl %1\n"
6251 "fmul \n"
6252 "fstpt %0\n"
6253 : "=m" (*f)
6254 : "m" (value), "m" (mult)
6255 );
6256 }
6257 D(bug("set_constant (%s,%.04f) = %s\r\n",name,(float)value,etos(f)));
6258 FPU_CONSISTENCY_CHECK_STOP( mult==1 ? "set_constant(mult==1)" : "set_constant(mult>1)" );
6259 }
6260
6261 static void do_fldpi( float80 dest ) REGPARAM;
6262 static void do_fldpi( float80 dest )
6263 {
6264 FPU_CONSISTENCY_CHECK_START();
6265 /* _asm {
6266 FLDPI
6267 FXAM
6268 FNSTSW sw
6269 MOV EDI, [dest]
6270 FSTP TBYTE PTR [EDI]
6271 } */
6272 _ASM( "fldpi \n"
6273 "fxam \n"
6274 "fnstsw %0\n"
6275 "fstpt %1\n"
6276 : "=m" (sw), "=m" (*dest)
6277 );
6278 FPU_CONSISTENCY_CHECK_STOP("do_fldpi");
6279 }
6280
6281 static void do_fldlg2( float80 dest ) REGPARAM;
6282 static void do_fldlg2( float80 dest )
6283 {
6284 FPU_CONSISTENCY_CHECK_START();
6285 /* _asm {
6286 FLDLG2
6287 FXAM
6288 FNSTSW sw
6289 MOV EDI, [dest]
6290 FSTP TBYTE PTR [EDI]
6291 } */
6292 _ASM( "fldlg2 \n"
6293 "fxam \n"
6294 "fnstsw %0\n"
6295 "fstpt %1\n"
6296 : "=m" (sw), "=m" (*dest)
6297 );
6298 FPU_CONSISTENCY_CHECK_STOP("do_fldlg2");
6299 }
6300
6301 static void do_fldl2e( float80 dest ) REGPARAM;
6302 static void do_fldl2e( float80 dest )
6303 {
6304 FPU_CONSISTENCY_CHECK_START();
6305 /* _asm {
6306 FLDL2E
6307 FXAM
6308 FNSTSW sw
6309 MOV EDI, [dest]
6310 FSTP TBYTE PTR [EDI]
6311 } */
6312 _ASM( "fldl2e \n"
6313 "fxam \n"
6314 "fnstsw %0\n"
6315 "fstpt %1\n"
6316 : "=m" (sw), "=m" (*dest)
6317 );
6318 FPU_CONSISTENCY_CHECK_STOP("do_fldl2e");
6319 }
6320
6321 static void do_fldz( float80 dest ) REGPARAM;
6322 static void do_fldz( float80 dest )
6323 {
6324 FPU_CONSISTENCY_CHECK_START();
6325 /* _asm {
6326 FLDZ
6327 FXAM
6328 FNSTSW sw
6329 MOV EDI, [dest]
6330 FSTP TBYTE PTR [EDI]
6331 } */
6332 _ASM( "fldz \n"
6333 "fxam \n"
6334 "fnstsw %0\n"
6335 "fstpt %1\n"
6336 : "=m" (sw), "=m" (*dest)
6337 );
6338 FPU_CONSISTENCY_CHECK_STOP("do_fldz");
6339 }
6340
6341 static void do_fldln2( float80 dest ) REGPARAM;
6342 static void do_fldln2( float80 dest )
6343 {
6344 FPU_CONSISTENCY_CHECK_START();
6345 /* _asm {
6346 FLDLN2
6347 FXAM
6348 FNSTSW sw
6349 MOV EDI, [dest]
6350 FSTP TBYTE PTR [EDI]
6351 } */
6352 _ASM( "fldln2 \n"
6353 "fxam \n"
6354 "fnstsw %0\n"
6355 "fstpt %1\n"
6356 : "=m" (sw), "=m" (*dest)
6357 );
6358 FPU_CONSISTENCY_CHECK_STOP("do_fldln2");
6359 }
6360
6361 static void do_fld1( float80 dest ) REGPARAM;
6362 static void do_fld1( float80 dest )
6363 {
6364 FPU_CONSISTENCY_CHECK_START();
6365 /* _asm {
6366 FLD1
6367 FXAM
6368 FNSTSW sw
6369 MOV EDI, [dest]
6370 FSTP TBYTE PTR [EDI]
6371 } */
6372 _ASM( "fld1 \n"
6373 "fxam \n"
6374 "fnstsw %0\n"
6375 "fstpt %1\n"
6376 : "=m" (sw), "=m" (*dest)
6377 );
6378 FPU_CONSISTENCY_CHECK_STOP("do_fld1");
6379 }
6380
6381
6382 /* ---------------------------- MAIN INIT ---------------------------- */
6383
6384 void fpu_init( void )
6385 {
6386 /* _asm {
6387 FSAVE m_fpu_state_original
6388 } */
6389 _ASM("fsave %0" : "=m" (m_fpu_state_original));
6390
6391 regs.fpiar = 0;
6392 regs.fpcr = 0;
6393 regs.fpsr = 0;
6394
6395 cw = CW_INITIAL;
6396 sw = SW_INITIAL;
6397 sw_accrued = 0;
6398 sw_quotient = 0;
6399
6400 for( int i=0; i<8; i++ ) {
6401 MAKE_NAN( fp_reg[i] );
6402 }
6403
6404 build_fpsr_lookup_tables();
6405 build_fpp_opp_lookup_table();
6406
6407 /* _asm {
6408 FNINIT
6409 FLDCW cw
6410 } */
6411 _ASM("fninit\nfldcw %0" : : "m" (cw));
6412
6413 do_fldpi( const_pi );
6414 do_fldlg2( const_lg2 );
6415 do_fldl2e( const_l2e );
6416 do_fldz( const_z );
6417 do_fldln2( const_ln2 );
6418 do_fld1( const_1 );
6419
6420 set_constant( const_e, "e", exp (1.0), 1 );
6421 set_constant( const_log_10_e, "Log 10 (e)", log (exp (1.0)) / log (10.0), 1 );
6422 set_constant( const_ln_10, "ln(10)", log (10.0), 1 );
6423 set_constant( const_1e1, "1.0e1", 1.0e1, 1 );
6424 set_constant( const_1e2, "1.0e2", 1.0e2, 1 );
6425 set_constant( const_1e4, "1.0e4", 1.0e4, 1 );
6426 set_constant( const_1e8, "1.0e8", 1.0e8, 1 );
6427 set_constant( const_1e16, "1.0e16", 1.0e16, 1 );
6428 set_constant( const_1e32, "1.0e32", 1.0e32, 1 );
6429 set_constant( const_1e64, "1.0e64", 1.0e64, 1 ) ;
6430 set_constant( const_1e128, "1.0e128", 1.0e128, 1 );
6431 set_constant( const_1e256, "1.0e256", 1.0e256, 1 );
6432 set_constant( const_1e512, "1.0e512", 1.0e256, 10 );
6433 set_constant( const_1e1024, "1.0e1024", 1.0e256, 100 );
6434 set_constant( const_1e2048, "1.0e2048", 1.0e256, 1000 );
6435 set_constant( const_1e4096, "1.0e4096", 1.0e256, 10000 );
6436
6437 // Just in case.
6438 /* _asm {
6439 FNINIT
6440 FLDCW cw
6441 } */
6442 _ASM("fninit\nfldcw %0" : : "m" (cw));
6443 }
6444
6445 void fpu_exit( void )
6446 {
6447 /* _asm {
6448 FRSTOR m_fpu_state_original
6449 // FNINIT
6450 } */
6451 _ASM("frstor %0" : : "m" (m_fpu_state_original));
6452 }
6453
6454 void fpu_reset( void )
6455 {
6456 fpu_exit();
6457 fpu_init();
6458 }
6459
6460 #if DEBUG
6461 #pragma optimize("",on)
6462 #endif