ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/uae_cpu/fpp.cpp

Comparing BasiliskII/src/uae_cpu/fpp.cpp (file contents):
Revision 1.4 by cebix, 1999-10-28T09:31:41Z vs.
Revision 1.9 by gbeauche, 2000-09-05T16:53:47Z

#	Line 43 | Line 43
43		* FDBcc:
44		*  The loop termination condition was wrong.
45		*  Possible leak from int16 to int32 fixed.
46	<	* Now fpcr high 16 bits are always read as zeores, no matter what was
46	>	* get_fp_value:
47	>	*  Immediate addressing mode && Operation Length == Byte ->
48	>	*  Use the low-order byte of the extension word.
49	>	* Now fpcr high 16 bits are always read as zeroes, no matter what was
50		* written to them.
51		*
52		* Other:
#	Line 71 | Line 74
74		#include "memory.h"
75		#include "readcpu.h"
76		#include "newcpu.h"
77	+	#include "main.h"
78
79		#define DEBUG 0
80		#include "debug.h"
#	Line 376 | Line 380 | static __inline__ double to_exten(uae_u3
380		if( wrd2 | wrd3 ) {
381		// mantissa, not fraction.
382		uae_u64 man = ((uae_u64)wrd2 << 32) | wrd3;
383	<	while( (man & UVAL64(0x8000000000000000)) == 0 ) {
383	>	while( exp > 0 && (man & UVAL64(0x8000000000000000)) == 0 ) {
384		man <<= 1;
385		exp--;
386		}
#	Line 411 | Line 415 | static __inline__ double to_exten(uae_u3
415		return(result);
416		}
417
418	+	/*
419	+	Would be so much easier with full size floats :(
420	+	... this is so vague.
421	+	*/
422	+	static __inline__ void to_exten_no_normalize(
423	+	uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3, uae_u32 *p
424	+	)
425	+	{
426	+	// double result;
427	+	// uae_u32 *p = (uae_u32 *)&result;
428	+
429	+	// Is it zero?
430	+	if ((wrd1 & 0x7fff0000) == 0 && wrd2 == 0 && wrd3 == 0) {
431	+	MAKE_ZERO_POSITIVE(p);
432	+	return;
433	+	}
434	+
435	+	// Is it NaN?
436	+	if( (wrd1 & 0x7FFF0000) == 0x7FFF0000 ) {
437	+	if( (wrd1 & 0x0000FFFF) || wrd2 || wrd3 ) {
438	+	MAKE_NAN( p );
439	+	return;
440	+	}
441	+	}
442	+
443	+	uae_u32 sign =  wrd1 & 0x80000000;
444	+	uae_u32 exp  = (wrd1 >> 16) & 0x7fff;
445	+
446	+	if(exp < 16383 - 1023) {
447	+	// should set underflow.
448	+	exp = 0;
449	+	} else if(exp > 16383 + 1023) {
450	+	// should set overflow.
451	+	exp = 2047;
452	+	} else {
453	+	exp = exp + 1023 - 16383;
454	+	}
455	+
456	+	// drop the explicit integer bit.
457	+	p[FLO] = (wrd2 << 21) | (wrd3 >> 11);
458	+	p[FHI] = sign | (exp << 20) | ((wrd2 & 0x7FFFFFFF) >> 11);
459	+
460	+	D(bug("to_exten (%X,%X,%X) = %.04f\r\n",wrd1,wrd2,wrd3,(float)(*(double *)p)));
461	+
462	+	// return(result);
463	+	}
464	+
465		static __inline__ void from_exten(double src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
466		{
467		uae_u32 *p = (uae_u32 *)&src;
#	Line 458 | Line 509 | static __inline__ double to_double(uae_u
509
510		static __inline__ void from_double(double src, uae_u32 * wrd1, uae_u32 * wrd2)
511		{
512	+	/*
513		if (src == 0.0) {
514		*wrd1 = *wrd2 = 0;
515		return;
516		}
517	+	*/
518		uae_u32 *p = (uae_u32 *)&src;
519		*wrd2 = p[FLO];
520		*wrd1 = p[FHI];
#	Line 800 | Line 853 | static __inline__ int get_fp_value (uae_
853		case 4:
854		ad = m68k_getpc ();
855		m68k_setpc (ad + sz2[size]);
856	+	// Immediate addressing mode && Operation Length == Byte ->
857	+	// Use the low-order byte of the extension word.
858	+	if(size == 6) ad++;
859		break;
860		default:
861		return 0;
#	Line 871 | Line 927 | static __inline__ int put_fp_value (doub
927		int mode;
928		int reg;
929		uae_u32 ad;
930	<	static int sz1[8] =
931	<	{4, 4, 12, 12, 2, 8, 1, 0};
876	<	static int sz2[8] =
877	<	{4, 4, 12, 12, 2, 8, 2, 0};
930	>	static int sz1[8] = {4, 4, 12, 12, 2, 8, 1, 0};
931	>	static int sz2[8] = {4, 4, 12, 12, 2, 8, 2, 0};
932
933		// D(bug("put_fp_value(%.04f,%X,%X)\r\n",(float)value,(int)opcode,(int)extra));
934
#	Line 1054 | Line 1108 | static __inline__ int get_fp_ad(uae_u32
1108		return 1;
1109		}
1110
1111	<	static __inline__ int fpp_cond(uae_u32 opcode, int contition)
1111	>	static __inline__ int fpp_cond(uae_u32 opcode, int condition)
1112		{
1113	<	int N = (regs.fpsr & 0x8000000) != 0;
1114	<	int Z = (regs.fpsr & 0x4000000) != 0;
1115	<	/* int I = (regs.fpsr & 0x2000000) != 0; */
1116	<	int NotANumber = (regs.fpsr & 0x1000000) != 0;
1113	>	#define N ((regs.fpsr & 0x8000000) != 0)
1114	>	#define Z ((regs.fpsr & 0x4000000) != 0)
1115	>	#define I ((regs.fpsr & 0x2000000) != 0)
1116	>	#define NotANumber ((regs.fpsr & 0x1000000) != 0)
1117
1118	<	switch (contition) {
1118	>	switch (condition) {
1119		case 0x00:
1120		CONDRET("False",0);
1121		case 0x01:
#	Line 1127 | Line 1181 | static __inline__ int fpp_cond(uae_u32 o
1181		CONDRET("Signaling Not Equal",!Z);
1182		case 0x1f:
1183		CONDRET("Signaling True",1);
1184	+	default:
1185	+	CONDRET("",-1);
1186		}
1187	<	CONDRET("",-1);
1187	>	#undef N
1188	>	#undef Z
1189	>	#undef I
1190	>	#undef NotANumber
1191		}
1192
1193	<	void fdbcc_opp(uae_u32 opcode, uae_u16 extra)
1193	>	void REGPARAM2 fdbcc_opp(uae_u32 opcode, uae_u16 extra)
1194		{
1195		uaecptr pc = (uae_u32) m68k_getpc ();
1196		uae_s32 disp = (uae_s32) (uae_s16) next_iword();
#	Line 1162 | Line 1221 | void fdbcc_opp(uae_u32 opcode, uae_u16 e
1221		}
1222		}
1223
1224	<	void fscc_opp(uae_u32 opcode, uae_u16 extra)
1224	>	void REGPARAM2 fscc_opp(uae_u32 opcode, uae_u16 extra)
1225		{
1226		uae_u32 ad;
1227		int cc;
#	Line 1185 | Line 1244 | void fscc_opp(uae_u32 opcode, uae_u16 ex
1244		}
1245		}
1246
1247	<	void ftrapcc_opp(uae_u32 opcode, uaecptr oldpc)
1247	>	void REGPARAM2 ftrapcc_opp(uae_u32 opcode, uaecptr oldpc)
1248		{
1249		int cc;
1250
#	Line 1201 | Line 1260 | void ftrapcc_opp(uae_u32 opcode, uaecptr
1260		}
1261
1262		// NOTE that we get here also when there is a FNOP (nontrapping false, displ 0)
1263	<	void fbcc_opp(uae_u32 opcode, uaecptr pc, uae_u32 extra)
1263	>	void REGPARAM2 fbcc_opp(uae_u32 opcode, uaecptr pc, uae_u32 extra)
1264		{
1265		int cc;
1266
#	Line 1220 | Line 1279 | void fbcc_opp(uae_u32 opcode, uaecptr pc
1279
1280		// FSAVE has no post-increment
1281		// 0x1f180000 == IDLE state frame, coprocessor version number 1F
1282	<	void fsave_opp(uae_u32 opcode)
1282	>	void REGPARAM2 fsave_opp(uae_u32 opcode)
1283		{
1284		uae_u32 ad;
1285		int incr = (opcode & 0x38) == 0x20 ? -1 : 1;
#	Line 1234 | Line 1293 | void fsave_opp(uae_u32 opcode)
1293		return;
1294		}
1295
1296	<	// Put 28 byte IDLE frame.
1297	<	// NOTE!!! IDLE frame is only 4 bytes on a 68040!!
1298	<
1299	<	if (incr < 0) {
1300	<	D(bug("fsave_opp pre-decrement\r\n"));
1301	<	ad -= 4;
1302	<	// What's this? Some BIU flags, or (incorrectly placed) command/condition?
1303	<	put_long (ad, 0x70000000);
1245	<	for (i = 0; i < 5; i++) {
1246	<	ad -= 4;
1247	<	put_long (ad, 0x00000000);
1248	<	}
1249	<	ad -= 4;
1250	<	put_long (ad, 0x1f180000); // IDLE, vers 1f
1251	<	} else {
1252	<	put_long (ad, 0x1f180000); // IDLE, vers 1f
1253	<	ad += 4;
1254	<	for (i = 0; i < 5; i++) {
1255	<	put_long (ad, 0x00000000);
1256	<	ad += 4;
1296	>	if (CPUType == 4) {
1297	>	// Put 4 byte 68040 IDLE frame.
1298	>	if (incr < 0) {
1299	>	ad -= 4;
1300	>	put_long (ad, 0x41000000);
1301	>	} else {
1302	>	put_long (ad, 0x41000000);
1303	>	ad += 4;
1304		}
1305	<	// What's this? Some BIU flags, or (incorrectly placed) command/condition?
1306	<	put_long (ad, 0x70000000);
1307	<	ad += 4;
1308	<	}
1305	>	} else {
1306	>	// Put 28 byte 68881 IDLE frame.
1307	>	if (incr < 0) {
1308	>	D(bug("fsave_opp pre-decrement\r\n"));
1309	>	ad -= 4;
1310	>	// What's this? Some BIU flags, or (incorrectly placed) command/condition?
1311	>	put_long (ad, 0x70000000);
1312	>	for (i = 0; i < 5; i++) {
1313	>	ad -= 4;
1314	>	put_long (ad, 0x00000000);
1315	>	}
1316	>	ad -= 4;
1317	>	put_long (ad, 0x1f180000); // IDLE, vers 1f
1318	>	} else {
1319	>	put_long (ad, 0x1f180000); // IDLE, vers 1f
1320	>	ad += 4;
1321	>	for (i = 0; i < 5; i++) {
1322	>	put_long (ad, 0x00000000);
1323	>	ad += 4;
1324	>	}
1325	>	// What's this? Some BIU flags, or (incorrectly placed) command/condition?
1326	>	put_long (ad, 0x70000000);
1327	>	ad += 4;
1328	>	}
1329	>	}
1330		if ((opcode & 0x38) == 0x18) {
1331		m68k_areg (regs, opcode & 7) = ad; // Never executed on a 68881
1332		D(bug("PROBLEM: fsave_opp post-increment\r\n"));
#	Line 1269 | Line 1337 | void fsave_opp(uae_u32 opcode)
1337		}
1338		}
1339
1340	<	// FSAVE has no pre-decrement
1341	<	void frestore_opp(uae_u32 opcode)
1340	>	// FRESTORE has no pre-decrement
1341	>	void REGPARAM2 frestore_opp(uae_u32 opcode)
1342		{
1343		uae_u32 ad;
1344		uae_u32 d;
#	Line 1284 | Line 1352 | void frestore_opp(uae_u32 opcode)
1352		return;
1353		}
1354
1355	<	if (incr < 0) {
1356	<
1357	<	D(bug("PROBLEM: frestore_opp incr < 0\r\n"));
1358	<
1359	<	// this may be wrong, but it's never called.
1360	<	ad -= 4;
1361	<	d = get_long (ad);
1362	<	if ((d & 0xff000000) != 0) {
1363	<	if ((d & 0x00ff0000) == 0x00180000)
1364	<	ad -= 6 * 4;
1365	<	else if ((d & 0x00ff0000) == 0x00380000)
1366	<	ad -= 14 * 4;
1367	<	else if ((d & 0x00ff0000) == 0x00b40000)
1368	<	ad -= 45 * 4;
1355	>	if (CPUType == 4) {
1356	>	// 68040
1357	>	if (incr < 0) {
1358	>	D(bug("PROBLEM: frestore_opp incr < 0\r\n"));
1359	>	// this may be wrong, but it's never called.
1360	>	ad -= 4;
1361	>	d = get_long (ad);
1362	>	if ((d & 0xff000000) != 0) { // Not a NULL frame?
1363	>	if ((d & 0x00ff0000) == 0) { // IDLE
1364	>	D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
1365	>	} else if ((d & 0x00ff0000) == 0x00300000) { // UNIMP
1366	>	D(bug("PROBLEM: frestore_opp found UNIMP frame at %X\r\n",ad-4));
1367	>	ad -= 44;
1368	>	} else if ((d & 0x00ff0000) == 0x00600000) { // BUSY
1369	>	D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
1370	>	ad -= 92;
1371	>	}
1372	>	}
1373	>	} else {
1374	>	d = get_long (ad);
1375	>	D(bug("frestore_opp frame at %X = %X\r\n",ad,d));
1376	>	ad += 4;
1377	>	if ((d & 0xff000000) != 0) { // Not a NULL frame?
1378	>	if ((d & 0x00ff0000) == 0) { // IDLE
1379	>	D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
1380	>	} else if ((d & 0x00ff0000) == 0x00300000) { // UNIMP
1381	>	D(bug("PROBLEM: frestore_opp found UNIMP frame at %X\r\n",ad-4));
1382	>	ad += 44;
1383	>	} else if ((d & 0x00ff0000) == 0x00600000) { // BUSY
1384	>	D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
1385	>	ad += 92;
1386	>	}
1387	>	}
1388		}
1389	<	} else {
1390	<	d = get_long (ad);
1391	<
1392	<	D(bug("frestore_opp frame at %X = %X\r\n",ad,d));
1393	<
1394	<	ad += 4;
1395	<	if ((d & 0xff000000) != 0) { // Not a NULL frame?
1396	<	if ((d & 0x00ff0000) == 0x00180000) { // IDLE
1397	<	D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
1398	<	ad += 6 * 4;
1399	<	} else if ((d & 0x00ff0000) == 0x00380000) {// UNIMP? shouldn't it be 3C?
1400	<	ad += 14 * 4;
1401	<	D(bug("PROBLEM: frestore_opp found UNIMP? frame at %X\r\n",ad-4));
1402	<	} else if ((d & 0x00ff0000) == 0x00b40000) {// BUSY
1403	<	D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
1404	<	ad += 45 * 4;
1389	>	} else {
1390	>	// 68881
1391	>	if (incr < 0) {
1392	>	D(bug("PROBLEM: frestore_opp incr < 0\r\n"));
1393	>	// this may be wrong, but it's never called.
1394	>	ad -= 4;
1395	>	d = get_long (ad);
1396	>	if ((d & 0xff000000) != 0) {
1397	>	if ((d & 0x00ff0000) == 0x00180000)
1398	>	ad -= 6 * 4;
1399	>	else if ((d & 0x00ff0000) == 0x00380000)
1400	>	ad -= 14 * 4;
1401	>	else if ((d & 0x00ff0000) == 0x00b40000)
1402	>	ad -= 45 * 4;
1403	>	}
1404	>	} else {
1405	>	d = get_long (ad);
1406	>	D(bug("frestore_opp frame at %X = %X\r\n",ad,d));
1407	>	ad += 4;
1408	>	if ((d & 0xff000000) != 0) { // Not a NULL frame?
1409	>	if ((d & 0x00ff0000) == 0x00180000) { // IDLE
1410	>	D(bug("frestore_opp found IDLE frame at %X\r\n",ad-4));
1411	>	ad += 6 * 4;
1412	>	} else if ((d & 0x00ff0000) == 0x00380000) {// UNIMP? shouldn't it be 3C?
1413	>	ad += 14 * 4;
1414	>	D(bug("PROBLEM: frestore_opp found UNIMP? frame at %X\r\n",ad-4));
1415	>	} else if ((d & 0x00ff0000) == 0x00b40000) {// BUSY
1416	>	D(bug("PROBLEM: frestore_opp found BUSY frame at %X\r\n",ad-4));
1417	>	ad += 45 * 4;
1418	>	}
1419		}
1420		}
1421		}
#	Line 1566 | Line 1667 | void fpp_opp(uae_u32 opcode, uae_u16 ext
1667		uae_u32 wrd1, wrd2, wrd3;
1668		if( list & 0x80 ) {
1669		from_exten(regs.fp[reg],&wrd1, &wrd2, &wrd3);
1670	<	put_long (ad, wrd3);
1670	>	put_long (ad, wrd1);
1671		ad += 4;
1672		put_long (ad, wrd2);
1673		ad += 4;
1674	<	put_long (ad, wrd1);
1674	>	put_long (ad, wrd3);
1675		ad += 4;
1676		}
1677		list <<= 1;
1678		}
1679		}
1680
1580	–	/*
1581	–	while (list) {
1582	–	uae_u32 wrd1, wrd2, wrd3;
1583	–	if (incr < 0) {
1584	–	from_exten(regs.fp[fpp_movem_index2[list]],
1585	–	&wrd1, &wrd2, &wrd3);
1586	–	ad -= 4;
1587	–	put_long (ad, wrd3);
1588	–	ad -= 4;
1589	–	put_long (ad, wrd2);
1590	–	ad -= 4;
1591	–	put_long (ad, wrd1);
1592	–	} else {
1593	–	from_exten(regs.fp[fpp_movem_index1[list]],
1594	–	&wrd1, &wrd2, &wrd3);
1595	–	put_long (ad, wrd1);
1596	–	ad += 4;
1597	–	put_long (ad, wrd2);
1598	–	ad += 4;
1599	–	put_long (ad, wrd3);
1600	–	ad += 4;
1601	–	}
1602	–	list = fpp_movem_next[list];
1603	–	}
1604	–	*/
1681		if ((opcode & 0x38) == 0x18) // post-increment?
1682		m68k_areg (regs, opcode & 7) = ad;
1683		if ((opcode & 0x38) == 0x20) // pre-decrement?
#	Line 1644 | Line 1720 | void fpp_opp(uae_u32 opcode, uae_u16 ext
1720		for(reg=7; reg>=0; reg--) {
1721		uae_u32 wrd1, wrd2, wrd3;
1722		if( list & 0x80 ) {
1647	–	wrd1 = get_long (ad);
1648	–	ad -= 4;
1649	–	wrd2 = get_long (ad);
1723		ad -= 4;
1724		wrd3 = get_long (ad);
1725		ad -= 4;
1726	<	regs.fp[reg] = to_exten (wrd1, wrd2, wrd3);
1726	>	wrd2 = get_long (ad);
1727	>	ad -= 4;
1728	>	wrd1 = get_long (ad);
1729	>	// regs.fp[reg] = to_exten (wrd1, wrd2, wrd3);
1730	>	to_exten_no_normalize (wrd1, wrd2, wrd3, (uae_u32 *)&regs.fp[reg]);
1731		}
1732		list <<= 1;
1733		}
#	Line 1664 | Line 1741 | void fpp_opp(uae_u32 opcode, uae_u16 ext
1741		ad += 4;
1742		wrd3 = get_long (ad);
1743		ad += 4;
1744	<	regs.fp[reg] = to_exten (wrd1, wrd2, wrd3);
1744	>	// regs.fp[reg] = to_exten (wrd1, wrd2, wrd3);
1745	>	to_exten_no_normalize (wrd1, wrd2, wrd3, (uae_u32 *)&regs.fp[reg]);
1746		}
1747		list <<= 1;
1748		}
1749		}
1672	–	/**/
1673	–
1674	–	/*
1675	–	while (list) {
1676	–	uae_u32 wrd1, wrd2, wrd3;
1677	–	if (incr < 0) {
1678	–	ad -= 4;
1679	–	wrd3 = get_long (ad);
1680	–	ad -= 4;
1681	–	wrd2 = get_long (ad);
1682	–	ad -= 4;
1683	–	wrd1 = get_long (ad);
1684	–	regs.fp[fpp_movem_index2[list]] = to_exten (wrd1, wrd2, wrd3);
1685	–	} else {
1686	–	wrd1 = get_long (ad);
1687	–	ad += 4;
1688	–	wrd2 = get_long (ad);
1689	–	ad += 4;
1690	–	wrd3 = get_long (ad);
1691	–	ad += 4;
1692	–	regs.fp[fpp_movem_index1[list]] = to_exten (wrd1, wrd2, wrd3);
1693	–	}
1694	–	list = fpp_movem_next[list];
1695	–	}
1696	–	*/
1750		if ((opcode & 0x38) == 0x18) // post-increment?
1751		m68k_areg (regs, opcode & 7) = ad;
1752		if ((opcode & 0x38) == 0x20) // pre-decrement?
#	Line 1824 | Line 1877 | void fpp_opp(uae_u32 opcode, uae_u16 ext
1877		dump_fp_regs( "END  ");
1878		return;
1879		}
1880	+	D(bug("returned from get_fp_value m68k_getpc()=%X\r\n",m68k_getpc()));
1881
1882		switch (extra & 0x7f) {
1883		case 0x00:              /* FMOVE */
#	Line 1942 | Line 1996 | void fpp_opp(uae_u32 opcode, uae_u16 ext
1996		MAKE_FPSR(regs.fpsr,regs.fp[reg]);
1997		break;
1998		case 0x18:              /* FABS */
1999	+	case 0x58:              /* single precision rounding */
2000	+	case 0x5C:              /* double precision rounding */
2001		D(bug("FABS %.04f\r\n",(float)src));
2002		regs.fp[reg] = src < 0 ? -src : src;
2003		MAKE_FPSR(regs.fpsr,regs.fp[reg]);
#	Line 2024 | Line 2080 | void fpp_opp(uae_u32 opcode, uae_u16 ext
2080		}
2081		break;
2082		case 0x22:              /* FADD */
2083	+	case 0x62:              /* single */
2084	+	case 0x66:              /* double */
2085		D(bug("FADD %.04f\r\n",(float)src));
2086		regs.fp[reg] += src;
2087		MAKE_FPSR(regs.fpsr,regs.fp[reg]);
2088		break;
2089		case 0x23:              /* FMUL */
2090		D(bug("FMUL %.04f\r\n",(float)src));
2091	+	#if HAVE_IEEE_DOUBLE
2092		GET_DEST_FLAGS((uae_u32 *)&regs.fp[reg]);
2093		GET_SOURCE_FLAGS((uae_u32 *)&src);
2094		if(fl_dest.in_range && fl_source.in_range) {
#	Line 2056 | Line 2115 | void fpp_opp(uae_u32 opcode, uae_u16 ext
2115		MAKE_INF_POSITIVE((uae_u32 *)&regs.fp[reg]);
2116		}
2117		}
2118	+	#else
2119	+	D(bug("FMUL %.04f\r\n",(float)src));
2120	+	regs.fp[reg] *= src;
2121	+	#endif
2122		MAKE_FPSR(regs.fpsr,regs.fp[reg]);
2123		break;
2124		case 0x24:              /* FSGLDIV */
#	Line 2160 | Line 2223 | void fpp_opp(uae_u32 opcode, uae_u16 ext
2223		}
2224		} else {
2225		double tmp = regs.fp[reg] - src;
2226	<	regs.fpsr = (regs.fpsr & 0x00FFFFFF) | (tmp == 0 ? 0x4000000 : 0) | (tmp < 0 ? 0x8000000 : 0);
2226	>	// regs.fpsr = (regs.fpsr & 0x00FFFFFF) | (tmp == 0 ? 0x4000000 : 0) | (tmp < 0 ? 0x8000000 : 0);
2227	>	regs.fpsr = (tmp == 0 ? 0x4000000 : 0) | (tmp < 0 ? 0x8000000 : 0);
2228		}
2229		#else
2230		{
#	Line 2180 | Line 2244 | void fpp_opp(uae_u32 opcode, uae_u16 ext
2244		op_illg (opcode);
2245		break;
2246		}
2247	+	D(bug("END m68k_getpc()=%X\r\n",m68k_getpc()));
2248		dump_fp_regs( "END  ");
2249		return;
2250		}
#	Line 2188 | Line 2253 | void fpp_opp(uae_u32 opcode, uae_u16 ext
2253		op_illg (opcode);
2254		dump_fp_regs( "END  ");
2255		}
2256	+
2257	+	/* -------------------------- Initialization -------------------------- */
2258	+
2259	+	void fpu_set_integral_fpu (bool is_integral)
2260	+	{
2261	+	D(bug("fpu_set_integral_fpu : %s\n", (is_integral ? "yes" : "no")));
2262	+	}
2263	+
2264	+	void fpu_init (void)
2265	+	{
2266	+	D(bug("fpu_init\n"));
2267	+	regs.fpcr = regs.fpsr = regs.fpiar = 0;
2268	+	}
2269	+
2270	+	void fpu_exit (void)
2271	+	{
2272	+	D(bug("fpu_exit\n"));
2273	+	}
2274	+
2275	+	void fpu_reset (void)
2276	+	{
2277	+	D(bug("fpu_reset\n"));
2278	+	fpu_exit();
2279	+	fpu_init();
2280	+	}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines