Skip to content

Commit f141d1a

Browse files
ecnelisesecnelises
committed
[NFC] Pre-commit test for long-double builtins
This test reflects clang behavior on long-double type math library builtins under default or explicit 128-bit long-double options.
1 parent 383778e commit f141d1a

File tree

1 file changed

+371
-0
lines changed

1 file changed

+371
-0
lines changed

‎clang/test/CodeGen/math-builtins-long.c

Lines changed: 371 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,371 @@
1+
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -w -S -o - -emit-llvm %s \
2+
// RUN: -fmath-errno | FileCheck %s -check-prefix=F80
3+
// RUN: %clang_cc1 -triple ppc64le-unknown-unknown -w -S -o - -emit-llvm %s \
4+
// RUN: -fmath-errno | FileCheck %s -check-prefix=PPC
5+
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -mlong-double-128 -w -S \
6+
// RUN: -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=X86F128
7+
// RUN: %clang_cc1 -triple ppc64le-unknown-unknown -mabi=ieeelongdouble -w -S \
8+
// RUN: -o - -emit-llvm %s -fmath-errno | FileCheck %s -check-prefix=PPCF128
9+
10+
void bar(long double);
11+
12+
void foo(long double f, long double *l, int *i, const char *c) {
13+
// F80: call x86_fp80 @fmodl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
14+
// PPC: call ppc_fp128 @fmodl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
15+
// X86F128: call fp128 @fmodl(fp128 %{{.+}}, fp128 %{{.+}})
16+
// PPCF128: call fp128 @fmodl(fp128 %{{.+}}, fp128 %{{.+}})
17+
__builtin_fmodl(f,f);
18+
19+
// F80: call x86_fp80 @atan2l(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
20+
// PPC: call ppc_fp128 @atan2l(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
21+
// X86F128: call fp128 @atan2l(fp128 %{{.+}}, fp128 %{{.+}})
22+
// PPCF128: call fp128 @atan2l(fp128 %{{.+}}, fp128 %{{.+}})
23+
__builtin_atan2l(f,f);
24+
25+
// F80: call x86_fp80 @llvm.copysign.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
26+
// PPC: call ppc_fp128 @llvm.copysign.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
27+
// X86F128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
28+
// PPCF128: call fp128 @llvm.copysign.f128(fp128 %{{.+}}, fp128 %{{.+}})
29+
__builtin_copysignl(f,f);
30+
31+
// F80: call x86_fp80 @llvm.fabs.f80(x86_fp80 %{{.+}})
32+
// PPC: call ppc_fp128 @llvm.fabs.ppcf128(ppc_fp128 %{{.+}})
33+
// X86F128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
34+
// PPCF128: call fp128 @llvm.fabs.f128(fp128 %{{.+}})
35+
__builtin_fabsl(f);
36+
37+
// F80: call x86_fp80 @frexpl(x86_fp80 %{{.+}}, i32* %{{.+}})
38+
// PPC: call ppc_fp128 @frexpl(ppc_fp128 %{{.+}}, i32* %{{.+}})
39+
// X86F128: call fp128 @frexpl(fp128 %{{.+}}, i32* %{{.+}})
40+
// PPCF128: call fp128 @frexpl(fp128 %{{.+}}, i32* %{{.+}})
41+
__builtin_frexpl(f,i);
42+
43+
// F80: store x86_fp80 0xK7FFF8000000000000000, x86_fp80*
44+
// PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ppc_fp128*
45+
// X86F128: store fp128 0xL00000000000000007FFF000000000000, fp128*
46+
// PPCF128: store fp128 0xL00000000000000007FFF000000000000, fp128*
47+
*l = __builtin_huge_vall();
48+
49+
// F80: store x86_fp80 0xK7FFF8000000000000000, x86_fp80*
50+
// PPC: store ppc_fp128 0xM7FF00000000000000000000000000000, ppc_fp128*
51+
// X86F128: store fp128 0xL00000000000000007FFF000000000000, fp128*
52+
// PPCF128: store fp128 0xL00000000000000007FFF000000000000, fp128*
53+
*l = __builtin_infl();
54+
55+
// F80: call x86_fp80 @ldexpl(x86_fp80 %{{.+}}, i32 %{{.+}})
56+
// PPC: call ppc_fp128 @ldexpl(ppc_fp128 %{{.+}}, {{(signext)?.+}})
57+
// X86F128: call fp128 @ldexpl(fp128 %{{.+}}, {{(signext)?.+}})
58+
// PPCF128: call fp128 @ldexpl(fp128 %{{.+}}, {{(signext)?.+}})
59+
__builtin_ldexpl(f,f);
60+
61+
// F80: call x86_fp80 @modfl(x86_fp80 %{{.+}}, x86_fp80* %{{.+}})
62+
// PPC: call ppc_fp128 @modfl(ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}})
63+
// X86F128: call fp128 @modfl(fp128 %{{.+}}, fp128* %{{.+}})
64+
// PPCF128: call fp128 @modfl(fp128 %{{.+}}, fp128* %{{.+}})
65+
__builtin_modfl(f,l);
66+
67+
// F80: call x86_fp80 @nanl(i8* %{{.+}})
68+
// PPC: call ppc_fp128 @nanl(i8* %{{.+}})
69+
// X86F128: call fp128 @nanl(i8* %{{.+}})
70+
// PPCF128: call fp128 @nanl(i8* %{{.+}})
71+
__builtin_nanl(c);
72+
73+
// F80: call x86_fp80 @nansl(i8* %{{.+}})
74+
// PPC: call ppc_fp128 @nansl(i8* %{{.+}})
75+
// X86F128: call fp128 @nansl(i8* %{{.+}})
76+
// PPCF128: call fp128 @nansl(i8* %{{.+}})
77+
__builtin_nansl(c);
78+
79+
// F80: call x86_fp80 @powl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
80+
// PPC: call ppc_fp128 @powl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
81+
// X86F128: call fp128 @powl(fp128 %{{.+}}, fp128 %{{.+}})
82+
// PPCF128: call fp128 @powl(fp128 %{{.+}}, fp128 %{{.+}})
83+
__builtin_powl(f,f);
84+
85+
// F80: call x86_fp80 @acosl(x86_fp80 %{{.+}})
86+
// PPC: call ppc_fp128 @acosl(ppc_fp128 %{{.+}})
87+
// X86F128: call fp128 @acosl(fp128 %{{.+}})
88+
// PPCF128: call fp128 @acosl(fp128 %{{.+}})
89+
__builtin_acosl(f);
90+
91+
// F80: call x86_fp80 @acoshl(x86_fp80 %{{.+}})
92+
// PPC: call ppc_fp128 @acoshl(ppc_fp128 %{{.+}})
93+
// X86F128: call fp128 @acoshl(fp128 %{{.+}})
94+
// PPCF128: call fp128 @acoshl(fp128 %{{.+}})
95+
__builtin_acoshl(f);
96+
97+
// F80: call x86_fp80 @asinl(x86_fp80 %{{.+}})
98+
// PPC: call ppc_fp128 @asinl(ppc_fp128 %{{.+}})
99+
// X86F128: call fp128 @asinl(fp128 %{{.+}})
100+
// PPCF128: call fp128 @asinl(fp128 %{{.+}})
101+
__builtin_asinl(f);
102+
103+
// F80: call x86_fp80 @asinhl(x86_fp80 %{{.+}})
104+
// PPC: call ppc_fp128 @asinhl(ppc_fp128 %{{.+}})
105+
// X86F128: call fp128 @asinhl(fp128 %{{.+}})
106+
// PPCF128: call fp128 @asinhl(fp128 %{{.+}})
107+
__builtin_asinhl(f);
108+
109+
// F80: call x86_fp80 @atanl(x86_fp80 %{{.+}})
110+
// PPC: call ppc_fp128 @atanl(ppc_fp128 %{{.+}})
111+
// X86F128: call fp128 @atanl(fp128 %{{.+}})
112+
// PPCF128: call fp128 @atanl(fp128 %{{.+}})
113+
__builtin_atanl(f);
114+
115+
// F80: call x86_fp80 @atanhl(x86_fp80 %{{.+}})
116+
// PPC: call ppc_fp128 @atanhl(ppc_fp128 %{{.+}})
117+
// X86F128: call fp128 @atanhl(fp128 %{{.+}})
118+
// PPCF128: call fp128 @atanhl(fp128 %{{.+}})
119+
__builtin_atanhl(f);
120+
121+
// F80: call x86_fp80 @cbrtl(x86_fp80 %{{.+}})
122+
// PPC: call ppc_fp128 @cbrtl(ppc_fp128 %{{.+}})
123+
// X86F128: call fp128 @cbrtl(fp128 %{{.+}})
124+
// PPCF128: call fp128 @cbrtl(fp128 %{{.+}})
125+
__builtin_cbrtl(f);
126+
127+
// F80: call x86_fp80 @llvm.ceil.f80(x86_fp80 %{{.+}})
128+
// PPC: call ppc_fp128 @llvm.ceil.ppcf128(ppc_fp128 %{{.+}})
129+
// X86F128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
130+
// PPCF128: call fp128 @llvm.ceil.f128(fp128 %{{.+}})
131+
__builtin_ceill(f);
132+
133+
// F80: call x86_fp80 @cosl(x86_fp80 %{{.+}})
134+
// PPC: call ppc_fp128 @cosl(ppc_fp128 %{{.+}})
135+
// X86F128: call fp128 @cosl(fp128 %{{.+}})
136+
// PPCF128: call fp128 @cosl(fp128 %{{.+}})
137+
__builtin_cosl(f);
138+
139+
// F80: call x86_fp80 @coshl(x86_fp80 %{{.+}})
140+
// PPC: call ppc_fp128 @coshl(ppc_fp128 %{{.+}})
141+
// X86F128: call fp128 @coshl(fp128 %{{.+}})
142+
// PPCF128: call fp128 @coshl(fp128 %{{.+}})
143+
__builtin_coshl(f);
144+
145+
// F80: call x86_fp80 @llvm.floor.f80(x86_fp80 %{{.+}})
146+
// PPC: call ppc_fp128 @llvm.floor.ppcf128(ppc_fp128 %{{.+}})
147+
// X86F128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
148+
// PPCF128: call fp128 @llvm.floor.f128(fp128 %{{.+}})
149+
__builtin_floorl(f);
150+
151+
// F80: call x86_fp80 @llvm.maxnum.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
152+
// PPC: call ppc_fp128 @llvm.maxnum.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
153+
// X86F128: call fp128 @llvm.maxnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
154+
// PPCF128: call fp128 @llvm.maxnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
155+
__builtin_fmaxl(f,f);
156+
157+
// F80: call x86_fp80 @llvm.minnum.f80(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
158+
// PPC: call ppc_fp128 @llvm.minnum.ppcf128(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
159+
// X86F128: call fp128 @llvm.minnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
160+
// PPCF128: call fp128 @llvm.minnum.f128(fp128 %{{.+}}, fp128 %{{.+}})
161+
__builtin_fminl(f,f);
162+
163+
// F80: call x86_fp80 @llvm.nearbyint.f80(x86_fp80 %{{.+}})
164+
// PPC: call ppc_fp128 @llvm.nearbyint.ppcf128(ppc_fp128 %{{.+}})
165+
// X86F128: call fp128 @llvm.nearbyint.f128(fp128 %{{.+}})
166+
// PPCF128: call fp128 @llvm.nearbyint.f128(fp128 %{{.+}})
167+
__builtin_nearbyintl(f);
168+
169+
// F80: call x86_fp80 @llvm.trunc.f80(x86_fp80 %{{.+}})
170+
// PPC: call ppc_fp128 @llvm.trunc.ppcf128(ppc_fp128 %{{.+}})
171+
// X86F128: call fp128 @llvm.trunc.f128(fp128 %{{.+}})
172+
// PPCF128: call fp128 @llvm.trunc.f128(fp128 %{{.+}})
173+
__builtin_truncl(f);
174+
175+
// F80: call x86_fp80 @llvm.rint.f80(x86_fp80 %{{.+}})
176+
// PPC: call ppc_fp128 @llvm.rint.ppcf128(ppc_fp128 %{{.+}})
177+
// X86F128: call fp128 @llvm.rint.f128(fp128 %{{.+}})
178+
// PPCF128: call fp128 @llvm.rint.f128(fp128 %{{.+}})
179+
__builtin_rintl(f);
180+
181+
// F80: call x86_fp80 @llvm.round.f80(x86_fp80 %{{.+}})
182+
// PPC: call ppc_fp128 @llvm.round.ppcf128(ppc_fp128 %{{.+}})
183+
// X86F128: call fp128 @llvm.round.f128(fp128 %{{.+}})
184+
// PPCF128: call fp128 @llvm.round.f128(fp128 %{{.+}})
185+
__builtin_roundl(f);
186+
// F80: call x86_fp80 @erfl(x86_fp80 %{{.+}})
187+
// PPC: call ppc_fp128 @erfl(ppc_fp128 %{{.+}})
188+
// X86F128: call fp128 @erfl(fp128 %{{.+}})
189+
// PPCF128: call fp128 @erfl(fp128 %{{.+}})
190+
__builtin_erfl(f);
191+
192+
// F80: call x86_fp80 @erfcl(x86_fp80 %{{.+}})
193+
// PPC: call ppc_fp128 @erfcl(ppc_fp128 %{{.+}})
194+
// X86F128: call fp128 @erfcl(fp128 %{{.+}})
195+
// PPCF128: call fp128 @erfcl(fp128 %{{.+}})
196+
__builtin_erfcl(f);
197+
198+
// F80: call x86_fp80 @expl(x86_fp80 %{{.+}})
199+
// PPC: call ppc_fp128 @expl(ppc_fp128 %{{.+}})
200+
// X86F128: call fp128 @expl(fp128 %{{.+}})
201+
// PPCF128: call fp128 @expl(fp128 %{{.+}})
202+
__builtin_expl(f);
203+
204+
// F80: call x86_fp80 @exp2l(x86_fp80 %{{.+}})
205+
// PPC: call ppc_fp128 @exp2l(ppc_fp128 %{{.+}})
206+
// X86F128: call fp128 @exp2l(fp128 %{{.+}})
207+
// PPCF128: call fp128 @exp2l(fp128 %{{.+}})
208+
__builtin_exp2l(f);
209+
210+
// F80: call x86_fp80 @expm1l(x86_fp80 %{{.+}})
211+
// PPC: call ppc_fp128 @expm1l(ppc_fp128 %{{.+}})
212+
// X86F128: call fp128 @expm1l(fp128 %{{.+}})
213+
// PPCF128: call fp128 @expm1l(fp128 %{{.+}})
214+
__builtin_expm1l(f);
215+
216+
// F80: call x86_fp80 @fdiml(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
217+
// PPC: call ppc_fp128 @fdiml(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
218+
// X86F128: call fp128 @fdiml(fp128 %{{.+}}, fp128 %{{.+}})
219+
// PPCF128: call fp128 @fdiml(fp128 %{{.+}}, fp128 %{{.+}})
220+
__builtin_fdiml(f,f);
221+
222+
// F80: call x86_fp80 @fmal(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
223+
// PPC: call ppc_fp128 @fmal(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
224+
// X86F128: call fp128 @fmal(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
225+
// PPCF128: call fp128 @fmal(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
226+
__builtin_fmal(f,f,f);
227+
228+
// F80: call x86_fp80 @hypotl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
229+
// PPC: call ppc_fp128 @hypotl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
230+
// X86F128: call fp128 @hypotl(fp128 %{{.+}}, fp128 %{{.+}})
231+
// PPCF128: call fp128 @hypotl(fp128 %{{.+}}, fp128 %{{.+}})
232+
__builtin_hypotl(f,f);
233+
234+
// F80: call i32 @ilogbl(x86_fp80 %{{.+}})
235+
// PPC: call {{(i32)|(signext i32)}} @ilogbl(ppc_fp128 %{{.+}})
236+
// X86F128: call {{(i32)|(signext i32)}} @ilogbl(fp128 %{{.+}})
237+
// PPCF128: call {{(i32)|(signext i32)}} @ilogbl(fp128 %{{.+}})
238+
__builtin_ilogbl(f);
239+
240+
// F80: call x86_fp80 @lgammal(x86_fp80 %{{.+}})
241+
// PPC: call ppc_fp128 @lgammal(ppc_fp128 %{{.+}})
242+
// X86F128: call fp128 @lgammal(fp128 %{{.+}})
243+
// PPCF128: call fp128 @lgammal(fp128 %{{.+}})
244+
__builtin_lgammal(f);
245+
246+
// F80: call i64 @llrintl(x86_fp80 %{{.+}})
247+
// PPC: call i64 @llrintl(ppc_fp128 %{{.+}})
248+
// X86F128: call i64 @llrintl(fp128 %{{.+}})
249+
// PPCF128: call i64 @llrintl(fp128 %{{.+}})
250+
__builtin_llrintl(f);
251+
252+
// F80: call i64 @llroundl(x86_fp80 %{{.+}})
253+
// PPC: call i64 @llroundl(ppc_fp128 %{{.+}})
254+
// X86F128: call i64 @llroundl(fp128 %{{.+}})
255+
// PPCF128: call i64 @llroundl(fp128 %{{.+}})
256+
__builtin_llroundl(f);
257+
258+
// F80: call x86_fp80 @logl(x86_fp80 %{{.+}})
259+
// PPC: call ppc_fp128 @logl(ppc_fp128 %{{.+}})
260+
// X86F128: call fp128 @logl(fp128 %{{.+}})
261+
// PPCF128: call fp128 @logl(fp128 %{{.+}})
262+
__builtin_logl(f);
263+
264+
// F80: call x86_fp80 @log10l(x86_fp80 %{{.+}})
265+
// PPC: call ppc_fp128 @log10l(ppc_fp128 %{{.+}})
266+
// X86F128: call fp128 @log10l(fp128 %{{.+}})
267+
// PPCF128: call fp128 @log10l(fp128 %{{.+}})
268+
__builtin_log10l(f);
269+
270+
// F80: call x86_fp80 @log1pl(x86_fp80 %{{.+}})
271+
// PPC: call ppc_fp128 @log1pl(ppc_fp128 %{{.+}})
272+
// X86F128: call fp128 @log1pl(fp128 %{{.+}})
273+
// PPCF128: call fp128 @log1pl(fp128 %{{.+}})
274+
__builtin_log1pl(f);
275+
276+
// F80: call x86_fp80 @log2l(x86_fp80 %{{.+}})
277+
// PPC: call ppc_fp128 @log2l(ppc_fp128 %{{.+}})
278+
// X86F128: call fp128 @log2l(fp128 %{{.+}})
279+
// PPCF128: call fp128 @log2l(fp128 %{{.+}})
280+
__builtin_log2l(f);
281+
282+
// F80: call x86_fp80 @logbl(x86_fp80 %{{.+}})
283+
// PPC: call ppc_fp128 @logbl(ppc_fp128 %{{.+}})
284+
// X86F128: call fp128 @logbl(fp128 %{{.+}})
285+
// PPCF128: call fp128 @logbl(fp128 %{{.+}})
286+
__builtin_logbl(f);
287+
288+
// F80: call i64 @lrintl(x86_fp80 %{{.+}})
289+
// PPC: call i64 @lrintl(ppc_fp128 %{{.+}})
290+
// X86F128: call i64 @lrintl(fp128 %{{.+}})
291+
// PPCF128: call i64 @lrintl(fp128 %{{.+}})
292+
__builtin_lrintl(f);
293+
294+
// F80: call i64 @lroundl(x86_fp80 %{{.+}})
295+
// PPC: call i64 @lroundl(ppc_fp128 %{{.+}})
296+
// X86F128: call i64 @lroundl(fp128 %{{.+}})
297+
// PPCF128: call i64 @lroundl(fp128 %{{.+}})
298+
__builtin_lroundl(f);
299+
300+
// F80: call x86_fp80 @nextafterl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
301+
// PPC: call ppc_fp128 @nextafterl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
302+
// X86F128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
303+
// PPCF128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
304+
__builtin_nextafterl(f,f);
305+
306+
// F80: call x86_fp80 @nexttowardl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
307+
// PPC: call ppc_fp128 @nexttowardl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
308+
// X86F128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
309+
// PPCF128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
310+
__builtin_nexttowardl(f,f);
311+
312+
// F80: call x86_fp80 @remainderl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
313+
// PPC: call ppc_fp128 @remainderl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
314+
// X86F128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
315+
// PPCF128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
316+
__builtin_remainderl(f,f);
317+
318+
// F80: call x86_fp80 @remquol(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, i32* %{{.+}})
319+
// PPC: call ppc_fp128 @remquol(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, i32* %{{.+}})
320+
// X86F128: call fp128 @remquol(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
321+
// PPCF128: call fp128 @remquol(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
322+
__builtin_remquol(f,f,i);
323+
324+
// F80: call x86_fp80 @scalblnl(x86_fp80 %{{.+}}, i64 %{{.+}})
325+
// PPC: call ppc_fp128 @scalblnl(ppc_fp128 %{{.+}}, i64 %{{.+}})
326+
// X86F128: call fp128 @scalblnl(fp128 %{{.+}}, i64 %{{.+}})
327+
// PPCF128: call fp128 @scalblnl(fp128 %{{.+}}, i64 %{{.+}})
328+
__builtin_scalblnl(f,f);
329+
330+
// F80: call x86_fp80 @scalbnl(x86_fp80 %{{.+}}, i32 %{{.+}})
331+
// PPC: call ppc_fp128 @scalbnl(ppc_fp128 %{{.+}}, {{(signext)?.+}})
332+
// X86F128: call fp128 @scalbnl(fp128 %{{.+}}, {{(signext)?.+}})
333+
// PPCF128: call fp128 @scalbnl(fp128 %{{.+}}, {{(signext)?.+}})
334+
__builtin_scalbnl(f,f);
335+
336+
// F80: call x86_fp80 @sinl(x86_fp80 %{{.+}})
337+
// PPC: call ppc_fp128 @sinl(ppc_fp128 %{{.+}})
338+
// X86F128: call fp128 @sinl(fp128 %{{.+}})
339+
// PPCF128: call fp128 @sinl(fp128 %{{.+}})
340+
__builtin_sinl(f);
341+
342+
// F80: call x86_fp80 @sinhl(x86_fp80 %{{.+}})
343+
// PPC: call ppc_fp128 @sinhl(ppc_fp128 %{{.+}})
344+
// X86F128: call fp128 @sinhl(fp128 %{{.+}})
345+
// PPCF128: call fp128 @sinhl(fp128 %{{.+}})
346+
__builtin_sinhl(f);
347+
348+
// F80: call x86_fp80 @sqrtl(x86_fp80 %{{.+}})
349+
// PPC: call ppc_fp128 @sqrtl(ppc_fp128 %{{.+}})
350+
// X86F128: call fp128 @sqrtl(fp128 %{{.+}})
351+
// PPCF128: call fp128 @sqrtl(fp128 %{{.+}})
352+
__builtin_sqrtl(f);
353+
354+
// F80: call x86_fp80 @tanl(x86_fp80 %{{.+}})
355+
// PPC: call ppc_fp128 @tanl(ppc_fp128 %{{.+}})
356+
// X86F128: call fp128 @tanl(fp128 %{{.+}})
357+
// PPCF128: call fp128 @tanl(fp128 %{{.+}})
358+
__builtin_tanl(f);
359+
360+
// F80: call x86_fp80 @tanhl(x86_fp80 %{{.+}})
361+
// PPC: call ppc_fp128 @tanhl(ppc_fp128 %{{.+}})
362+
// X86F128: call fp128 @tanhl(fp128 %{{.+}})
363+
// PPCF128: call fp128 @tanhl(fp128 %{{.+}})
364+
__builtin_tanhl(f);
365+
366+
// F80: call x86_fp80 @tgammal(x86_fp80 %{{.+}})
367+
// PPC: call ppc_fp128 @tgammal(ppc_fp128 %{{.+}})
368+
// X86F128: call fp128 @tgammal(fp128 %{{.+}})
369+
// PPCF128: call fp128 @tgammal(fp128 %{{.+}})
370+
__builtin_tgammal(f);
371+
}

0 commit comments

Comments
 (0)