Mercurial > hg > CbC > CbC_llvm

comparison clang/test/CodeGen/math-builtins-long.c @ 207:2e18cbf3894f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM12
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Tue, 08 Jun 2021 06:07:14 +0900
parents
children c4bab56944e8
comparison
equal deleted inserted replaced
173:0572611fdcc8 207:2e18cbf3894f
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 @fmodf128(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 @atan2f128(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 @frexpf128(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 @ldexpf128(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 @modff128(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 @nanf128(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 @nansf128(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 @powf128(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 @acosf128(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 @acoshf128(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 @asinf128(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 @asinhf128(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 @atanf128(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 @atanhf128(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 @cbrtf128(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 @cosf128(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 @coshf128(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
187 // F80: call x86_fp80 @erfl(x86_fp80 %{{.+}})
188 // PPC: call ppc_fp128 @erfl(ppc_fp128 %{{.+}})
189 // X86F128: call fp128 @erfl(fp128 %{{.+}})
190 // PPCF128: call fp128 @erff128(fp128 %{{.+}})
191 __builtin_erfl(f);
192
193 // F80: call x86_fp80 @erfcl(x86_fp80 %{{.+}})
194 // PPC: call ppc_fp128 @erfcl(ppc_fp128 %{{.+}})
195 // X86F128: call fp128 @erfcl(fp128 %{{.+}})
196 // PPCF128: call fp128 @erfcf128(fp128 %{{.+}})
197 __builtin_erfcl(f);
198
199 // F80: call x86_fp80 @expl(x86_fp80 %{{.+}})
200 // PPC: call ppc_fp128 @expl(ppc_fp128 %{{.+}})
201 // X86F128: call fp128 @expl(fp128 %{{.+}})
202 // PPCF128: call fp128 @expf128(fp128 %{{.+}})
203 __builtin_expl(f);
204
205 // F80: call x86_fp80 @exp2l(x86_fp80 %{{.+}})
206 // PPC: call ppc_fp128 @exp2l(ppc_fp128 %{{.+}})
207 // X86F128: call fp128 @exp2l(fp128 %{{.+}})
208 // PPCF128: call fp128 @exp2f128(fp128 %{{.+}})
209 __builtin_exp2l(f);
210
211 // F80: call x86_fp80 @expm1l(x86_fp80 %{{.+}})
212 // PPC: call ppc_fp128 @expm1l(ppc_fp128 %{{.+}})
213 // X86F128: call fp128 @expm1l(fp128 %{{.+}})
214 // PPCF128: call fp128 @expm1f128(fp128 %{{.+}})
215 __builtin_expm1l(f);
216
217 // F80: call x86_fp80 @fdiml(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
218 // PPC: call ppc_fp128 @fdiml(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
219 // X86F128: call fp128 @fdiml(fp128 %{{.+}}, fp128 %{{.+}})
220 // PPCF128: call fp128 @fdimf128(fp128 %{{.+}}, fp128 %{{.+}})
221 __builtin_fdiml(f,f);
222
223 // F80: call x86_fp80 @fmal(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
224 // PPC: call ppc_fp128 @fmal(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
225 // X86F128: call fp128 @fmal(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
226 // PPCF128: call fp128 @fmaf128(fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}})
227 __builtin_fmal(f,f,f);
228
229 // F80: call x86_fp80 @hypotl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
230 // PPC: call ppc_fp128 @hypotl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
231 // X86F128: call fp128 @hypotl(fp128 %{{.+}}, fp128 %{{.+}})
232 // PPCF128: call fp128 @hypotf128(fp128 %{{.+}}, fp128 %{{.+}})
233 __builtin_hypotl(f,f);
234
235 // F80: call i32 @ilogbl(x86_fp80 %{{.+}})
236 // PPC: call {{(i32)|(signext i32)}} @ilogbl(ppc_fp128 %{{.+}})
237 // X86F128: call {{(i32)|(signext i32)}} @ilogbl(fp128 %{{.+}})
238 // PPCF128: call {{(i32)|(signext i32)}} @ilogbf128(fp128 %{{.+}})
239 __builtin_ilogbl(f);
240
241 // F80: call x86_fp80 @lgammal(x86_fp80 %{{.+}})
242 // PPC: call ppc_fp128 @lgammal(ppc_fp128 %{{.+}})
243 // X86F128: call fp128 @lgammal(fp128 %{{.+}})
244 // PPCF128: call fp128 @lgammaf128(fp128 %{{.+}})
245 __builtin_lgammal(f);
246
247 // F80: call i64 @llrintl(x86_fp80 %{{.+}})
248 // PPC: call i64 @llrintl(ppc_fp128 %{{.+}})
249 // X86F128: call i64 @llrintl(fp128 %{{.+}})
250 // PPCF128: call i64 @llrintf128(fp128 %{{.+}})
251 __builtin_llrintl(f);
252
253 // F80: call i64 @llroundl(x86_fp80 %{{.+}})
254 // PPC: call i64 @llroundl(ppc_fp128 %{{.+}})
255 // X86F128: call i64 @llroundl(fp128 %{{.+}})
256 // PPCF128: call i64 @llroundf128(fp128 %{{.+}})
257 __builtin_llroundl(f);
258
259 // F80: call x86_fp80 @logl(x86_fp80 %{{.+}})
260 // PPC: call ppc_fp128 @logl(ppc_fp128 %{{.+}})
261 // X86F128: call fp128 @logl(fp128 %{{.+}})
262 // PPCF128: call fp128 @logf128(fp128 %{{.+}})
263 __builtin_logl(f);
264
265 // F80: call x86_fp80 @log10l(x86_fp80 %{{.+}})
266 // PPC: call ppc_fp128 @log10l(ppc_fp128 %{{.+}})
267 // X86F128: call fp128 @log10l(fp128 %{{.+}})
268 // PPCF128: call fp128 @log10f128(fp128 %{{.+}})
269 __builtin_log10l(f);
270
271 // F80: call x86_fp80 @log1pl(x86_fp80 %{{.+}})
272 // PPC: call ppc_fp128 @log1pl(ppc_fp128 %{{.+}})
273 // X86F128: call fp128 @log1pl(fp128 %{{.+}})
274 // PPCF128: call fp128 @log1pf128(fp128 %{{.+}})
275 __builtin_log1pl(f);
276
277 // F80: call x86_fp80 @log2l(x86_fp80 %{{.+}})
278 // PPC: call ppc_fp128 @log2l(ppc_fp128 %{{.+}})
279 // X86F128: call fp128 @log2l(fp128 %{{.+}})
280 // PPCF128: call fp128 @log2f128(fp128 %{{.+}})
281 __builtin_log2l(f);
282
283 // F80: call x86_fp80 @logbl(x86_fp80 %{{.+}})
284 // PPC: call ppc_fp128 @logbl(ppc_fp128 %{{.+}})
285 // X86F128: call fp128 @logbl(fp128 %{{.+}})
286 // PPCF128: call fp128 @logbf128(fp128 %{{.+}})
287 __builtin_logbl(f);
288
289 // F80: call i64 @lrintl(x86_fp80 %{{.+}})
290 // PPC: call i64 @lrintl(ppc_fp128 %{{.+}})
291 // X86F128: call i64 @lrintl(fp128 %{{.+}})
292 // PPCF128: call i64 @lrintf128(fp128 %{{.+}})
293 __builtin_lrintl(f);
294
295 // F80: call i64 @lroundl(x86_fp80 %{{.+}})
296 // PPC: call i64 @lroundl(ppc_fp128 %{{.+}})
297 // X86F128: call i64 @lroundl(fp128 %{{.+}})
298 // PPCF128: call i64 @lroundf128(fp128 %{{.+}})
299 __builtin_lroundl(f);
300
301 // F80: call x86_fp80 @nextafterl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
302 // PPC: call ppc_fp128 @nextafterl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
303 // X86F128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
304 // PPCF128: call fp128 @nextafterf128(fp128 %{{.+}}, fp128 %{{.+}})
305 __builtin_nextafterl(f,f);
306
307 // F80: call x86_fp80 @nexttowardl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
308 // PPC: call ppc_fp128 @nexttowardl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
309 // X86F128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
310 // PPCF128: call fp128 @nexttowardf128(fp128 %{{.+}}, fp128 %{{.+}})
311 __builtin_nexttowardl(f,f);
312
313 // F80: call x86_fp80 @remainderl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
314 // PPC: call ppc_fp128 @remainderl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
315 // X86F128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
316 // PPCF128: call fp128 @remainderf128(fp128 %{{.+}}, fp128 %{{.+}})
317 __builtin_remainderl(f,f);
318
319 // F80: call x86_fp80 @remquol(x86_fp80 %{{.+}}, x86_fp80 %{{.+}}, i32* %{{.+}})
320 // PPC: call ppc_fp128 @remquol(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}}, i32* %{{.+}})
321 // X86F128: call fp128 @remquol(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
322 // PPCF128: call fp128 @remquof128(fp128 %{{.+}}, fp128 %{{.+}}, i32* %{{.+}})
323 __builtin_remquol(f,f,i);
324
325 // F80: call x86_fp80 @scalblnl(x86_fp80 %{{.+}}, i64 %{{.+}})
326 // PPC: call ppc_fp128 @scalblnl(ppc_fp128 %{{.+}}, i64 %{{.+}})
327 // X86F128: call fp128 @scalblnl(fp128 %{{.+}}, i64 %{{.+}})
328 // PPCF128: call fp128 @scalblnf128(fp128 %{{.+}}, i64 %{{.+}})
329 __builtin_scalblnl(f,f);
330
331 // F80: call x86_fp80 @scalbnl(x86_fp80 %{{.+}}, i32 %{{.+}})
332 // PPC: call ppc_fp128 @scalbnl(ppc_fp128 %{{.+}}, {{(signext)?.+}})
333 // X86F128: call fp128 @scalbnl(fp128 %{{.+}}, {{(signext)?.+}})
334 // PPCF128: call fp128 @scalbnf128(fp128 %{{.+}}, {{(signext)?.+}})
335 __builtin_scalbnl(f,f);
336
337 // F80: call x86_fp80 @sinl(x86_fp80 %{{.+}})
338 // PPC: call ppc_fp128 @sinl(ppc_fp128 %{{.+}})
339 // X86F128: call fp128 @sinl(fp128 %{{.+}})
340 // PPCF128: call fp128 @sinf128(fp128 %{{.+}})
341 __builtin_sinl(f);
342
343 // F80: call x86_fp80 @sinhl(x86_fp80 %{{.+}})
344 // PPC: call ppc_fp128 @sinhl(ppc_fp128 %{{.+}})
345 // X86F128: call fp128 @sinhl(fp128 %{{.+}})
346 // PPCF128: call fp128 @sinhf128(fp128 %{{.+}})
347 __builtin_sinhl(f);
348
349 // F80: call x86_fp80 @sqrtl(x86_fp80 %{{.+}})
350 // PPC: call ppc_fp128 @sqrtl(ppc_fp128 %{{.+}})
351 // X86F128: call fp128 @sqrtl(fp128 %{{.+}})
352 // PPCF128: call fp128 @sqrtf128(fp128 %{{.+}})
353 __builtin_sqrtl(f);
354
355 // F80: call x86_fp80 @tanl(x86_fp80 %{{.+}})
356 // PPC: call ppc_fp128 @tanl(ppc_fp128 %{{.+}})
357 // X86F128: call fp128 @tanl(fp128 %{{.+}})
358 // PPCF128: call fp128 @tanf128(fp128 %{{.+}})
359 __builtin_tanl(f);
360
361 // F80: call x86_fp80 @tanhl(x86_fp80 %{{.+}})
362 // PPC: call ppc_fp128 @tanhl(ppc_fp128 %{{.+}})
363 // X86F128: call fp128 @tanhl(fp128 %{{.+}})
364 // PPCF128: call fp128 @tanhf128(fp128 %{{.+}})
365 __builtin_tanhl(f);
366
367 // F80: call x86_fp80 @tgammal(x86_fp80 %{{.+}})
368 // PPC: call ppc_fp128 @tgammal(ppc_fp128 %{{.+}})
369 // X86F128: call fp128 @tgammal(fp128 %{{.+}})
370 // PPCF128: call fp128 @tgammaf128(fp128 %{{.+}})
371 __builtin_tgammal(f);
372 }