testmath.c@ 16122

Last change on this file since 16122 was 13840, checked in by vboxsync, 16 years ago
Hex format types (Vhx[sd] -> Rhx[sd]).
Property svn:keywords set to `Id`
File size: 24.6 KB

Line
1	/* $Id: testmath.c 13840 2008-11-05 03:31:46Z vboxsync $ */
2	/** @file
3	* Testcase for the no-crt math stuff.
4	*/
5
6
7	/*******************************************************************************
8	* Header Files *
9	*******************************************************************************/
10	#ifndef MATHTEST_STANDALONE
11	# include <iprt/assert.h>
12	# include <math.h>
13	# undef printf
14	# define printf AssertMsg2
15	#else
16	# include <stdio.h>
17	# include <math.h>
18	#endif
19
20	/* gcc starting with version 4.3 uses the MPFR library which results in more accurate results. gcc-4.3.1 seems to emit the less accurate result. So just allow both results. */
21	#define SIN180a -0.8011526357338304777463731115L
22	#define SIN180b -0.801152635733830477871L
23
24	static void bitch(const char pszWhat, const long double plrdResult, const long double *plrdExpected)
25	{
26	const unsigned char pach1 = (const unsigned char )plrdResult;
27	const unsigned char pach2 = (const unsigned char )plrdExpected;
28	#ifndef MATHTEST_STANDALONE
29	printf("error: %s - %d instead of %d\n", pszWhat, (int)(plrdResult 100000), (int)(plrdExpected 100000));
30	#else
31	printf("error: %s - %.25f instead of %.25f\n", pszWhat, (double)plrdResult, (double)plrdExpected);
32	#endif
33	printf(" %02x%02x%02x%02x-%02x%02x%02x%02x-%02x%02x\n", pach1[0], pach1[1], pach1[2], pach1[3], pach1[4], pach1[5], pach1[6], pach1[7], pach1[8], pach1[9]);
34	printf(" %02x%02x%02x%02x-%02x%02x%02x%02x-%02x%02x\n", pach2[0], pach2[1], pach2[2], pach2[3], pach2[4], pach2[5], pach2[6], pach2[7], pach2[8], pach2[9]);
35	}
36
37	static void bitchll(const char *pszWhat, long long llResult, long long llExpected)
38	{
39	#if defined(__MINGW32__) && !defined(Assert)
40	printf("error: %s - %I64d instead of %I64d\n", pszWhat, llResult, llExpected);
41	#else
42	printf("error: %s - %lld instead of %lld\n", pszWhat, llResult, llExpected);
43	#endif
44	}
45
46	static void bitchl(const char *pszWhat, long lResult, long lExpected)
47	{
48	printf("error: %s - %ld instead of %ld\n", pszWhat, lResult, lExpected);
49	}
50
51	extern int testsin(void)
52	{
53	return sinl(180.0L) == SIN180a \|\| sinl(180.0L) == SIN180b;
54	}
55
56	extern int testremainder(void)
57	{
58	static double s_rd1 = 2.5;
59	static double s_rd2 = 2.0;
60	static double s_rd3 = 0.5;
61	return remainder(s_rd1, s_rd2) == s_rd3;
62	}
63
64	static __inline__ void set_cw(unsigned cw)
65	{
66	__asm __volatile("fldcw %0" : : "m" (cw));
67	}
68
69	static __inline__ unsigned get_cw(void)
70	{
71	unsigned cw;
72	__asm __volatile("fstcw %0" : : "m" (cw));
73	return cw & 0xffff;
74	}
75
76	static long double check_lrd(const long double lrd, const unsigned long long ull, const unsigned short us)
77	{
78	static volatile long double lrd2;
79	lrd2 = lrd;
80	if ( (unsigned long long )&lrd2 != ull
81	\|\| ((unsigned short *)&lrd2)[4] != us)
82	{
83	#if defined(__MINGW32__) && !defined(Assert)
84	printf("%I64x:%04x instead of %I64x:%04x\n", (unsigned long long )&lrd2, ((unsigned short *)&lrd2)[4], ull, us);
85	#else
86	printf("%llx:%04x instead of %llx:%04x\n", (unsigned long long )&lrd2, ((unsigned short *)&lrd2)[4], ull, us);
87	#endif
88	__asm__("int3\n");
89	}
90	return lrd;
91	}
92
93
94	static long double make_lrd(const unsigned long long ull, const unsigned short us)
95	{
96	union
97	{
98	long double lrd;
99	struct
100	{
101	unsigned long long ull;
102	unsigned short us;
103	} i;
104	} u;
105
106	u.i.ull = ull;
107	u.i.us = us;
108	return u.lrd;
109	}
110
111	static long double check_lrd_cw(const long double lrd, const unsigned long long ull, const unsigned short us, const unsigned cw)
112	{
113	set_cw(cw);
114	if (cw != get_cw())
115	{
116	printf("get_cw() -> %#x expected %#x\n", get_cw(), cw);
117	__asm__("int3\n");
118	}
119	return check_lrd(lrd, ull, us);
120	}
121
122	static long double make_lrd_cw(unsigned long long ull, unsigned short us, unsigned cw)
123	{
124	set_cw(cw);
125	return check_lrd_cw(make_lrd(ull, us), ull, us, cw);
126	}
127
128	extern int testmath(void)
129	{
130	unsigned cErrors = 0;
131	long double lrdResult;
132	long double lrdExpect;
133	long double lrd;
134	#define CHECK(operation, expect) \
135	do { \
136	lrdExpect = expect; \
137	lrdResult = operation; \
138	if (lrdResult != lrdExpect) \
139	{ \
140	bitch(#operation, &lrdResult, &lrdExpect); \
141	cErrors++; \
142	} \
143	} while (0)
144
145	long long llResult;
146	long long llExpect;
147	#define CHECKLL(operation, expect) \
148	do { \
149	llExpect = expect; \
150	llResult = operation; \
151	if (llResult != llExpect) \
152	{ \
153	bitchll(#operation, llResult, llExpect); \
154	cErrors++; \
155	} \
156	} while (0)
157
158	long lResult;
159	long lExpect;
160	#define CHECKL(operation, expect) \
161	do { \
162	lExpect = expect; \
163	lResult = operation; \
164	if (lResult != lExpect) \
165	{ \
166	bitchl(#operation, lResult, lExpect); \
167	cErrors++; \
168	} \
169	} while (0)
170
171	CHECK(atan2l(1.0L, 1.0L), 0.785398163397448309603L);
172	CHECK(atan2l(2.3L, 3.3L), 0.608689307327411694890L);
173
174	CHECK(ceill(1.9L), 2.0L);
175	CHECK(ceill(4.5L), 5.0L);
176	CHECK(ceill(3.3L), 4.0L);
177	CHECK(ceill(6.1L), 7.0L);
178
179	CHECK(floorl(1.9L), 1.0L);
180	CHECK(floorl(4.5L), 4.0L);
181	CHECK(floorl(7.3L), 7.0L);
182	CHECK(floorl(1234.1L), 1234.0L);
183	CHECK(floor(1233.1), 1233.0);
184	CHECK(floor(1239.98989898), 1239.0);
185	CHECK(floorf(9999.999), 9999.0);
186
187	CHECK(ldexpl(1.0L, 1), 2.0L);
188	CHECK(ldexpl(1.0L, 10), 1024.0L);
189	CHECK(ldexpl(2.25L, 10), 2304.0L);
190
191	CHECKLL(llrintl(1.0L), 1);
192	CHECKLL(llrintl(1.3L), 1);
193	CHECKLL(llrintl(1.5L), 2);
194	CHECKLL(llrintl(1.9L), 2);
195	CHECKLL(llrintf(123.34), 123);
196	CHECKLL(llrintf(-123.50), -124);
197	CHECKLL(llrint(42.42), 42);
198	CHECKLL(llrint(-2147483648.12343), -2147483648LL);
199	#if !defined(RT_ARCH_AMD64)
200	CHECKLL(lrint(-21474836499.12343), -2147483648LL);
201	CHECKLL(lrint(-2147483649932412.12343), -2147483648LL);
202	#else
203	CHECKLL(lrint(-21474836499.12343), -21474836499L);
204	CHECKLL(lrint(-2147483649932412.12343), -2147483649932412L);
205	#endif
206
207	// __asm__("int3");
208	CHECKL(lrintl(make_lrd_cw(000000000000000000ULL,000000,0x027f)), 0L);
209	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x027f)), 0L);
210	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x027f)), 0L);
211	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x067f)), 0L);
212	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x067f)), 0L);
213	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x0a7f)), 1L);
214	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x0a7f)), 1L);
215	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x0e7f)), 0L);
216	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x3ffe,0x0e7f)), 0L);
217	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x027f)), 0L);
218	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x027f)), 0L);
219	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x067f)), -1L);
220	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x067f)), -1L);
221	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x0a7f)), 0L);
222	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x0a7f)), 0L);
223	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x0e7f)), 0L);
224	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0xbffe,0x0e7f)), 0L);
225	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x027f)), 0L);
226	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x027f)), 0L);
227	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x067f)), 0L);
228	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x067f)), 0L);
229	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x0a7f)), 1L);
230	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x0a7f)), 1L);
231	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x0e7f)), 0L);
232	CHECKL(lrintl(make_lrd_cw(0x9249249249249000ULL,0x3ffc,0x0e7f)), 0L);
233	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x027f)), 0L);
234	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x027f)), 0L);
235	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x067f)), -1L);
236	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x067f)), -1L);
237	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x0a7f)), 0L);
238	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x0a7f)), 0L);
239	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x0e7f)), 0L);
240	CHECKL(lrintl(make_lrd_cw(0xe38e38e38e38e000ULL,0xbffb,0x0e7f)), 0L);
241	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x027f)), 32768L);
242	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x027f)), 32768L);
243	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x067f)), 32768L);
244	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x067f)), 32768L);
245	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x0a7f)), 32768L);
246	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x0a7f)), 32768L);
247	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x0e7f)), 32768L);
248	CHECKL(lrintl(make_lrd_cw(0x8000000000000000ULL,0x400e,0x0e7f)), 32768L);
249	#if !defined(RT_ARCH_AMD64)
250	/* c90 says that the constant is 2147483648 (which is not representable as a signed 32-bit
251	* value). To that constant you've then applied the negation operation. c90 doesn't have
252	* negative constants, only positive ones that have been negated. */
253	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x027f)), (long)(-2147483647L - 1));
254	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x027f)), (long)(-2147483647L - 1));
255	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x067f)), (long)(-2147483647L - 1));
256	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x067f)), (long)(-2147483647L - 1));
257	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x0a7f)), (long)(-2147483647L - 1));
258	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x0a7f)), (long)(-2147483647L - 1));
259	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x0e7f)), (long)(-2147483647L - 1));
260	CHECKL(lrintl(make_lrd_cw(0xad78ebc5ac620000ULL,0xc041,0x0e7f)), (long)(-2147483647L - 1));
261	#endif
262	set_cw(0x27f);
263
264	CHECK(logl(2.7182818284590452353602874713526625L), 1.0);
265
266	CHECK(remainderl(1.0L, 1.0L), 0.0);
267	CHECK(remainderl(1.0L, 1.5L), -0.5);
268	CHECK(remainderl(42.0L, 34.25L), 7.75);
269	CHECK(remainderf(43.0, 34.25), 8.75);
270	CHECK(remainder(44.25, 34.25), 10.00);
271	double rd1 = 44.25;
272	double rd2 = 34.25;
273	CHECK(remainder(rd1, rd2), 10.00);
274	CHECK(remainder(2.5, 2.0), 0.5);
275	CHECK(remainder(2.5, 2.0), 0.5);
276	CHECK(remainder(2.5, 2.0), 0.5);
277	CHECKLL(testremainder(), 1);
278
279
280	CHECK(rintl(1.0L), 1.0);
281	CHECK(rintl(1.4L), 1.0);
282	CHECK(rintl(1.3L), 1.0);
283	CHECK(rintl(0.9L), 1.0);
284	CHECK(rintl(3123.1232L), 3123.0);
285	CHECK(rint(3985.13454), 3985.0);
286	CHECK(rintf(9999.999), 10000.0);
287
288	CHECK(sinl(1.0L), 0.84147098480789650664L);
289	lrd = 180.0L;
290	CHECK(sinl(lrd), -0.801152635733830477871L);
291	#if 0
292	CHECK(sinl(180.0L), SIN180);
293	#else
294	lrdExpect = SIN180a;
295	lrdResult = sinl(180.0L);
296	if (lrdResult != lrdExpect)
297	{
298	lrdExpect = SIN180b;
299	if (lrdResult != lrdExpect)
300	{
301	bitch("sinl(180.0L)", &lrdResult, &lrdExpect);
302	cErrors++;
303	}
304	}
305	#endif
306	CHECKLL(testsin(), 1);
307
308	CHECK(sqrtl(1.0L), 1.0);
309	CHECK(sqrtl(4.0L), 2.0);
310	CHECK(sqrtl(1525225.0L), 1235.0);
311
312	CHECK(tanl(0.0L), 0.0);
313	CHECK(tanl(0.7853981633974483096156608458198757L), 1.0);
314
315	CHECK(powl(0.0, 0.0), 1.0);
316	CHECK(powl(2.0, 2.0), 4.0);
317	CHECK(powl(3.0, 3.0), 27.0);
318
319	return cErrors;
320	}
321
322
323	/////////////////////////////////////////////////////////////////////////////////////////
324	/////////////////////////////////////////////////////////////////////////////////////////
325	/////////////////////////////////////////////////////////////////////////////////////////
326	#if 0
327
328	#define floatx_to_int32 floatx80_to_int32
329	#define floatx_to_int64 floatx80_to_int64
330	#define floatx_to_int32_round_to_zero floatx80_to_int32_round_to_zero
331	#define floatx_to_int64_round_to_zero floatx80_to_int64_round_to_zero
332	#define floatx_abs floatx80_abs
333	#define floatx_chs floatx80_chs
334	#define floatx_round_to_int(foo, bar) floatx80_round_to_int(foo, NULL)
335	#define floatx_compare floatx80_compare
336	#define floatx_compare_quiet floatx80_compare_quiet
337	#undef sin
338	#undef cos
339	#undef sqrt
340	#undef pow
341	#undef log
342	#undef tan
343	#undef atan2
344	#undef floor
345	#undef ceil
346	#undef ldexp
347	#define sin sinl
348	#define cos cosl
349	#define sqrt sqrtl
350	#define pow powl
351	#define log logl
352	#define tan tanl
353	#define atan2 atan2l
354	#define floor floorl
355	#define ceil ceill
356	#define ldexp ldexpl
357
358
359	typedef long double CPU86_LDouble;
360
361	typedef union {
362	long double d;
363	struct {
364	unsigned long long lower;
365	unsigned short upper;
366	} l;
367	} CPU86_LDoubleU;
368
369	/* the following deal with x86 long double-precision numbers */
370	#define MAXEXPD 0x7fff
371	#define EXPBIAS 16383
372	#define EXPD(fp) (fp.l.upper & 0x7fff)
373	#define SIGND(fp) ((fp.l.upper) & 0x8000)
374	#define MANTD(fp) (fp.l.lower)
375	#define BIASEXPONENT(fp) fp.l.upper = (fp.l.upper & ~(0x7fff)) \| EXPBIAS
376
377	typedef long double floatx80;
378	#define STATUS_PARAM , void *pv
379
380	static floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)
381	{
382	return rintl(a);
383	}
384
385
386
387	struct myenv
388	{
389	unsigned int fpstt; /* top of stack index */
390	unsigned int fpus;
391	unsigned int fpuc;
392	unsigned char fptags[8]; /* 0 = valid, 1 = empty */
393	union {
394	#ifdef USE_X86LDOUBLE
395	CPU86_LDouble d __attribute__((aligned(16)));
396	#else
397	CPU86_LDouble d;
398	#endif
399	} fpregs[8];
400
401	} my_env, env_org, env_res, *env = &my_env;
402
403
404	#define ST0 (env->fpregs[env->fpstt].d)
405	#define ST(n) (env->fpregs[(env->fpstt + (n)) & 7].d)
406	#define ST1 ST(1)
407	#define MAXTAN 9223372036854775808.0
408
409
410	static inline void fpush(void)
411	{
412	env->fpstt = (env->fpstt - 1) & 7;
413	env->fptags[env->fpstt] = 0; /* validate stack entry */
414	}
415
416	static inline void fpop(void)
417	{
418	env->fptags[env->fpstt] = 1; /* invvalidate stack entry */
419	env->fpstt = (env->fpstt + 1) & 7;
420	}
421
422	static void helper_f2xm1(void)
423	{
424	ST0 = pow(2.0,ST0) - 1.0;
425	}
426
427	static void helper_fyl2x(void)
428	{
429	CPU86_LDouble fptemp;
430
431	fptemp = ST0;
432	if (fptemp>0.0){
433	fptemp = log(fptemp)/log(2.0); /* log2(ST) */
434	ST1 *= fptemp;
435	fpop();
436	} else {
437	env->fpus &= (~0x4700);
438	env->fpus \|= 0x400;
439	}
440	}
441
442	static void helper_fptan(void)
443	{
444	CPU86_LDouble fptemp;
445
446	fptemp = ST0;
447	if((fptemp > MAXTAN)\|\|(fptemp < -MAXTAN)) {
448	env->fpus \|= 0x400;
449	} else {
450	ST0 = tan(fptemp);
451	fpush();
452	ST0 = 1.0;
453	env->fpus &= (~0x400); /* C2 <-- 0 */
454	/* the above code is for \|arg\| < 2*52 only /
455	}
456	}
457
458	static void helper_fpatan(void)
459	{
460	CPU86_LDouble fptemp, fpsrcop;
461
462	fpsrcop = ST1;
463	fptemp = ST0;
464	ST1 = atan2(fpsrcop,fptemp);
465	fpop();
466	}
467
468	static void helper_fxtract(void)
469	{
470	CPU86_LDoubleU temp;
471	unsigned int expdif;
472
473	temp.d = ST0;
474	expdif = EXPD(temp) - EXPBIAS;
475	/DP exponent bias/
476	ST0 = expdif;
477	fpush();
478	BIASEXPONENT(temp);
479	ST0 = temp.d;
480	}
481
482	static void helper_fprem1(void)
483	{
484	CPU86_LDouble dblq, fpsrcop, fptemp;
485	CPU86_LDoubleU fpsrcop1, fptemp1;
486	int expdif;
487	int q;
488
489	fpsrcop = ST0;
490	fptemp = ST1;
491	fpsrcop1.d = fpsrcop;
492	fptemp1.d = fptemp;
493	expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
494	if (expdif < 53) {
495	dblq = fpsrcop / fptemp;
496	dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
497	ST0 = fpsrcop - fptemp*dblq;
498	q = (int)dblq; /* cutting off top bits is assumed here */
499	env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
500	/* (C0,C1,C3) <-- (q2,q1,q0) */
501	env->fpus \|= (q&0x4) << 6; /* (C0) <-- q2 */
502	env->fpus \|= (q&0x2) << 8; /* (C1) <-- q1 */
503	env->fpus \|= (q&0x1) << 14; /* (C3) <-- q0 */
504	} else {
505	env->fpus \|= 0x400; /* C2 <-- 1 */
506	fptemp = pow(2.0, expdif-50);
507	fpsrcop = (ST0 / ST1) / fptemp;
508	/* fpsrcop = integer obtained by rounding to the nearest */
509	fpsrcop = (fpsrcop-floor(fpsrcop) < ceil(fpsrcop)-fpsrcop)?
510	floor(fpsrcop): ceil(fpsrcop);
511	ST0 -= (ST1 * fpsrcop * fptemp);
512	}
513	}
514
515	static void helper_fprem(void)
516	{
517	#if 0
518	LogFlow(("helper_fprem: ST0=%.Rhxs ST1=%.Rhxs fpus=%#x\n", sizeof(ST0), &ST0, sizeof(ST1), &ST1, env->fpus));
519
520	__asm__ __volatile__("fldt (%2)\n"
521	"fldt (%1)\n"
522	"fprem \n"
523	"fnstsw (%0)\n"
524	"fstpt (%1)\n"
525	"fstpt (%2)\n"
526	: : "r" (&env->fpus), "r" (&ST0), "r" (&ST1) : "memory");
527
528	LogFlow(("helper_fprem: -> ST0=%.*Rhxs fpus=%#x c\n", sizeof(ST0), &ST0, env->fpus));
529	#else
530	CPU86_LDouble dblq, fpsrcop, fptemp;
531	CPU86_LDoubleU fpsrcop1, fptemp1;
532	int expdif;
533	int q;
534
535	fpsrcop = ST0;
536	fptemp = ST1;
537	fpsrcop1.d = fpsrcop;
538	fptemp1.d = fptemp;
539
540	expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
541	if ( expdif < 53 ) {
542	dblq = fpsrcop / fptemp;
543	dblq = (dblq < 0.0)? ceil(dblq): floor(dblq);
544	ST0 = fpsrcop - fptemp*dblq;
545	q = (int)dblq; /* cutting off top bits is assumed here */
546	env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
547	/* (C0,C1,C3) <-- (q2,q1,q0) */
548	env->fpus \|= (q&0x4) << 6; /* (C0) <-- q2 */
549	env->fpus \|= (q&0x2) << 8; /* (C1) <-- q1 */
550	env->fpus \|= (q&0x1) << 14; /* (C3) <-- q0 */
551	} else {
552	env->fpus \|= 0x400; /* C2 <-- 1 */
553	fptemp = pow(2.0, expdif-50);
554	fpsrcop = (ST0 / ST1) / fptemp;
555	/* fpsrcop = integer obtained by chopping */
556	fpsrcop = (fpsrcop < 0.0)?
557	-(floor(fabs(fpsrcop))): floor(fpsrcop);
558	ST0 -= (ST1 * fpsrcop * fptemp);
559	}
560	#endif
561	}
562
563	static void helper_fyl2xp1(void)
564	{
565	CPU86_LDouble fptemp;
566
567	fptemp = ST0;
568	if ((fptemp+1.0)>0.0) {
569	fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
570	ST1 *= fptemp;
571	fpop();
572	} else {
573	env->fpus &= (~0x4700);
574	env->fpus \|= 0x400;
575	}
576	}
577
578	static void helper_fsqrt(void)
579	{
580	CPU86_LDouble fptemp;
581
582	fptemp = ST0;
583	if (fptemp<0.0) {
584	env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
585	env->fpus \|= 0x400;
586	}
587	ST0 = sqrt(fptemp);
588	}
589
590	static void helper_fsincos(void)
591	{
592	CPU86_LDouble fptemp;
593
594	fptemp = ST0;
595	if ((fptemp > MAXTAN)\|\|(fptemp < -MAXTAN)) {
596	env->fpus \|= 0x400;
597	} else {
598	ST0 = sin(fptemp);
599	fpush();
600	ST0 = cos(fptemp);
601	env->fpus &= (~0x400); /* C2 <-- 0 */
602	/* the above code is for \|arg\| < 2*63 only /
603	}
604	}
605
606	static void helper_frndint(void)
607	{
608	ST0 = floatx_round_to_int(ST0, &env->fp_status);
609	}
610
611	static void helper_fscale(void)
612	{
613	ST0 = ldexp (ST0, (int)(ST1));
614	}
615
616	static void helper_fsin(void)
617	{
618	CPU86_LDouble fptemp;
619
620	fptemp = ST0;
621	if ((fptemp > MAXTAN)\|\|(fptemp < -MAXTAN)) {
622	env->fpus \|= 0x400;
623	} else {
624	ST0 = sin(fptemp);
625	env->fpus &= (~0x400); /* C2 <-- 0 */
626	/* the above code is for \|arg\| < 2*53 only /
627	}
628	}
629
630	static void helper_fcos(void)
631	{
632	CPU86_LDouble fptemp;
633
634	fptemp = ST0;
635	if((fptemp > MAXTAN)\|\|(fptemp < -MAXTAN)) {
636	env->fpus \|= 0x400;
637	} else {
638	ST0 = cos(fptemp);
639	env->fpus &= (~0x400); /* C2 <-- 0 */
640	/* the above code is for \|arg5 < 2*63 only /
641	}
642	}
643
644	static void helper_fxam_ST0(void)
645	{
646	CPU86_LDoubleU temp;
647	int expdif;
648
649	temp.d = ST0;
650
651	env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
652	if (SIGND(temp))
653	env->fpus \|= 0x200; /* C1 <-- 1 */
654
655	/* XXX: test fptags too */
656	expdif = EXPD(temp);
657	if (expdif == MAXEXPD) {
658	#ifdef USE_X86LDOUBLE
659	if (MANTD(temp) == 0x8000000000000000ULL)
660	#else
661	if (MANTD(temp) == 0)
662	#endif
663	env->fpus \|= 0x500 /Infinity/;
664	else
665	env->fpus \|= 0x100 /NaN/;
666	} else if (expdif == 0) {
667	if (MANTD(temp) == 0)
668	env->fpus \|= 0x4000 /Zero/;
669	else
670	env->fpus \|= 0x4400 /Denormal/;
671	} else {
672	env->fpus \|= 0x400;
673	}
674	}
675
676
677	void check_env(void)
678	{
679	int i;
680	for (i = 0; i < 8; i++)
681	{
682	CPU86_LDoubleU my, res;
683	my.d = env->fpregs[i].d;
684	res.d = env_res.fpregs[i].d;
685
686	if ( my.l.lower != res.l.lower
687	\|\| my.l.upper != res.l.upper)
688	printf("register %i: %#018llx:%#06x\n"
689	" expected %#018llx:%#06x\n",
690	i,
691	my.l.lower, my.l.upper,
692	res.l.lower, res.l.upper);
693	}
694	for (i = 0; i < 8; i++)
695	if (env->fptags[i] != env_res.fptags[i])
696	printf("tag %i: %d != %d\n", i, env->fptags[i], env_res.fptags[i]);
697	if (env->fpstt != env_res.fpstt)
698	printf("fpstt: %#06x != %#06x\n", env->fpstt, env_res.fpstt);
699	if (env->fpuc != env_res.fpuc)
700	printf("fpuc: %#06x != %#06x\n", env->fpuc, env_res.fpuc);
701	if (env->fpus != env_res.fpus)
702	printf("fpus: %#06x != %#06x\n", env->fpus, env_res.fpus);
703	}
704	#endif /* not used. */
705
706	#if 0 /* insert this into helper.c */
707	/* FPU helpers */
708	CPU86_LDoubleU my_st[8];
709	unsigned int my_fpstt;
710	unsigned int my_fpus;
711	unsigned int my_fpuc;
712	unsigned char my_fptags[8];
713
714	void hlp_fpu_enter(void)
715	{
716	int i;
717	for (i = 0; i < 8; i++)
718	my_st[i].d = env->fpregs[i].d;
719	my_fpstt = env->fpstt;
720	my_fpus = env->fpus;
721	my_fpuc = env->fpuc;
722	memcpy(&my_fptags, &env->fptags, sizeof(my_fptags));
723	}
724
725	void hlp_fpu_leave(const char *psz)
726	{
727	int i;
728	Log(("/code/ \n"));
729	for (i = 0; i < 8; i++)
730	Log(("/code/ (unsigned long long )&env_org.fpregs[%d] = %#018llxULL; ((unsigned short *)&env_org.fpregs[%d])[4] = %#06x; env_org.fptags[%d]=%d;\n",
731	i, my_st[i].l.lower, i, my_st[i].l.upper, i, my_fptags[i]));
732	Log(("/code/ env_org.fpstt=%#x;\n", my_fpstt));
733	Log(("/code/ env_org.fpus=%#x;\n", my_fpus));
734	Log(("/code/ env_org.fpuc=%#x;\n", my_fpuc));
735	for (i = 0; i < 8; i++)
736	{
737	CPU86_LDoubleU u;
738	u.d = env->fpregs[i].d;
739	Log(("/code/ (unsigned long long )&env_res.fpregs[%d] = %#018llxULL; ((unsigned short *)&env_res.fpregs[%d])[4] = %#06x; env_res.fptags[%d]=%d;\n",
740	i, u.l.lower, i, u.l.upper, i, env->fptags[i]));
741	}
742	Log(("/code/ env_res.fpstt=%#x;\n", env->fpstt));
743	Log(("/code/ env_res.fpus=%#x;\n", env->fpus));
744	Log(("/code/ env_res.fpuc=%#x;\n", env->fpuc));
745
746	Log(("/code/ my_env = env_org;\n"));
747	Log(("/code/ %s();\n", psz));
748	Log(("/code/ check_env();\n"));
749	}
750	#endif /* helper.c */
751
752	extern void testmath2(void )
753	{
754	#if 0
755	#include "/tmp/code.h"
756	#endif
757	}
758
759
760	/////////////////////////////////////////////////////////////////////////////////////////
761	/////////////////////////////////////////////////////////////////////////////////////////
762	/////////////////////////////////////////////////////////////////////////////////////////
763
764	#ifdef MATHTEST_STANDALONE
765
766	void test_fops(double a, double b)
767	{
768	printf("a=%f b=%f a+b=%f\n", a, b, a + b);
769	printf("a=%f b=%f a-b=%f\n", a, b, a - b);
770	printf("a=%f b=%f ab=%f\n", a, b, a b);
771	printf("a=%f b=%f a/b=%f\n", a, b, a / b);
772	printf("a=%f b=%f fmod(a, b)=%f\n", a, b, (double)fmod(a, b));
773	printf("a=%f sqrt(a)=%f\n", a, (double)sqrtl(a));
774	printf("a=%f sin(a)=%f\n", a, (double)sinl(a));
775	printf("a=%f cos(a)=%f\n", a, (double)cos(a));
776	printf("a=%f tan(a)=%f\n", a, (double)tanl(a));
777	printf("a=%f log(a)=%f\n", a, (double)log(a));
778	printf("a=%f exp(a)=%f\n", a, (double)exp(a));
779	printf("a=%f b=%f atan2(a, b)=%f\n", a, b, atan2(a, b));
780	/* just to test some op combining */
781	printf("a=%f asin(sinl(a))=%f\n", a, (double)asin(sinl(a)));
782	printf("a=%f acos(cos(a))=%f\n", a, (double)acos(cos(a)));
783	printf("a=%f atan(tanl(a))=%f\n", a, (double)atan(tanl(a)));
784	}
785
786	int main()
787	{
788	unsigned cErrors = testmath();
789
790	testmath2();
791	test_fops(2, 3);
792	test_fops(1.4, -5);
793
794	printf("cErrors=%d\n", cErrors);
795	return cErrors;
796	}
797	#endif
798

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/recompiler/Sun/testmath.c@ 16122

Download in other formats: