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

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

   This file is part of GCC.

   GCC 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 3, or (at your option)
   any later version.

   GCC 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 GCC; see the file COPYING3.  If not see
   <http://www.gnu.org/licenses/>.  */

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