[thirdparty/gcc.git] / gcc / fp-test.c

/* fp-test.c - Check that all floating-point operations are available.
   Copyright (C) 1995, 2000 Free Software Foundation, Inc.
   Contributed by Ronald F. Guilmette <rfg@monkeys.com>.

   This file is part of GNU CC.

   GNU CC is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GNU CC is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GNU CC; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* This is a trivial test program which may be useful to people who are
   porting the GCC or G++ compilers to a new system.  The intent here is
   merely to check that all floating-point operations have been provided
   by the port. (Note that I say ``provided'' rather than ``implemented''.)

   To use this file, simply compile it (with GCC or G++) and then try to
   link it in the normal way (also using GCC or G++ respectively).  If
   all of the floating -point operations (including conversions) have
   been provided, then this file will link without incident.  If however
   one or more of the primitive floating-point operations have not been
   properly provided, you will get link-time errors indicating which
   floating-point operations are unavailable.

   This file will typically be used when porting the GNU compilers to
   some system which lacks floating-point hardware, and for which
   software emulation routines (for FP ops) are needed in order to
   complete the port.  */

#if 0
#include <math.h>
#endif

extern double acos (double);
extern double asin (double);
extern double atan (double);
extern double atan2 (double, double);
extern double cos (double);
extern double sin (double);
extern double tan (double);
extern double cosh (double);
extern double sinh (double);
extern double tanh (double);
extern double exp (double);
extern double frexp (double, int *);
extern double ldexp (double, int);
extern double log (double);
extern double log10 (double);
extern double modf (double, double *);
extern double pow (double, double);
extern double sqrt (double);
extern double ceil (double);
extern double fabs (double);
extern double floor (double);
extern double fmod (double, double);

int i1, i2 = 2;

volatile signed char sc;
volatile unsigned char uc;

volatile signed short ss;
volatile unsigned short us;

volatile signed int si;
volatile unsigned int ui;

volatile signed long sl;
volatile unsigned long ul;

volatile float f1 = 1.0, f2 = 1.0, f3 = 1.0;
volatile double d1 = 1.0, d2 = 1.0, d3 = 1.0;
volatile long double D1 = 1.0, D2 = 1.0, D3 = 1.0;

int
main ()
{
  /* TYPE: float */

  f1 = -f2;
  f1 = f2 + f3;
  f1 = f2 - f3;
  f1 = f2 * f3;
  f1 = f2 / f3;
  f1 += f2;
  f1 -= f2;
  f1 *= f2;
  f1 /= f2;

  si = f1 == f2;
  si = f1 != f2;
  si = f1 > f2;
  si = f1 < f2;
  si = f1 >= f2;
  si = f1 <= f2;

  si = __builtin_isgreater (f1, f2);
  si = __builtin_isgreaterequal (f1, f2);
  si = __builtin_isless (f1, f2);
  si = __builtin_islessequal (f1, f2);
  si = __builtin_islessgreater (f1, f2);
  si = __builtin_isunordered (f1, f2);

  sc = f1;
  uc = f1;
  ss = f1;
  us = f1;
  si = f1;
  ui = f1;
  sl = f1;
  ul = f1;
  d1 = f1;
  D1 = f1;

  f1 = sc;
  f1 = uc;
  f1 = ss;
  f1 = us;
  f1 = si;
  f1 = ui;
  f1 = sl;
  f1 = ul;
  f1 = d1;
  f1 = D1;

  d1 = -d2;
  d1 = d2 + d3;
  d1 = d2 - d3;
  d1 = d2 * d3;
  d1 = d2 / d3;
  d1 += d2;
  d1 -= d2;
  d1 *= d2;
  d1 /= d2;

  si = d1 == d2;
  si = d1 != d2;
  si = d1 > d2;
  si = d1 < d2;
  si = d1 >= d2;
  si = d1 <= d2;

  si = __builtin_isgreater (d1, d2);
  si = __builtin_isgreaterequal (d1, d2);
  si = __builtin_isless (d1, d2);
  si = __builtin_islessequal (d1, d2);
  si = __builtin_islessgreater (d1, d2);
  si = __builtin_isunordered (d1, d2);

  sc = d1;
  uc = d1;
  ss = d1;
  us = d1;
  si = d1;
  ui = d1;
  sl = d1;
  ul = d1;
  f1 = d1;
  D1 = d1;

  d1 = sc;
  d1 = uc;
  d1 = ss;
  d1 = us;
  d1 = si;
  d1 = ui;
  d1 = sl;
  d1 = ul;
  d1 = f1;
  d1 = D1;

  D1 = -D2;
  D1 = D2 + D3;
  D1 = D2 - D3;
  D1 = D2 * D3;
  D1 = D2 / D3;
  D1 += D2;
  D1 -= D2;
  D1 *= D2;
  D1 /= D2;

  si = D1 == D2;
  si = D1 != D2;
  si = D1 > D2;
  si = D1 < D2;
  si = D1 >= D2;
  si = D1 <= D2;

  si = __builtin_isgreater (D1, D2);
  si = __builtin_isgreaterequal (D1, D2);
  si = __builtin_isless (D1, D2);
  si = __builtin_islessequal (D1, D2);
  si = __builtin_islessgreater (D1, D2);
  si = __builtin_isunordered (D1, D2);

  sc = D1;
  uc = D1;
  ss = D1;
  us = D1;
  si = D1;
  ui = D1;
  sl = D1;
  ul = D1;
  f1 = D1;
  d1 = D1;

  D1 = sc;
  D1 = uc;
  D1 = ss;
  D1 = us;
  D1 = si;
  D1 = ui;
  D1 = sl;
  D1 = ul;
  D1 = f1;
  D1 = d1;

  d1 = acos (d2);
  d1 = asin (d2);
  d1 = atan (d2);
  d1 = atan2 (d2, d3);
  d1 = cos (d2);
  d1 = sin (d2);
  d1 = tan (d2);
  d1 = cosh (d2);
  d1 = sinh (d2);
  d1 = tanh (d2);
  d1 = exp (d2);
  d1 = frexp (d2, &i1);
  d1 = ldexp (d2, i2);
  d1 = log (d2);
  d1 = log10 (d2);
  d1 = modf (d2, &d3);
  d1 = pow (d2, d3);
  d1 = sqrt (d2);
  d1 = ceil (d2);
  d1 = fabs (d2);
  d1 = floor (d2);
  d1 = fmod (d2, d3);

  return 0;
}
Commit	Line	Data
633e2687	1	/* fp-test.c - Check that all floating-point operations are available.
1eb8759b	2	Copyright (C) 1995, 2000 Free Software Foundation, Inc.
633e2687 RK	3	Contributed by Ronald F. Guilmette <rfg@monkeys.com>.
633e2687 RK	4
1eb8759b	5	This file is part of GNU CC.
633e2687	6
1eb8759b RH	7	GNU CC is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
633e2687	11
1eb8759b RH	12	GNU CC is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
633e2687	16
1eb8759b RH	17	You should have received a copy of the GNU General Public License
	18	along with GNU CC; see the file COPYING. If not, write to
	19	the Free Software Foundation, 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
633e2687 RK	21
	22	/* This is a trivial test program which may be useful to people who are
	23	porting the GCC or G++ compilers to a new system. The intent here is
	24	merely to check that all floating-point operations have been provided
	25	by the port. (Note that I say ``provided'' rather than ``implemented''.)
	26
	27	To use this file, simply compile it (with GCC or G++) and then try to
	28	link it in the normal way (also using GCC or G++ respectively). If
	29	all of the floating -point operations (including conversions) have
	30	been provided, then this file will link without incident. If however
	31	one or more of the primitive floating-point operations have not been
	32	properly provided, you will get link-time errors indicating which
	33	floating-point operations are unavailable.
	34
	35	This file will typically be used when porting the GNU compilers to
	36	some system which lacks floating-point hardware, and for which
	37	software emulation routines (for FP ops) are needed in order to
	38	complete the port. */
	39
	40	#if 0
	41	#include <math.h>
	42	#endif
	43
	44	extern double acos (double);
	45	extern double asin (double);
	46	extern double atan (double);
	47	extern double atan2 (double, double);
	48	extern double cos (double);
	49	extern double sin (double);
	50	extern double tan (double);
	51	extern double cosh (double);
	52	extern double sinh (double);
	53	extern double tanh (double);
	54	extern double exp (double);
	55	extern double frexp (double, int *);
	56	extern double ldexp (double, int);
	57	extern double log (double);
	58	extern double log10 (double);
	59	extern double modf (double, double *);
	60	extern double pow (double, double);
	61	extern double sqrt (double);
	62	extern double ceil (double);
	63	extern double fabs (double);
	64	extern double floor (double);
	65	extern double fmod (double, double);
	66
	67	int i1, i2 = 2;
	68
	69	volatile signed char sc;
	70	volatile unsigned char uc;
	71
	72	volatile signed short ss;
	73	volatile unsigned short us;
	74
	75	volatile signed int si;
	76	volatile unsigned int ui;
	77
	78	volatile signed long sl;
	79	volatile unsigned long ul;
	80
	81	volatile float f1 = 1.0, f2 = 1.0, f3 = 1.0;
	82	volatile double d1 = 1.0, d2 = 1.0, d3 = 1.0;
	83	volatile long double D1 = 1.0, D2 = 1.0, D3 = 1.0;
	84
85	int
86	main ()
87	{
88	/* TYPE: float */
89
90	f1 = -f2;
91	f1 = f2 + f3;
92	f1 = f2 - f3;
93	f1 = f2 * f3;
94	f1 = f2 / f3;
95	f1 += f2;
96	f1 -= f2;
97	f1 *= f2;
98	f1 /= f2;
99
100	si = f1 == f2;
101	si = f1 != f2;
102	si = f1 > f2;
103	si = f1 < f2;
104	si = f1 >= f2;
105	si = f1 <= f2;
106
1eb8759b RH	107	si = __builtin_isgreater (f1, f2);
	108	si = __builtin_isgreaterequal (f1, f2);
	109	si = __builtin_isless (f1, f2);
	110	si = __builtin_islessequal (f1, f2);
	111	si = __builtin_islessgreater (f1, f2);
	112	si = __builtin_isunordered (f1, f2);
	113
633e2687 RK	114	sc = f1;
	115	uc = f1;
	116	ss = f1;
	117	us = f1;
	118	si = f1;
	119	ui = f1;
	120	sl = f1;
	121	ul = f1;
	122	d1 = f1;
	123	D1 = f1;
	124
	125	f1 = sc;
	126	f1 = uc;
	127	f1 = ss;
	128	f1 = us;
	129	f1 = si;
	130	f1 = ui;
	131	f1 = sl;
	132	f1 = ul;
	133	f1 = d1;
	134	f1 = D1;
	135
	136	d1 = -d2;
	137	d1 = d2 + d3;
	138	d1 = d2 - d3;
	139	d1 = d2 * d3;
	140	d1 = d2 / d3;
	141	d1 += d2;
	142	d1 -= d2;
	143	d1 *= d2;
	144	d1 /= d2;
	145
	146	si = d1 == d2;
	147	si = d1 != d2;
	148	si = d1 > d2;
	149	si = d1 < d2;
	150	si = d1 >= d2;
	151	si = d1 <= d2;
	152
1eb8759b RH	153	si = __builtin_isgreater (d1, d2);
	154	si = __builtin_isgreaterequal (d1, d2);
	155	si = __builtin_isless (d1, d2);
	156	si = __builtin_islessequal (d1, d2);
	157	si = __builtin_islessgreater (d1, d2);
	158	si = __builtin_isunordered (d1, d2);
	159
633e2687 RK	160	sc = d1;
	161	uc = d1;
	162	ss = d1;
	163	us = d1;
	164	si = d1;
	165	ui = d1;
	166	sl = d1;
	167	ul = d1;
	168	f1 = d1;
	169	D1 = d1;
	170
	171	d1 = sc;
	172	d1 = uc;
	173	d1 = ss;
	174	d1 = us;
	175	d1 = si;
	176	d1 = ui;
	177	d1 = sl;
	178	d1 = ul;
	179	d1 = f1;
	180	d1 = D1;
	181
	182	D1 = -D2;
	183	D1 = D2 + D3;
	184	D1 = D2 - D3;
	185	D1 = D2 * D3;
	186	D1 = D2 / D3;
	187	D1 += D2;
	188	D1 -= D2;
	189	D1 *= D2;
	190	D1 /= D2;
	191
	192	si = D1 == D2;
	193	si = D1 != D2;
	194	si = D1 > D2;
	195	si = D1 < D2;
	196	si = D1 >= D2;
	197	si = D1 <= D2;
	198
1eb8759b RH	199	si = __builtin_isgreater (D1, D2);
	200	si = __builtin_isgreaterequal (D1, D2);
	201	si = __builtin_isless (D1, D2);
	202	si = __builtin_islessequal (D1, D2);
	203	si = __builtin_islessgreater (D1, D2);
	204	si = __builtin_isunordered (D1, D2);
	205
633e2687 RK	206	sc = D1;
	207	uc = D1;
	208	ss = D1;
	209	us = D1;
	210	si = D1;
	211	ui = D1;
	212	sl = D1;
	213	ul = D1;
	214	f1 = D1;
	215	d1 = D1;
	216
	217	D1 = sc;
	218	D1 = uc;
	219	D1 = ss;
	220	D1 = us;
	221	D1 = si;
	222	D1 = ui;
	223	D1 = sl;
	224	D1 = ul;
	225	D1 = f1;
	226	D1 = d1;
	227
	228	d1 = acos (d2);
	229	d1 = asin (d2);
	230	d1 = atan (d2);
	231	d1 = atan2 (d2, d3);
	232	d1 = cos (d2);
	233	d1 = sin (d2);
	234	d1 = tan (d2);
	235	d1 = cosh (d2);
	236	d1 = sinh (d2);
	237	d1 = tanh (d2);
	238	d1 = exp (d2);
	239	d1 = frexp (d2, &i1);
	240	d1 = ldexp (d2, i2);
	241	d1 = log (d2);
	242	d1 = log10 (d2);
	243	d1 = modf (d2, &d3);
	244	d1 = pow (d2, d3);
	245	d1 = sqrt (d2);
	246	d1 = ceil (d2);
	247	d1 = fabs (d2);
	248	d1 = floor (d2);
	249	d1 = fmod (d2, d3);
	250
	251	return 0;
	252	}