URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.target/] [powerpc/] [vsx-mass-1.c] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log


/* { dg-do compile { target { powerpc*-*-* } } } */
/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
/* { dg-require-effective-target powerpc_vsx_ok } */
/* { dg-options "-O3 -ftree-vectorize -mcpu=power7 -ffast-math -mveclibabi=mass" } */
/* { dg-final { scan-assembler "bl atan2d2" } } */
/* { dg-final { scan-assembler "bl atan2f4" } } */
/* { dg-final { scan-assembler "bl hypotd2" } } */
/* { dg-final { scan-assembler "bl hypotf4" } } */
/* { dg-final { scan-assembler "bl powd2" } } */
/* { dg-final { scan-assembler "bl powf4" } } */
/* { dg-final { scan-assembler "bl acosd2" } } */
/* { dg-final { scan-assembler "bl acosf4" } } */
/* { dg-final { scan-assembler "bl acoshd2" } } */
/* { dg-final { scan-assembler "bl acoshf4" } } */
/* { dg-final { scan-assembler "bl asind2" } } */
/* { dg-final { scan-assembler "bl asinf4" } } */
/* { dg-final { scan-assembler "bl asinhd2" } } */
/* { dg-final { scan-assembler "bl asinhf4" } } */
/* { dg-final { scan-assembler "bl atand2" } } */
/* { dg-final { scan-assembler "bl atanf4" } } */
/* { dg-final { scan-assembler "bl atanhd2" } } */
/* { dg-final { scan-assembler "bl atanhf4" } } */
/* { dg-final { scan-assembler "bl cbrtd2" } } */
/* { dg-final { scan-assembler "bl cbrtf4" } } */
/* { dg-final { scan-assembler "bl cosd2" } } */
/* { dg-final { scan-assembler "bl cosf4" } } */
/* { dg-final { scan-assembler "bl coshd2" } } */
/* { dg-final { scan-assembler "bl coshf4" } } */
/* { dg-final { scan-assembler "bl erfd2" } } */
/* { dg-final { scan-assembler "bl erff4" } } */
/* { dg-final { scan-assembler "bl erfcd2" } } */
/* { dg-final { scan-assembler "bl erfcf4" } } */
/* { dg-final { scan-assembler "bl exp2d2" } } */
/* { dg-final { scan-assembler "bl exp2f4" } } */
/* { dg-final { scan-assembler "bl expd2" } } */
/* { dg-final { scan-assembler "bl expf4" } } */
/* { dg-final { scan-assembler "bl expm1d2" } } */
/* { dg-final { scan-assembler "bl expm1f4" } } */
/* { dg-final { scan-assembler "bl lgamma" } } */
/* { dg-final { scan-assembler "bl lgammaf" } } */
/* { dg-final { scan-assembler "bl log10d2" } } */
/* { dg-final { scan-assembler "bl log10f4" } } */
/* { dg-final { scan-assembler "bl log1pd2" } } */
/* { dg-final { scan-assembler "bl log1pf4" } } */
/* { dg-final { scan-assembler "bl log2d2" } } */
/* { dg-final { scan-assembler "bl log2f4" } } */
/* { dg-final { scan-assembler "bl logd2" } } */
/* { dg-final { scan-assembler "bl logf4" } } */
/* { dg-final { scan-assembler "bl sind2" } } */
/* { dg-final { scan-assembler "bl sinf4" } } */
/* { dg-final { scan-assembler "bl sinhd2" } } */
/* { dg-final { scan-assembler "bl sinhf4" } } */
/* { dg-final { scan-assembler "bl tand2" } } */
/* { dg-final { scan-assembler "bl tanf4" } } */
/* { dg-final { scan-assembler "bl tanhd2" } } */
/* { dg-final { scan-assembler "bl tanhf4" } } */
 
#ifndef SIZE
#define SIZE 1024
#endif
 
double d1[SIZE] __attribute__((__aligned__(32)));
double d2[SIZE] __attribute__((__aligned__(32)));
double d3[SIZE] __attribute__((__aligned__(32)));
 
float f1[SIZE] __attribute__((__aligned__(32)));
float f2[SIZE] __attribute__((__aligned__(32)));
float f3[SIZE] __attribute__((__aligned__(32)));
 
void
test_double_atan2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_atan2 (d2[i], d3[i]);
}
 
void
test_float_atan2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_atan2f (f2[i], f3[i]);
}
 
void
test_double_hypot (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_hypot (d2[i], d3[i]);
}
 
void
test_float_hypot (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_hypotf (f2[i], f3[i]);
}
 
void
test_double_pow (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_pow (d2[i], d3[i]);
}
 
void
test_float_pow (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_powf (f2[i], f3[i]);
}
 
void
test_double_acos (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_acos (d2[i]);
}
 
void
test_float_acos (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_acosf (f2[i]);
}
 
void
test_double_acosh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_acosh (d2[i]);
}
 
void
test_float_acosh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_acoshf (f2[i]);
}
 
void
test_double_asin (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_asin (d2[i]);
}
 
void
test_float_asin (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_asinf (f2[i]);
}
 
void
test_double_asinh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_asinh (d2[i]);
}
 
void
test_float_asinh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_asinhf (f2[i]);
}
 
void
test_double_atan (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_atan (d2[i]);
}
 
void
test_float_atan (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_atanf (f2[i]);
}
 
void
test_double_atanh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_atanh (d2[i]);
}
 
void
test_float_atanh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_atanhf (f2[i]);
}
 
void
test_double_cbrt (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_cbrt (d2[i]);
}
 
void
test_float_cbrt (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_cbrtf (f2[i]);
}
 
void
test_double_cos (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_cos (d2[i]);
}
 
void
test_float_cos (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_cosf (f2[i]);
}
 
void
test_double_cosh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_cosh (d2[i]);
}
 
void
test_float_cosh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_coshf (f2[i]);
}
 
void
test_double_erf (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_erf (d2[i]);
}
 
void
test_float_erf (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_erff (f2[i]);
}
 
void
test_double_erfc (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_erfc (d2[i]);
}
 
void
test_float_erfc (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_erfcf (f2[i]);
}
 
void
test_double_exp2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_exp2 (d2[i]);
}
 
void
test_float_exp2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_exp2f (f2[i]);
}
 
void
test_double_exp (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_exp (d2[i]);
}
 
void
test_float_exp (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_expf (f2[i]);
}
 
void
test_double_expm1 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_expm1 (d2[i]);
}
 
void
test_float_expm1 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_expm1f (f2[i]);
}
 
void
test_double_lgamma (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_lgamma (d2[i]);
}
 
void
test_float_lgamma (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_lgammaf (f2[i]);
}
 
void
test_double_log10 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_log10 (d2[i]);
}
 
void
test_float_log10 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_log10f (f2[i]);
}
 
void
test_double_log1p (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_log1p (d2[i]);
}
 
void
test_float_log1p (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_log1pf (f2[i]);
}
 
void
test_double_log2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_log2 (d2[i]);
}
 
void
test_float_log2 (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_log2f (f2[i]);
}
 
void
test_double_log (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_log (d2[i]);
}
 
void
test_float_log (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_logf (f2[i]);
}
 
void
test_double_sin (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_sin (d2[i]);
}
 
void
test_float_sin (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_sinf (f2[i]);
}
 
void
test_double_sinh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_sinh (d2[i]);
}
 
void
test_float_sinh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_sinhf (f2[i]);
}
 
void
test_double_sqrt (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_sqrt (d2[i]);
}
 
void
test_float_sqrt (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_sqrtf (f2[i]);
}
 
void
test_double_tan (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_tan (d2[i]);
}
 
void
test_float_tan (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_tanf (f2[i]);
}
 
void
test_double_tanh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    d1[i] = __builtin_tanh (d2[i]);
}
 
void
test_float_tanh (void)
{
  int i;
 
  for (i = 0; i < SIZE; i++)
    f1[i] = __builtin_tanhf (f2[i]);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.target/] [powerpc/] [vsx-mass-1.c] - Blame information for rev 801

Line No.	Rev	Author	Line
1	691	jeremybenn	`/* { dg-do compile { target { powerpc--* } } } */`
2			`/* { dg-skip-if "" { powerpc--darwin* } { "" } { "" } } /`
3			`/* { dg-require-effective-target powerpc_vsx_ok } */`
4			`/* { dg-options "-O3 -ftree-vectorize -mcpu=power7 -ffast-math -mveclibabi=mass" } */`
5			`/* { dg-final { scan-assembler "bl atan2d2" } } */`
6			`/* { dg-final { scan-assembler "bl atan2f4" } } */`
7			`/* { dg-final { scan-assembler "bl hypotd2" } } */`
8			`/* { dg-final { scan-assembler "bl hypotf4" } } */`
9			`/* { dg-final { scan-assembler "bl powd2" } } */`
10			`/* { dg-final { scan-assembler "bl powf4" } } */`
11			`/* { dg-final { scan-assembler "bl acosd2" } } */`
12			`/* { dg-final { scan-assembler "bl acosf4" } } */`
13			`/* { dg-final { scan-assembler "bl acoshd2" } } */`
14			`/* { dg-final { scan-assembler "bl acoshf4" } } */`
15			`/* { dg-final { scan-assembler "bl asind2" } } */`
16			`/* { dg-final { scan-assembler "bl asinf4" } } */`
17			`/* { dg-final { scan-assembler "bl asinhd2" } } */`
18			`/* { dg-final { scan-assembler "bl asinhf4" } } */`
19			`/* { dg-final { scan-assembler "bl atand2" } } */`
20			`/* { dg-final { scan-assembler "bl atanf4" } } */`
21			`/* { dg-final { scan-assembler "bl atanhd2" } } */`
22			`/* { dg-final { scan-assembler "bl atanhf4" } } */`
23			`/* { dg-final { scan-assembler "bl cbrtd2" } } */`
24			`/* { dg-final { scan-assembler "bl cbrtf4" } } */`
25			`/* { dg-final { scan-assembler "bl cosd2" } } */`
26			`/* { dg-final { scan-assembler "bl cosf4" } } */`
27			`/* { dg-final { scan-assembler "bl coshd2" } } */`
28			`/* { dg-final { scan-assembler "bl coshf4" } } */`
29			`/* { dg-final { scan-assembler "bl erfd2" } } */`
30			`/* { dg-final { scan-assembler "bl erff4" } } */`
31			`/* { dg-final { scan-assembler "bl erfcd2" } } */`
32			`/* { dg-final { scan-assembler "bl erfcf4" } } */`
33			`/* { dg-final { scan-assembler "bl exp2d2" } } */`
34			`/* { dg-final { scan-assembler "bl exp2f4" } } */`
35			`/* { dg-final { scan-assembler "bl expd2" } } */`
36			`/* { dg-final { scan-assembler "bl expf4" } } */`
37			`/* { dg-final { scan-assembler "bl expm1d2" } } */`
38			`/* { dg-final { scan-assembler "bl expm1f4" } } */`
39			`/* { dg-final { scan-assembler "bl lgamma" } } */`
40			`/* { dg-final { scan-assembler "bl lgammaf" } } */`
41			`/* { dg-final { scan-assembler "bl log10d2" } } */`
42			`/* { dg-final { scan-assembler "bl log10f4" } } */`
43			`/* { dg-final { scan-assembler "bl log1pd2" } } */`
44			`/* { dg-final { scan-assembler "bl log1pf4" } } */`
45			`/* { dg-final { scan-assembler "bl log2d2" } } */`
46			`/* { dg-final { scan-assembler "bl log2f4" } } */`
47			`/* { dg-final { scan-assembler "bl logd2" } } */`
48			`/* { dg-final { scan-assembler "bl logf4" } } */`
49			`/* { dg-final { scan-assembler "bl sind2" } } */`
50			`/* { dg-final { scan-assembler "bl sinf4" } } */`
51			`/* { dg-final { scan-assembler "bl sinhd2" } } */`
52			`/* { dg-final { scan-assembler "bl sinhf4" } } */`
53			`/* { dg-final { scan-assembler "bl tand2" } } */`
54			`/* { dg-final { scan-assembler "bl tanf4" } } */`
55			`/* { dg-final { scan-assembler "bl tanhd2" } } */`
56			`/* { dg-final { scan-assembler "bl tanhf4" } } */`
57
58			`#ifndef SIZE`
59			`#define SIZE 1024`
60			`#endif`
61
62			`double d1[SIZE] __attribute__((__aligned__(32)));`
63			`double d2[SIZE] __attribute__((__aligned__(32)));`
64			`double d3[SIZE] __attribute__((__aligned__(32)));`
65
66			`float f1[SIZE] __attribute__((__aligned__(32)));`
67			`float f2[SIZE] __attribute__((__aligned__(32)));`
68			`float f3[SIZE] __attribute__((__aligned__(32)));`
69
70			`void`
71			`test_double_atan2 (void)`
72			`{`
73			`int i;`
74
75			`for (i = 0; i < SIZE; i++)`
76			`d1[i] = __builtin_atan2 (d2[i], d3[i]);`
77			`}`
78
79			`void`
80			`test_float_atan2 (void)`
81			`{`
82			`int i;`
83
84			`for (i = 0; i < SIZE; i++)`
85			`f1[i] = __builtin_atan2f (f2[i], f3[i]);`
86			`}`
87
88			`void`
89			`test_double_hypot (void)`
90			`{`
91			`int i;`
92
93			`for (i = 0; i < SIZE; i++)`
94			`d1[i] = __builtin_hypot (d2[i], d3[i]);`
95			`}`
96
97			`void`
98			`test_float_hypot (void)`
99			`{`
100			`int i;`
101
102			`for (i = 0; i < SIZE; i++)`
103			`f1[i] = __builtin_hypotf (f2[i], f3[i]);`
104			`}`
105
106			`void`
107			`test_double_pow (void)`
108			`{`
109			`int i;`
110
111			`for (i = 0; i < SIZE; i++)`
112			`d1[i] = __builtin_pow (d2[i], d3[i]);`
113			`}`
114
115			`void`
116			`test_float_pow (void)`
117			`{`
118			`int i;`
119
120			`for (i = 0; i < SIZE; i++)`
121			`f1[i] = __builtin_powf (f2[i], f3[i]);`
122			`}`
123
124			`void`
125			`test_double_acos (void)`
126			`{`
127			`int i;`
128
129			`for (i = 0; i < SIZE; i++)`
130			`d1[i] = __builtin_acos (d2[i]);`
131			`}`
132
133			`void`
134			`test_float_acos (void)`
135			`{`
136			`int i;`
137
138			`for (i = 0; i < SIZE; i++)`
139			`f1[i] = __builtin_acosf (f2[i]);`
140			`}`
141
142			`void`
143			`test_double_acosh (void)`
144			`{`
145			`int i;`
146
147			`for (i = 0; i < SIZE; i++)`
148			`d1[i] = __builtin_acosh (d2[i]);`
149			`}`
150
151			`void`
152			`test_float_acosh (void)`
153			`{`
154			`int i;`
155
156			`for (i = 0; i < SIZE; i++)`
157			`f1[i] = __builtin_acoshf (f2[i]);`
158			`}`
159
160			`void`
161			`test_double_asin (void)`
162			`{`
163			`int i;`
164
165			`for (i = 0; i < SIZE; i++)`
166			`d1[i] = __builtin_asin (d2[i]);`
167			`}`
168
169			`void`
170			`test_float_asin (void)`
171			`{`
172			`int i;`
173
174			`for (i = 0; i < SIZE; i++)`
175			`f1[i] = __builtin_asinf (f2[i]);`
176			`}`
177
178			`void`
179			`test_double_asinh (void)`
180			`{`
181			`int i;`
182
183			`for (i = 0; i < SIZE; i++)`
184			`d1[i] = __builtin_asinh (d2[i]);`
185			`}`
186
187			`void`
188			`test_float_asinh (void)`
189			`{`
190			`int i;`
191
192			`for (i = 0; i < SIZE; i++)`
193			`f1[i] = __builtin_asinhf (f2[i]);`
194			`}`
195
196			`void`
197			`test_double_atan (void)`
198			`{`
199			`int i;`
200
201			`for (i = 0; i < SIZE; i++)`
202			`d1[i] = __builtin_atan (d2[i]);`
203			`}`
204
205			`void`
206			`test_float_atan (void)`
207			`{`
208			`int i;`
209
210			`for (i = 0; i < SIZE; i++)`
211			`f1[i] = __builtin_atanf (f2[i]);`
212			`}`
213
214			`void`
215			`test_double_atanh (void)`
216			`{`
217			`int i;`
218
219			`for (i = 0; i < SIZE; i++)`
220			`d1[i] = __builtin_atanh (d2[i]);`
221			`}`
222
223			`void`
224			`test_float_atanh (void)`
225			`{`
226			`int i;`
227
228			`for (i = 0; i < SIZE; i++)`
229			`f1[i] = __builtin_atanhf (f2[i]);`
230			`}`
231
232			`void`
233			`test_double_cbrt (void)`
234			`{`
235			`int i;`
236
237			`for (i = 0; i < SIZE; i++)`
238			`d1[i] = __builtin_cbrt (d2[i]);`
239			`}`
240
241			`void`
242			`test_float_cbrt (void)`
243			`{`
244			`int i;`
245
246			`for (i = 0; i < SIZE; i++)`
247			`f1[i] = __builtin_cbrtf (f2[i]);`
248			`}`
249
250			`void`
251			`test_double_cos (void)`
252			`{`
253			`int i;`
254
255			`for (i = 0; i < SIZE; i++)`
256			`d1[i] = __builtin_cos (d2[i]);`
257			`}`
258
259			`void`
260			`test_float_cos (void)`
261			`{`
262			`int i;`
263
264			`for (i = 0; i < SIZE; i++)`
265			`f1[i] = __builtin_cosf (f2[i]);`
266			`}`
267
268			`void`
269			`test_double_cosh (void)`
270			`{`
271			`int i;`
272
273			`for (i = 0; i < SIZE; i++)`
274			`d1[i] = __builtin_cosh (d2[i]);`
275			`}`
276
277			`void`
278			`test_float_cosh (void)`
279			`{`
280			`int i;`
281
282			`for (i = 0; i < SIZE; i++)`
283			`f1[i] = __builtin_coshf (f2[i]);`
284			`}`
285
286			`void`
287			`test_double_erf (void)`
288			`{`
289			`int i;`
290
291			`for (i = 0; i < SIZE; i++)`
292			`d1[i] = __builtin_erf (d2[i]);`
293			`}`
294
295			`void`
296			`test_float_erf (void)`
297			`{`
298			`int i;`
299
300			`for (i = 0; i < SIZE; i++)`
301			`f1[i] = __builtin_erff (f2[i]);`
302			`}`
303
304			`void`
305			`test_double_erfc (void)`
306			`{`
307			`int i;`
308
309			`for (i = 0; i < SIZE; i++)`
310			`d1[i] = __builtin_erfc (d2[i]);`
311			`}`
312
313			`void`
314			`test_float_erfc (void)`
315			`{`
316			`int i;`
317
318			`for (i = 0; i < SIZE; i++)`
319			`f1[i] = __builtin_erfcf (f2[i]);`
320			`}`
321
322			`void`
323			`test_double_exp2 (void)`
324			`{`
325			`int i;`
326
327			`for (i = 0; i < SIZE; i++)`
328			`d1[i] = __builtin_exp2 (d2[i]);`
329			`}`
330
331			`void`
332			`test_float_exp2 (void)`
333			`{`
334			`int i;`
335
336			`for (i = 0; i < SIZE; i++)`
337			`f1[i] = __builtin_exp2f (f2[i]);`
338			`}`
339
340			`void`
341			`test_double_exp (void)`
342			`{`
343			`int i;`
344
345			`for (i = 0; i < SIZE; i++)`
346			`d1[i] = __builtin_exp (d2[i]);`
347			`}`
348
349			`void`
350			`test_float_exp (void)`
351			`{`
352			`int i;`
353
354			`for (i = 0; i < SIZE; i++)`
355			`f1[i] = __builtin_expf (f2[i]);`
356			`}`
357
358			`void`
359			`test_double_expm1 (void)`
360			`{`
361			`int i;`
362
363			`for (i = 0; i < SIZE; i++)`
364			`d1[i] = __builtin_expm1 (d2[i]);`
365			`}`
366
367			`void`
368			`test_float_expm1 (void)`
369			`{`
370			`int i;`
371
372			`for (i = 0; i < SIZE; i++)`
373			`f1[i] = __builtin_expm1f (f2[i]);`
374			`}`
375
376			`void`
377			`test_double_lgamma (void)`
378			`{`
379			`int i;`
380
381			`for (i = 0; i < SIZE; i++)`
382			`d1[i] = __builtin_lgamma (d2[i]);`
383			`}`
384
385			`void`
386			`test_float_lgamma (void)`
387			`{`
388			`int i;`
389
390			`for (i = 0; i < SIZE; i++)`
391			`f1[i] = __builtin_lgammaf (f2[i]);`
392			`}`
393
394			`void`
395			`test_double_log10 (void)`
396			`{`
397			`int i;`
398
399			`for (i = 0; i < SIZE; i++)`
400			`d1[i] = __builtin_log10 (d2[i]);`
401			`}`
402
403			`void`
404			`test_float_log10 (void)`
405			`{`
406			`int i;`
407
408			`for (i = 0; i < SIZE; i++)`
409			`f1[i] = __builtin_log10f (f2[i]);`
410			`}`
411
412			`void`
413			`test_double_log1p (void)`
414			`{`
415			`int i;`
416
417			`for (i = 0; i < SIZE; i++)`
418			`d1[i] = __builtin_log1p (d2[i]);`
419			`}`
420
421			`void`
422			`test_float_log1p (void)`
423			`{`
424			`int i;`
425
426			`for (i = 0; i < SIZE; i++)`
427			`f1[i] = __builtin_log1pf (f2[i]);`
428			`}`
429
430			`void`
431			`test_double_log2 (void)`
432			`{`
433			`int i;`
434
435			`for (i = 0; i < SIZE; i++)`
436			`d1[i] = __builtin_log2 (d2[i]);`
437			`}`
438
439			`void`
440			`test_float_log2 (void)`
441			`{`
442			`int i;`
443
444			`for (i = 0; i < SIZE; i++)`
445			`f1[i] = __builtin_log2f (f2[i]);`
446			`}`
447
448			`void`
449			`test_double_log (void)`
450			`{`
451			`int i;`
452
453			`for (i = 0; i < SIZE; i++)`
454			`d1[i] = __builtin_log (d2[i]);`
455			`}`
456
457			`void`
458			`test_float_log (void)`
459			`{`
460			`int i;`
461
462			`for (i = 0; i < SIZE; i++)`
463			`f1[i] = __builtin_logf (f2[i]);`
464			`}`
465
466			`void`
467			`test_double_sin (void)`
468			`{`
469			`int i;`
470
471			`for (i = 0; i < SIZE; i++)`
472			`d1[i] = __builtin_sin (d2[i]);`
473			`}`
474
475			`void`
476			`test_float_sin (void)`
477			`{`
478			`int i;`
479
480			`for (i = 0; i < SIZE; i++)`
481			`f1[i] = __builtin_sinf (f2[i]);`
482			`}`
483
484			`void`
485			`test_double_sinh (void)`
486			`{`
487			`int i;`
488
489			`for (i = 0; i < SIZE; i++)`
490			`d1[i] = __builtin_sinh (d2[i]);`
491			`}`
492
493			`void`
494			`test_float_sinh (void)`
495			`{`
496			`int i;`
497
498			`for (i = 0; i < SIZE; i++)`
499			`f1[i] = __builtin_sinhf (f2[i]);`
500			`}`
501
502			`void`
503			`test_double_sqrt (void)`
504			`{`
505			`int i;`
506
507			`for (i = 0; i < SIZE; i++)`
508			`d1[i] = __builtin_sqrt (d2[i]);`
509			`}`
510
511			`void`
512			`test_float_sqrt (void)`
513			`{`
514			`int i;`
515
516			`for (i = 0; i < SIZE; i++)`
517			`f1[i] = __builtin_sqrtf (f2[i]);`
518			`}`
519
520			`void`
521			`test_double_tan (void)`
522			`{`
523			`int i;`
524
525			`for (i = 0; i < SIZE; i++)`
526			`d1[i] = __builtin_tan (d2[i]);`
527			`}`
528
529			`void`
530			`test_float_tan (void)`
531			`{`
532			`int i;`
533
534			`for (i = 0; i < SIZE; i++)`
535			`f1[i] = __builtin_tanf (f2[i]);`
536			`}`
537
538			`void`
539			`test_double_tanh (void)`
540			`{`
541			`int i;`
542
543			`for (i = 0; i < SIZE; i++)`
544			`d1[i] = __builtin_tanh (d2[i]);`
545			`}`
546
547			`void`
548			`test_float_tanh (void)`
549			`{`
550			`int i;`
551
552			`for (i = 0; i < SIZE; i++)`
553			`f1[i] = __builtin_tanhf (f2[i]);`
554			`}`