[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.base / dfp-test.c

/* This testcase is part of GDB, the GNU debugger.

   Copyright 2007-2019 Free Software Foundation, Inc.

   This program 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 of the License, or
   (at your option) any later version.

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include <stdio.h>
#include <stdlib.h>

#define DELTA (0.0001df)
#define DELTA_B (0.001)

double double_val1 = 45.125;
double double_val2 = -67.75;
double double_val3 = 0.25;
double double_val4 = 1.25;
double double_val5 = 2.25;
double double_val6 = 3.25;
double double_val7 = 4.25;
double double_val8 = 5.25;
double double_val9 = 6.25;
double double_val10 = 7.25;
double double_val11 = 8.25;
double double_val12 = 9.25;
double double_val13 = 10.25;
double double_val14 = 11.25;

_Decimal32 dec32_val1 = 3.14159df;
_Decimal32 dec32_val2 = -2.3765df;
_Decimal32 dec32_val3 = 0.2df;
_Decimal32 dec32_val4 = 1.2df;
_Decimal32 dec32_val5 = 2.2df;
_Decimal32 dec32_val6 = 3.2df;
_Decimal32 dec32_val7 = 4.2df;
_Decimal32 dec32_val8 = 5.2df;
_Decimal32 dec32_val9 = 6.2df;
_Decimal32 dec32_val10 = 7.2df;
_Decimal32 dec32_val11 = 8.2df;
_Decimal32 dec32_val12 = 9.2df;
_Decimal32 dec32_val13 = 10.2df;
_Decimal32 dec32_val14 = 11.2df;
_Decimal32 dec32_val15 = 12.2df;
_Decimal32 dec32_val16 = 13.2df;

_Decimal64 dec64_val1 = 3.14159dd;
_Decimal64 dec64_val2 = -2.3765dd;
_Decimal64 dec64_val3 = 0.2dd;
_Decimal64 dec64_val4 = 1.2dd;
_Decimal64 dec64_val5 = 2.2dd;
_Decimal64 dec64_val6 = 3.2dd;
_Decimal64 dec64_val7 = 4.2dd;
_Decimal64 dec64_val8 = 5.2dd;
_Decimal64 dec64_val9 = 6.2dd;
_Decimal64 dec64_val10 = 7.2dd;
_Decimal64 dec64_val11 = 8.2dd;
_Decimal64 dec64_val12 = 9.2dd;
_Decimal64 dec64_val13 = 10.2dd;
_Decimal64 dec64_val14 = 11.2dd;
_Decimal64 dec64_val15 = 12.2dd;
_Decimal64 dec64_val16 = 13.2dd;

_Decimal128 dec128_val1 = 3.14159dl;
_Decimal128 dec128_val2 = -2.3765dl;
_Decimal128 dec128_val3 = 0.2dl;
_Decimal128 dec128_val4 = 1.2dl;
_Decimal128 dec128_val5 = 2.2dl;
_Decimal128 dec128_val6 = 3.2dl;
_Decimal128 dec128_val7 = 4.2dl;
_Decimal128 dec128_val8 = 5.2dl;
_Decimal128 dec128_val9 = 6.2dl;
_Decimal128 dec128_val10 = 7.2dl;
_Decimal128 dec128_val11 = 8.2dl;
_Decimal128 dec128_val12 = 9.2dl;
_Decimal128 dec128_val13 = 10.2dl;
_Decimal128 dec128_val14 = 11.2dl;
_Decimal128 dec128_val15 = 12.2dl;
_Decimal128 dec128_val16 = 13.2dl;

volatile _Decimal32 d32;
volatile _Decimal64 d64;
volatile _Decimal128 d128;

/* Typedefs and typedefs of typedefs, for ptype/whatis testing.  */
typedef _Decimal32 d32_t;
typedef _Decimal64 d64_t;
typedef _Decimal128 d128_t;

typedef d32_t d32_t2;
typedef d64_t d64_t2;
typedef d128_t d128_t2;

d32_t v_d32_t;
d64_t v_d64_t;
d128_t v_d128_t;

d32_t2 v_d32_t2;
d64_t2 v_d64_t2;
d128_t2 v_d128_t2;

struct decstruct
{
  int int4;
  long long8;
  float float4;
  double double8;
  _Decimal32 dec32;
  _Decimal64 dec64;
  _Decimal128 dec128;
} ds;

static _Decimal32
arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
         _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
{
  return arg0;
}

static _Decimal64
arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
         _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
{
  return arg0;
}

static _Decimal128
arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
         _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
{
  return arg0;
}

/* Function to test if _Decimal128 argument interferes with stack slots
   because of alignment.  */
int
decimal_dec128_align (double arg0, _Decimal128 arg1, double arg2, double arg3,
		      double arg4, double arg5, double arg6, double arg7,
		      double arg8, double arg9, double arg10, double arg11,
		      double arg12, double arg13)
{
  return ((arg0 - double_val1) < DELTA_B
	  && (arg0 - double_val1) > -DELTA_B
	  && (arg1 - dec128_val2) < DELTA
	  && (arg1 - dec128_val2) > -DELTA
	  && (arg2 - double_val3) < DELTA_B
	  && (arg2 - double_val3) > -DELTA_B
	  && (arg3 - double_val4) < DELTA_B
	  && (arg3 - double_val4) > -DELTA_B
	  && (arg4 - double_val5) < DELTA_B
	  && (arg4 - double_val5) > -DELTA_B
	  && (arg5 - double_val6) < DELTA_B
	  && (arg5 - double_val6) > -DELTA_B
	  && (arg6 - double_val7) < DELTA_B
	  && (arg6 - double_val7) > -DELTA_B
	  && (arg7 - double_val8) < DELTA_B
	  && (arg7 - double_val8) > -DELTA_B
	  && (arg8 - double_val9) < DELTA_B
	  && (arg8 - double_val9) > -DELTA_B
	  && (arg9 - double_val10) < DELTA_B
	  && (arg9 - double_val10) > -DELTA_B
	  && (arg10 - double_val11) < DELTA_B
	  && (arg10 - double_val11) > -DELTA_B
	  && (arg11 - double_val12) < DELTA_B
	  && (arg11 - double_val12) > -DELTA_B
	  && (arg12 - double_val13) < DELTA_B
	  && (arg12 - double_val13) > -DELTA_B
	  && (arg13 - double_val14) < DELTA_B
	  && (arg13 - double_val14) > -DELTA_B);
}

int
decimal_mixed (_Decimal32 arg0, _Decimal64 arg1, _Decimal128 arg2)
{
  return ((arg0 - dec32_val1) < DELTA
	  && (arg0 - dec32_val1) > -DELTA
	  && (arg1 - dec64_val1) < DELTA
	  && (arg1 - dec64_val1) > -DELTA
	  && (arg2 - dec128_val1) < DELTA
	  && (arg2 - dec128_val1) > -DELTA);
}

/* These functions have many arguments to force some of them to be passed via
   the stack instead of registers, to test that GDB can construct correctly
   the parameter save area. Note that Linux/ppc32 has 8 float registers to use
   for float parameter passing and Linux/ppc64 has 13, so the number of
   arguments has to be at least 14 to contemplate these platforms.  */

int
decimal_many_args_dec32 (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
			    _Decimal32 f4, _Decimal32 f5, _Decimal32 f6,
			    _Decimal32 f7, _Decimal32 f8, _Decimal32 f9,
			    _Decimal32 f10, _Decimal32 f11, _Decimal32 f12,
			    _Decimal32 f13, _Decimal32 f14, _Decimal32 f15,
			    _Decimal32 f16)
{
  _Decimal32 sum_args;
  _Decimal32 sum_values;

  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
	     + f13 + f14 + f15 + f16;
  sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec32_val4 + dec32_val5
	       + dec32_val6 + dec32_val7 + dec32_val8 + dec32_val9
	       + dec32_val10 + dec32_val11 + dec32_val12 + dec32_val13
	       + dec32_val14 + dec32_val15 + dec32_val16;

  return ((sum_args - sum_values) < DELTA
	  && (sum_args - sum_values) > -DELTA);
}

int
decimal_many_args_dec64 (_Decimal64 f1, _Decimal64 f2, _Decimal64 f3,
			    _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
			    _Decimal64 f7, _Decimal64 f8, _Decimal64 f9,
			    _Decimal64 f10, _Decimal64 f11, _Decimal64 f12,
			    _Decimal64 f13, _Decimal64 f14, _Decimal64 f15,
			    _Decimal64 f16)
{
  _Decimal64 sum_args;
  _Decimal64 sum_values;

  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
	     + f13 + f14 + f15 + f16;
  sum_values = dec64_val1 + dec64_val2 + dec64_val3 + dec64_val4 + dec64_val5
	       + dec64_val6 + dec64_val7 + dec64_val8 + dec64_val9
	       + dec64_val10 + dec64_val11 + dec64_val12 + dec64_val13
	       + dec64_val14 + dec64_val15 + dec64_val16;

  return ((sum_args - sum_values) < DELTA
	  && (sum_args - sum_values) > -DELTA);
}

int
decimal_many_args_dec128 (_Decimal128 f1, _Decimal128 f2, _Decimal128 f3,
			    _Decimal128 f4, _Decimal128 f5, _Decimal128 f6,
			    _Decimal128 f7, _Decimal128 f8, _Decimal128 f9,
			    _Decimal128 f10, _Decimal128 f11, _Decimal128 f12,
			    _Decimal128 f13, _Decimal128 f14, _Decimal128 f15,
			    _Decimal128 f16)
{
  _Decimal128 sum_args;
  _Decimal128 sum_values;

  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
	     + f13 + f14 + f15 + f16;
  sum_values = dec128_val1 + dec128_val2 + dec128_val3 + dec128_val4 + dec128_val5
	       + dec128_val6 + dec128_val7 + dec128_val8 + dec128_val9
	       + dec128_val10 + dec128_val11 + dec128_val12 + dec128_val13
	       + dec128_val14 + dec128_val15 + dec128_val16;

  return ((sum_args - sum_values) < DELTA
	  && (sum_args - sum_values) > -DELTA);
}

int
decimal_many_args_mixed (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
			   _Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
			   _Decimal64 f7, _Decimal128 f8, _Decimal128 f9,
			   _Decimal128 f10, _Decimal32 f11, _Decimal64 f12,
			   _Decimal32 f13, _Decimal64 f14, _Decimal128 f15)
{
  _Decimal128 sum_args;
  _Decimal128 sum_values;

  sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
	     + f13 + f14 + f15;
  sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec64_val4 + dec64_val5
	       + dec64_val6 + dec64_val7 + dec128_val8 + dec128_val9
	       + dec128_val10 + dec32_val11 + dec64_val12 + dec32_val13
	       + dec64_val14 + dec128_val15;

  return ((sum_args - sum_values) < DELTA
	  && (sum_args - sum_values) > -DELTA);
}

int main()
{
  /* An finite 32-bits decimal floating point.  */
  d32 = 1.2345df;		/* Initialize d32.  */

  /* Non-finite 32-bits decimal floating point: infinity and NaN.  */
  d32 = __builtin_infd32();	/* Positive infd32.  */
  d32 = -__builtin_infd32();	/* Negative infd32.  */
  d32 = __builtin_nand32("");

  /* An finite 64-bits decimal floating point.  */
  d64 = 1.2345dd;		/* Initialize d64.  */

  /* Non-finite 64-bits decimal floating point: infinity and NaN.  */
  d64 = __builtin_infd64();	/* Positive infd64.  */
  d64 = -__builtin_infd64();	/* Negative infd64.  */
  d64 = __builtin_nand64("");

  /* An finite 128-bits decimal floating point.  */
  d128 = 1.2345dl;		/* Initialize d128.  */

  /* Non-finite 128-bits decimal floating point: infinity and NaN.  */
  d128 = __builtin_infd128();	/* Positive infd128.  */
  d128 = -__builtin_infd128();	/* Negative infd128.  */
  d128 = __builtin_nand128("");

  /* Functions with decimal floating point as parameter and return value. */
  d32 = arg0_32 (0.1df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df);
  d64 = arg0_64 (0.1dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd);
  d128 = arg0_128 (0.1dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl);

  ds.int4 = 1;
  ds.long8 = 2;
  ds.float4 = 3.1;
  ds.double8 = 4.2;
  ds.dec32 = 1.2345df;
  ds.dec64 = 1.2345dd;
  ds.dec128 = 1.2345dl;

  return 0;	/* Exit point.  */
}
Commit	Line	Data
93004d61 TJB	1	/* This testcase is part of GDB, the GNU debugger.
93004d61 TJB	2
42a4f53d	3	Copyright 2007-2019 Free Software Foundation, Inc.
93004d61 TJB	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20
7d35ab09 TJB	21	#define DELTA (0.0001df)
	22	#define DELTA_B (0.001)
	23
	24	double double_val1 = 45.125;
	25	double double_val2 = -67.75;
	26	double double_val3 = 0.25;
	27	double double_val4 = 1.25;
	28	double double_val5 = 2.25;
	29	double double_val6 = 3.25;
	30	double double_val7 = 4.25;
	31	double double_val8 = 5.25;
	32	double double_val9 = 6.25;
	33	double double_val10 = 7.25;
	34	double double_val11 = 8.25;
	35	double double_val12 = 9.25;
	36	double double_val13 = 10.25;
	37	double double_val14 = 11.25;
	38
	39	_Decimal32 dec32_val1 = 3.14159df;
	40	_Decimal32 dec32_val2 = -2.3765df;
	41	_Decimal32 dec32_val3 = 0.2df;
	42	_Decimal32 dec32_val4 = 1.2df;
	43	_Decimal32 dec32_val5 = 2.2df;
	44	_Decimal32 dec32_val6 = 3.2df;
	45	_Decimal32 dec32_val7 = 4.2df;
	46	_Decimal32 dec32_val8 = 5.2df;
	47	_Decimal32 dec32_val9 = 6.2df;
	48	_Decimal32 dec32_val10 = 7.2df;
	49	_Decimal32 dec32_val11 = 8.2df;
	50	_Decimal32 dec32_val12 = 9.2df;
	51	_Decimal32 dec32_val13 = 10.2df;
	52	_Decimal32 dec32_val14 = 11.2df;
	53	_Decimal32 dec32_val15 = 12.2df;
	54	_Decimal32 dec32_val16 = 13.2df;
	55
	56	_Decimal64 dec64_val1 = 3.14159dd;
	57	_Decimal64 dec64_val2 = -2.3765dd;
	58	_Decimal64 dec64_val3 = 0.2dd;
	59	_Decimal64 dec64_val4 = 1.2dd;
	60	_Decimal64 dec64_val5 = 2.2dd;
	61	_Decimal64 dec64_val6 = 3.2dd;
	62	_Decimal64 dec64_val7 = 4.2dd;
	63	_Decimal64 dec64_val8 = 5.2dd;
	64	_Decimal64 dec64_val9 = 6.2dd;
	65	_Decimal64 dec64_val10 = 7.2dd;
	66	_Decimal64 dec64_val11 = 8.2dd;
	67	_Decimal64 dec64_val12 = 9.2dd;
	68	_Decimal64 dec64_val13 = 10.2dd;
	69	_Decimal64 dec64_val14 = 11.2dd;
	70	_Decimal64 dec64_val15 = 12.2dd;
	71	_Decimal64 dec64_val16 = 13.2dd;
	72
	73	_Decimal128 dec128_val1 = 3.14159dl;
	74	_Decimal128 dec128_val2 = -2.3765dl;
	75	_Decimal128 dec128_val3 = 0.2dl;
	76	_Decimal128 dec128_val4 = 1.2dl;
	77	_Decimal128 dec128_val5 = 2.2dl;
	78	_Decimal128 dec128_val6 = 3.2dl;
	79	_Decimal128 dec128_val7 = 4.2dl;
	80	_Decimal128 dec128_val8 = 5.2dl;
	81	_Decimal128 dec128_val9 = 6.2dl;
	82	_Decimal128 dec128_val10 = 7.2dl;
	83	_Decimal128 dec128_val11 = 8.2dl;
	84	_Decimal128 dec128_val12 = 9.2dl;
85	_Decimal128 dec128_val13 = 10.2dl;
86	_Decimal128 dec128_val14 = 11.2dl;
87	_Decimal128 dec128_val15 = 12.2dl;
88	_Decimal128 dec128_val16 = 13.2dl;
89
93004d61 TJB	90	volatile _Decimal32 d32;
	91	volatile _Decimal64 d64;
	92	volatile _Decimal128 d128;
	93
c973d0aa PA	94	/* Typedefs and typedefs of typedefs, for ptype/whatis testing. */
	95	typedef _Decimal32 d32_t;
	96	typedef _Decimal64 d64_t;
	97	typedef _Decimal128 d128_t;
	98
	99	typedef d32_t d32_t2;
	100	typedef d64_t d64_t2;
	101	typedef d128_t d128_t2;
	102
	103	d32_t v_d32_t;
	104	d64_t v_d64_t;
	105	d128_t v_d128_t;
	106
	107	d32_t2 v_d32_t2;
	108	d64_t2 v_d64_t2;
	109	d128_t2 v_d128_t2;
	110
93004d61 TJB	111	struct decstruct
	112	{
	113	int int4;
	114	long long8;
f6867ce0 TJB	115	float float4;
f6867ce0 TJB	116	double double8;
93004d61 TJB	117	_Decimal32 dec32;
	118	_Decimal64 dec64;
	119	_Decimal128 dec128;
	120	} ds;
	121
	122	static _Decimal32
	123	arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
	124	_Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
	125	{
	126	return arg0;
	127	}
	128
	129	static _Decimal64
	130	arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
	131	_Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
	132	{
	133	return arg0;
	134	}
	135
	136	static _Decimal128
	137	arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
	138	_Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
	139	{
	140	return arg0;
	141	}
	142
7d35ab09 TJB	143	/* Function to test if _Decimal128 argument interferes with stack slots
	144	because of alignment. */
	145	int
	146	decimal_dec128_align (double arg0, _Decimal128 arg1, double arg2, double arg3,
	147	double arg4, double arg5, double arg6, double arg7,
	148	double arg8, double arg9, double arg10, double arg11,
	149	double arg12, double arg13)
	150	{
	151	return ((arg0 - double_val1) < DELTA_B
	152	&& (arg0 - double_val1) > -DELTA_B
	153	&& (arg1 - dec128_val2) < DELTA
	154	&& (arg1 - dec128_val2) > -DELTA
	155	&& (arg2 - double_val3) < DELTA_B
	156	&& (arg2 - double_val3) > -DELTA_B
	157	&& (arg3 - double_val4) < DELTA_B
	158	&& (arg3 - double_val4) > -DELTA_B
	159	&& (arg4 - double_val5) < DELTA_B
	160	&& (arg4 - double_val5) > -DELTA_B
	161	&& (arg5 - double_val6) < DELTA_B
	162	&& (arg5 - double_val6) > -DELTA_B
	163	&& (arg6 - double_val7) < DELTA_B
	164	&& (arg6 - double_val7) > -DELTA_B
	165	&& (arg7 - double_val8) < DELTA_B
	166	&& (arg7 - double_val8) > -DELTA_B
	167	&& (arg8 - double_val9) < DELTA_B
	168	&& (arg8 - double_val9) > -DELTA_B
	169	&& (arg9 - double_val10) < DELTA_B
	170	&& (arg9 - double_val10) > -DELTA_B
	171	&& (arg10 - double_val11) < DELTA_B
	172	&& (arg10 - double_val11) > -DELTA_B
	173	&& (arg11 - double_val12) < DELTA_B
	174	&& (arg11 - double_val12) > -DELTA_B
	175	&& (arg12 - double_val13) < DELTA_B
	176	&& (arg12 - double_val13) > -DELTA_B
	177	&& (arg13 - double_val14) < DELTA_B
	178	&& (arg13 - double_val14) > -DELTA_B);
	179	}
	180
	181	int
	182	decimal_mixed (_Decimal32 arg0, _Decimal64 arg1, _Decimal128 arg2)
	183	{
	184	return ((arg0 - dec32_val1) < DELTA
	185	&& (arg0 - dec32_val1) > -DELTA
	186	&& (arg1 - dec64_val1) < DELTA
	187	&& (arg1 - dec64_val1) > -DELTA
	188	&& (arg2 - dec128_val1) < DELTA
	189	&& (arg2 - dec128_val1) > -DELTA);
	190	}
	191
	192	/* These functions have many arguments to force some of them to be passed via
	193	the stack instead of registers, to test that GDB can construct correctly
	194	the parameter save area. Note that Linux/ppc32 has 8 float registers to use
	195	for float parameter passing and Linux/ppc64 has 13, so the number of
	196	arguments has to be at least 14 to contemplate these platforms. */
	197
	198	int
	199	decimal_many_args_dec32 (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
	200	_Decimal32 f4, _Decimal32 f5, _Decimal32 f6,
	201	_Decimal32 f7, _Decimal32 f8, _Decimal32 f9,
	202	_Decimal32 f10, _Decimal32 f11, _Decimal32 f12,
	203	_Decimal32 f13, _Decimal32 f14, _Decimal32 f15,
	204	_Decimal32 f16)
	205	{
	206	_Decimal32 sum_args;
207	_Decimal32 sum_values;
208
209	sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
210	+ f13 + f14 + f15 + f16;
211	sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec32_val4 + dec32_val5
212	+ dec32_val6 + dec32_val7 + dec32_val8 + dec32_val9
213	+ dec32_val10 + dec32_val11 + dec32_val12 + dec32_val13
214	+ dec32_val14 + dec32_val15 + dec32_val16;
215
216	return ((sum_args - sum_values) < DELTA
217	&& (sum_args - sum_values) > -DELTA);
218	}
219
220	int
221	decimal_many_args_dec64 (_Decimal64 f1, _Decimal64 f2, _Decimal64 f3,
222	_Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
223	_Decimal64 f7, _Decimal64 f8, _Decimal64 f9,
224	_Decimal64 f10, _Decimal64 f11, _Decimal64 f12,
225	_Decimal64 f13, _Decimal64 f14, _Decimal64 f15,
226	_Decimal64 f16)
227	{
228	_Decimal64 sum_args;
229	_Decimal64 sum_values;
230
231	sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
232	+ f13 + f14 + f15 + f16;
233	sum_values = dec64_val1 + dec64_val2 + dec64_val3 + dec64_val4 + dec64_val5
234	+ dec64_val6 + dec64_val7 + dec64_val8 + dec64_val9
235	+ dec64_val10 + dec64_val11 + dec64_val12 + dec64_val13
236	+ dec64_val14 + dec64_val15 + dec64_val16;
237
238	return ((sum_args - sum_values) < DELTA
239	&& (sum_args - sum_values) > -DELTA);
240	}
241
242	int
243	decimal_many_args_dec128 (_Decimal128 f1, _Decimal128 f2, _Decimal128 f3,
244	_Decimal128 f4, _Decimal128 f5, _Decimal128 f6,
245	_Decimal128 f7, _Decimal128 f8, _Decimal128 f9,
246	_Decimal128 f10, _Decimal128 f11, _Decimal128 f12,
247	_Decimal128 f13, _Decimal128 f14, _Decimal128 f15,
248	_Decimal128 f16)
249	{
250	_Decimal128 sum_args;
251	_Decimal128 sum_values;
252
253	sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
254	+ f13 + f14 + f15 + f16;
255	sum_values = dec128_val1 + dec128_val2 + dec128_val3 + dec128_val4 + dec128_val5
256	+ dec128_val6 + dec128_val7 + dec128_val8 + dec128_val9
257	+ dec128_val10 + dec128_val11 + dec128_val12 + dec128_val13
258	+ dec128_val14 + dec128_val15 + dec128_val16;
259
260	return ((sum_args - sum_values) < DELTA
261	&& (sum_args - sum_values) > -DELTA);
262	}
263
264	int
265	decimal_many_args_mixed (_Decimal32 f1, _Decimal32 f2, _Decimal32 f3,
266	_Decimal64 f4, _Decimal64 f5, _Decimal64 f6,
267	_Decimal64 f7, _Decimal128 f8, _Decimal128 f9,
268	_Decimal128 f10, _Decimal32 f11, _Decimal64 f12,
269	_Decimal32 f13, _Decimal64 f14, _Decimal128 f15)
270	{
271	_Decimal128 sum_args;
272	_Decimal128 sum_values;
273
274	sum_args = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12
275	+ f13 + f14 + f15;
276	sum_values = dec32_val1 + dec32_val2 + dec32_val3 + dec64_val4 + dec64_val5
277	+ dec64_val6 + dec64_val7 + dec128_val8 + dec128_val9
278	+ dec128_val10 + dec32_val11 + dec64_val12 + dec32_val13
279	+ dec64_val14 + dec128_val15;
280
281	return ((sum_args - sum_values) < DELTA
282	&& (sum_args - sum_values) > -DELTA);
283	}
284
93004d61 TJB	285	int main()
	286	{
	287	/* An finite 32-bits decimal floating point. */
	288	d32 = 1.2345df; /* Initialize d32. */
	289
	290	/* Non-finite 32-bits decimal floating point: infinity and NaN. */
	291	d32 = __builtin_infd32(); /* Positive infd32. */
	292	d32 = -__builtin_infd32(); /* Negative infd32. */
	293	d32 = __builtin_nand32("");
	294
	295	/* An finite 64-bits decimal floating point. */
	296	d64 = 1.2345dd; /* Initialize d64. */
	297
	298	/* Non-finite 64-bits decimal floating point: infinity and NaN. */
	299	d64 = __builtin_infd64(); /* Positive infd64. */
	300	d64 = -__builtin_infd64(); /* Negative infd64. */
	301	d64 = __builtin_nand64("");
	302
	303	/* An finite 128-bits decimal floating point. */
	304	d128 = 1.2345dl; /* Initialize d128. */
	305
	306	/* Non-finite 128-bits decimal floating point: infinity and NaN. */
	307	d128 = __builtin_infd128(); /* Positive infd128. */
	308	d128 = -__builtin_infd128(); /* Negative infd128. */
	309	d128 = __builtin_nand128("");
	310
	311	/* Functions with decimal floating point as parameter and return value. */
	312	d32 = arg0_32 (0.1df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df);
	313	d64 = arg0_64 (0.1dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd);
	314	d128 = arg0_128 (0.1dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl);
	315
	316	ds.int4 = 1;
	317	ds.long8 = 2;
f6867ce0 TJB	318	ds.float4 = 3.1;
f6867ce0 TJB	319	ds.double8 = 4.2;
93004d61 TJB	320	ds.dec32 = 1.2345df;
	321	ds.dec64 = 1.2345dd;
	322	ds.dec128 = 1.2345dl;
	323
	324	return 0; /* Exit point. */
	325	}