LLVM 17.0.0git
TargetLibraryInfo.cpp
Go to the documentation of this file.
1//===-- TargetLibraryInfo.cpp - Runtime library information ----------------==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the TargetLibraryInfo class.
10//
11//===----------------------------------------------------------------------===//
12
14#include "llvm/IR/Constants.h"
18using namespace llvm;
19
21 "vector-library", cl::Hidden, cl::desc("Vector functions library"),
24 "No vector functions library"),
26 "Accelerate framework"),
28 "Darwin_libsystem_m", "Darwin libsystem_m"),
30 "GLIBC Vector Math library"),
32 "IBM MASS vector library"),
34 "Intel SVML library"),
36 "SIMD Library for Evaluating Elementary Functions")));
37
38StringLiteral const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
39 {
40#define TLI_DEFINE_STRING
41#include "llvm/Analysis/TargetLibraryInfo.def"
42};
43
44// Recognized types of library function arguments and return types.
45enum FuncArgTypeID : char {
46 Void = 0, // Must be zero.
47 Bool, // 8 bits on all targets
51 IntPlus, // Int or bigger.
52 Long, // Either 32 or 64 bits.
53 IntX, // Any integer type.
55 LLong, // 64 bits on all targets.
56 SizeT, // size_t.
57 SSizeT, // POSIX ssize_t.
58 Flt, // IEEE float.
59 Dbl, // IEEE double.
60 LDbl, // Any floating type (TODO: tighten this up).
61 Floating, // Any floating type.
62 Ptr, // Any pointer type.
63 Struct, // Any struct type.
64 Ellip, // The ellipsis (...).
65 Same, // Same argument type as the previous one.
66};
67
68typedef std::array<FuncArgTypeID, 8> FuncProtoTy;
69
70static const FuncProtoTy Signatures[] = {
71#define TLI_DEFINE_SIG
72#include "llvm/Analysis/TargetLibraryInfo.def"
73};
74
75static_assert(sizeof Signatures / sizeof *Signatures == LibFunc::NumLibFuncs,
76 "Missing library function signatures");
77
78static bool hasSinCosPiStret(const Triple &T) {
79 // Only Darwin variants have _stret versions of combined trig functions.
80 if (!T.isOSDarwin())
81 return false;
82
83 // The ABI is rather complicated on x86, so don't do anything special there.
84 if (T.getArch() == Triple::x86)
85 return false;
86
87 if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9))
88 return false;
89
90 if (T.isiOS() && T.isOSVersionLT(7, 0))
91 return false;
92
93 return true;
94}
95
96static bool hasBcmp(const Triple &TT) {
97 // Posix removed support from bcmp() in 2001, but the glibc and several
98 // implementations of the libc still have it.
99 if (TT.isOSLinux())
100 return TT.isGNUEnvironment() || TT.isMusl();
101 // Both NetBSD and OpenBSD are planning to remove the function. Windows does
102 // not have it.
103 return TT.isOSFreeBSD() || TT.isOSSolaris();
104}
105
107 FunctionType *FuncTy) {
108 switch (CC) {
109 default:
110 return false;
112 return true;
116
117 // The iOS ABI diverges from the standard in some cases, so for now don't
118 // try to simplify those calls.
119 if (Triple(TT).isiOS())
120 return false;
121
122 if (!FuncTy->getReturnType()->isPointerTy() &&
123 !FuncTy->getReturnType()->isIntegerTy() &&
124 !FuncTy->getReturnType()->isVoidTy())
125 return false;
126
127 for (auto *Param : FuncTy->params()) {
128 if (!Param->isPointerTy() && !Param->isIntegerTy())
129 return false;
130 }
131 return true;
132 }
133 }
134 return false;
135}
136
138 return ::isCallingConvCCompatible(CI->getCallingConv(),
139 CI->getModule()->getTargetTriple(),
140 CI->getFunctionType());
141}
142
144 return ::isCallingConvCCompatible(F->getCallingConv(),
145 F->getParent()->getTargetTriple(),
146 F->getFunctionType());
147}
148
149/// Initialize the set of available library functions based on the specified
150/// target triple. This should be carefully written so that a missing target
151/// triple gets a sane set of defaults.
152static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
153 ArrayRef<StringLiteral> StandardNames) {
154 // Verify that the StandardNames array is in alphabetical order.
155 assert(
156 llvm::is_sorted(StandardNames,
157 [](StringRef LHS, StringRef RHS) { return LHS < RHS; }) &&
158 "TargetLibraryInfoImpl function names must be sorted");
159
160 // Set IO unlocked variants as unavailable
161 // Set them as available per system below
162 TLI.setUnavailable(LibFunc_getc_unlocked);
163 TLI.setUnavailable(LibFunc_getchar_unlocked);
164 TLI.setUnavailable(LibFunc_putc_unlocked);
165 TLI.setUnavailable(LibFunc_putchar_unlocked);
166 TLI.setUnavailable(LibFunc_fputc_unlocked);
167 TLI.setUnavailable(LibFunc_fgetc_unlocked);
168 TLI.setUnavailable(LibFunc_fread_unlocked);
169 TLI.setUnavailable(LibFunc_fwrite_unlocked);
170 TLI.setUnavailable(LibFunc_fputs_unlocked);
171 TLI.setUnavailable(LibFunc_fgets_unlocked);
172
173 bool ShouldExtI32Param, ShouldExtI32Return;
174 bool ShouldSignExtI32Param, ShouldSignExtI32Return;
176 ShouldExtI32Return, ShouldSignExtI32Param, ShouldSignExtI32Return, T);
177 TLI.setShouldExtI32Param(ShouldExtI32Param);
178 TLI.setShouldExtI32Return(ShouldExtI32Return);
179 TLI.setShouldSignExtI32Param(ShouldSignExtI32Param);
180 TLI.setShouldSignExtI32Return(ShouldSignExtI32Return);
181
182 // Let's assume by default that the size of int is 32 bits, unless the target
183 // is a 16-bit architecture because then it most likely is 16 bits. If that
184 // isn't true for a target those defaults should be overridden below.
185 TLI.setIntSize(T.isArch16Bit() ? 16 : 32);
186
187 // There is really no runtime library on AMDGPU, apart from
188 // __kmpc_alloc/free_shared.
189 if (T.isAMDGPU()) {
191 TLI.setAvailable(llvm::LibFunc___kmpc_alloc_shared);
192 TLI.setAvailable(llvm::LibFunc___kmpc_free_shared);
193 return;
194 }
195
196 // memset_pattern{4,8,16} is only available on iOS 3.0 and Mac OS X 10.5 and
197 // later. All versions of watchOS support it.
198 if (T.isMacOSX()) {
199 // available IO unlocked variants on Mac OS X
200 TLI.setAvailable(LibFunc_getc_unlocked);
201 TLI.setAvailable(LibFunc_getchar_unlocked);
202 TLI.setAvailable(LibFunc_putc_unlocked);
203 TLI.setAvailable(LibFunc_putchar_unlocked);
204
205 if (T.isMacOSXVersionLT(10, 5)) {
206 TLI.setUnavailable(LibFunc_memset_pattern4);
207 TLI.setUnavailable(LibFunc_memset_pattern8);
208 TLI.setUnavailable(LibFunc_memset_pattern16);
209 }
210 } else if (T.isiOS()) {
211 if (T.isOSVersionLT(3, 0)) {
212 TLI.setUnavailable(LibFunc_memset_pattern4);
213 TLI.setUnavailable(LibFunc_memset_pattern8);
214 TLI.setUnavailable(LibFunc_memset_pattern16);
215 }
216 } else if (!T.isWatchOS()) {
217 TLI.setUnavailable(LibFunc_memset_pattern4);
218 TLI.setUnavailable(LibFunc_memset_pattern8);
219 TLI.setUnavailable(LibFunc_memset_pattern16);
220 }
221
222 if (!hasSinCosPiStret(T)) {
223 TLI.setUnavailable(LibFunc_sinpi);
224 TLI.setUnavailable(LibFunc_sinpif);
225 TLI.setUnavailable(LibFunc_cospi);
226 TLI.setUnavailable(LibFunc_cospif);
227 TLI.setUnavailable(LibFunc_sincospi_stret);
228 TLI.setUnavailable(LibFunc_sincospif_stret);
229 }
230
231 if (!hasBcmp(T))
232 TLI.setUnavailable(LibFunc_bcmp);
233
234 if (T.isMacOSX() && T.getArch() == Triple::x86 &&
235 !T.isMacOSXVersionLT(10, 7)) {
236 // x86-32 OSX has a scheme where fwrite and fputs (and some other functions
237 // we don't care about) have two versions; on recent OSX, the one we want
238 // has a $UNIX2003 suffix. The two implementations are identical except
239 // for the return value in some edge cases. However, we don't want to
240 // generate code that depends on the old symbols.
241 TLI.setAvailableWithName(LibFunc_fwrite, "fwrite$UNIX2003");
242 TLI.setAvailableWithName(LibFunc_fputs, "fputs$UNIX2003");
243 }
244
245 // iprintf and friends are only available on XCore, TCE, and Emscripten.
246 if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce &&
247 T.getOS() != Triple::Emscripten) {
248 TLI.setUnavailable(LibFunc_iprintf);
249 TLI.setUnavailable(LibFunc_siprintf);
250 TLI.setUnavailable(LibFunc_fiprintf);
251 }
252
253 // __small_printf and friends are only available on Emscripten.
254 if (T.getOS() != Triple::Emscripten) {
255 TLI.setUnavailable(LibFunc_small_printf);
256 TLI.setUnavailable(LibFunc_small_sprintf);
257 TLI.setUnavailable(LibFunc_small_fprintf);
258 }
259
260 if (T.isOSWindows() && !T.isOSCygMing()) {
261 // XXX: The earliest documentation available at the moment is for VS2015/VC19:
262 // https://docs.microsoft.com/en-us/cpp/c-runtime-library/floating-point-support?view=vs-2015
263 // XXX: In order to use an MSVCRT older than VC19,
264 // the specific library version must be explicit in the target triple,
265 // e.g., x86_64-pc-windows-msvc18.
266 bool hasPartialC99 = true;
267 if (T.isKnownWindowsMSVCEnvironment()) {
268 VersionTuple Version = T.getEnvironmentVersion();
269 hasPartialC99 = (Version.getMajor() == 0 || Version.getMajor() >= 19);
270 }
271
272 // Latest targets support C89 math functions, in part.
273 bool isARM = (T.getArch() == Triple::aarch64 ||
274 T.getArch() == Triple::arm);
275 bool hasPartialFloat = (isARM ||
276 T.getArch() == Triple::x86_64);
277
278 // Win32 does not support float C89 math functions, in general.
279 if (!hasPartialFloat) {
280 TLI.setUnavailable(LibFunc_acosf);
281 TLI.setUnavailable(LibFunc_asinf);
282 TLI.setUnavailable(LibFunc_atan2f);
283 TLI.setUnavailable(LibFunc_atanf);
284 TLI.setUnavailable(LibFunc_ceilf);
285 TLI.setUnavailable(LibFunc_cosf);
286 TLI.setUnavailable(LibFunc_coshf);
287 TLI.setUnavailable(LibFunc_expf);
288 TLI.setUnavailable(LibFunc_floorf);
289 TLI.setUnavailable(LibFunc_fmodf);
290 TLI.setUnavailable(LibFunc_log10f);
291 TLI.setUnavailable(LibFunc_logf);
292 TLI.setUnavailable(LibFunc_modff);
293 TLI.setUnavailable(LibFunc_powf);
294 TLI.setUnavailable(LibFunc_remainderf);
295 TLI.setUnavailable(LibFunc_sinf);
296 TLI.setUnavailable(LibFunc_sinhf);
297 TLI.setUnavailable(LibFunc_sqrtf);
298 TLI.setUnavailable(LibFunc_tanf);
299 TLI.setUnavailable(LibFunc_tanhf);
300 }
301 if (!isARM)
302 TLI.setUnavailable(LibFunc_fabsf);
303 TLI.setUnavailable(LibFunc_frexpf);
304 TLI.setUnavailable(LibFunc_ldexpf);
305
306 // Win32 does not support long double C89 math functions.
307 TLI.setUnavailable(LibFunc_acosl);
308 TLI.setUnavailable(LibFunc_asinl);
309 TLI.setUnavailable(LibFunc_atan2l);
310 TLI.setUnavailable(LibFunc_atanl);
311 TLI.setUnavailable(LibFunc_ceill);
312 TLI.setUnavailable(LibFunc_cosl);
313 TLI.setUnavailable(LibFunc_coshl);
314 TLI.setUnavailable(LibFunc_expl);
315 TLI.setUnavailable(LibFunc_fabsl);
316 TLI.setUnavailable(LibFunc_floorl);
317 TLI.setUnavailable(LibFunc_fmodl);
318 TLI.setUnavailable(LibFunc_frexpl);
319 TLI.setUnavailable(LibFunc_ldexpl);
320 TLI.setUnavailable(LibFunc_log10l);
321 TLI.setUnavailable(LibFunc_logl);
322 TLI.setUnavailable(LibFunc_modfl);
323 TLI.setUnavailable(LibFunc_powl);
324 TLI.setUnavailable(LibFunc_remainderl);
325 TLI.setUnavailable(LibFunc_sinl);
326 TLI.setUnavailable(LibFunc_sinhl);
327 TLI.setUnavailable(LibFunc_sqrtl);
328 TLI.setUnavailable(LibFunc_tanl);
329 TLI.setUnavailable(LibFunc_tanhl);
330
331 // Win32 does not fully support C99 math functions.
332 if (!hasPartialC99) {
333 TLI.setUnavailable(LibFunc_acosh);
334 TLI.setUnavailable(LibFunc_acoshf);
335 TLI.setUnavailable(LibFunc_asinh);
336 TLI.setUnavailable(LibFunc_asinhf);
337 TLI.setUnavailable(LibFunc_atanh);
338 TLI.setUnavailable(LibFunc_atanhf);
339 TLI.setAvailableWithName(LibFunc_cabs, "_cabs");
340 TLI.setUnavailable(LibFunc_cabsf);
341 TLI.setUnavailable(LibFunc_cbrt);
342 TLI.setUnavailable(LibFunc_cbrtf);
343 TLI.setAvailableWithName(LibFunc_copysign, "_copysign");
344 TLI.setAvailableWithName(LibFunc_copysignf, "_copysignf");
345 TLI.setUnavailable(LibFunc_exp2);
346 TLI.setUnavailable(LibFunc_exp2f);
347 TLI.setUnavailable(LibFunc_expm1);
348 TLI.setUnavailable(LibFunc_expm1f);
349 TLI.setUnavailable(LibFunc_fmax);
350 TLI.setUnavailable(LibFunc_fmaxf);
351 TLI.setUnavailable(LibFunc_fmin);
352 TLI.setUnavailable(LibFunc_fminf);
353 TLI.setUnavailable(LibFunc_log1p);
354 TLI.setUnavailable(LibFunc_log1pf);
355 TLI.setUnavailable(LibFunc_log2);
356 TLI.setUnavailable(LibFunc_log2f);
357 TLI.setAvailableWithName(LibFunc_logb, "_logb");
358 if (hasPartialFloat)
359 TLI.setAvailableWithName(LibFunc_logbf, "_logbf");
360 else
361 TLI.setUnavailable(LibFunc_logbf);
362 TLI.setUnavailable(LibFunc_rint);
363 TLI.setUnavailable(LibFunc_rintf);
364 TLI.setUnavailable(LibFunc_round);
365 TLI.setUnavailable(LibFunc_roundf);
366 TLI.setUnavailable(LibFunc_trunc);
367 TLI.setUnavailable(LibFunc_truncf);
368 }
369
370 // Win32 does not support long double C99 math functions.
371 TLI.setUnavailable(LibFunc_acoshl);
372 TLI.setUnavailable(LibFunc_asinhl);
373 TLI.setUnavailable(LibFunc_atanhl);
374 TLI.setUnavailable(LibFunc_cabsl);
375 TLI.setUnavailable(LibFunc_cbrtl);
376 TLI.setUnavailable(LibFunc_copysignl);
377 TLI.setUnavailable(LibFunc_exp2l);
378 TLI.setUnavailable(LibFunc_expm1l);
379 TLI.setUnavailable(LibFunc_fmaxl);
380 TLI.setUnavailable(LibFunc_fminl);
381 TLI.setUnavailable(LibFunc_log1pl);
382 TLI.setUnavailable(LibFunc_log2l);
383 TLI.setUnavailable(LibFunc_logbl);
384 TLI.setUnavailable(LibFunc_nearbyintl);
385 TLI.setUnavailable(LibFunc_rintl);
386 TLI.setUnavailable(LibFunc_roundl);
387 TLI.setUnavailable(LibFunc_truncl);
388
389 // Win32 does not support these functions, but
390 // they are generally available on POSIX-compliant systems.
391 TLI.setUnavailable(LibFunc_access);
392 TLI.setUnavailable(LibFunc_chmod);
393 TLI.setUnavailable(LibFunc_closedir);
394 TLI.setUnavailable(LibFunc_fdopen);
395 TLI.setUnavailable(LibFunc_fileno);
396 TLI.setUnavailable(LibFunc_fseeko);
397 TLI.setUnavailable(LibFunc_fstat);
398 TLI.setUnavailable(LibFunc_ftello);
399 TLI.setUnavailable(LibFunc_gettimeofday);
400 TLI.setUnavailable(LibFunc_memccpy);
401 TLI.setUnavailable(LibFunc_mkdir);
402 TLI.setUnavailable(LibFunc_open);
403 TLI.setUnavailable(LibFunc_opendir);
404 TLI.setUnavailable(LibFunc_pclose);
405 TLI.setUnavailable(LibFunc_popen);
406 TLI.setUnavailable(LibFunc_read);
407 TLI.setUnavailable(LibFunc_rmdir);
408 TLI.setUnavailable(LibFunc_stat);
409 TLI.setUnavailable(LibFunc_strcasecmp);
410 TLI.setUnavailable(LibFunc_strncasecmp);
411 TLI.setUnavailable(LibFunc_unlink);
412 TLI.setUnavailable(LibFunc_utime);
413 TLI.setUnavailable(LibFunc_write);
414 }
415
416 if (T.isOSWindows() && !T.isWindowsCygwinEnvironment()) {
417 // These functions aren't available in either MSVC or MinGW environments.
418 TLI.setUnavailable(LibFunc_bcmp);
419 TLI.setUnavailable(LibFunc_bcopy);
420 TLI.setUnavailable(LibFunc_bzero);
421 TLI.setUnavailable(LibFunc_chown);
422 TLI.setUnavailable(LibFunc_ctermid);
423 TLI.setUnavailable(LibFunc_ffs);
424 TLI.setUnavailable(LibFunc_flockfile);
425 TLI.setUnavailable(LibFunc_fstatvfs);
426 TLI.setUnavailable(LibFunc_ftrylockfile);
427 TLI.setUnavailable(LibFunc_funlockfile);
428 TLI.setUnavailable(LibFunc_getitimer);
429 TLI.setUnavailable(LibFunc_getlogin_r);
430 TLI.setUnavailable(LibFunc_getpwnam);
431 TLI.setUnavailable(LibFunc_htonl);
432 TLI.setUnavailable(LibFunc_htons);
433 TLI.setUnavailable(LibFunc_lchown);
434 TLI.setUnavailable(LibFunc_lstat);
435 TLI.setUnavailable(LibFunc_memrchr);
436 TLI.setUnavailable(LibFunc_ntohl);
437 TLI.setUnavailable(LibFunc_ntohs);
438 TLI.setUnavailable(LibFunc_pread);
439 TLI.setUnavailable(LibFunc_pwrite);
440 TLI.setUnavailable(LibFunc_readlink);
441 TLI.setUnavailable(LibFunc_realpath);
442 TLI.setUnavailable(LibFunc_setitimer);
443 TLI.setUnavailable(LibFunc_statvfs);
444 TLI.setUnavailable(LibFunc_stpcpy);
445 TLI.setUnavailable(LibFunc_stpncpy);
446 TLI.setUnavailable(LibFunc_times);
447 TLI.setUnavailable(LibFunc_uname);
448 TLI.setUnavailable(LibFunc_unsetenv);
449 TLI.setUnavailable(LibFunc_utimes);
450 }
451
452 // Pick just one set of new/delete variants.
453 if (T.isOSMSVCRT()) {
454 // MSVC, doesn't have the Itanium new/delete.
455 TLI.setUnavailable(LibFunc_ZdaPv);
456 TLI.setUnavailable(LibFunc_ZdaPvRKSt9nothrow_t);
457 TLI.setUnavailable(LibFunc_ZdaPvSt11align_val_t);
458 TLI.setUnavailable(LibFunc_ZdaPvSt11align_val_tRKSt9nothrow_t);
459 TLI.setUnavailable(LibFunc_ZdaPvj);
460 TLI.setUnavailable(LibFunc_ZdaPvjSt11align_val_t);
461 TLI.setUnavailable(LibFunc_ZdaPvm);
462 TLI.setUnavailable(LibFunc_ZdaPvmSt11align_val_t);
463 TLI.setUnavailable(LibFunc_ZdlPv);
464 TLI.setUnavailable(LibFunc_ZdlPvRKSt9nothrow_t);
465 TLI.setUnavailable(LibFunc_ZdlPvSt11align_val_t);
466 TLI.setUnavailable(LibFunc_ZdlPvSt11align_val_tRKSt9nothrow_t);
467 TLI.setUnavailable(LibFunc_ZdlPvj);
468 TLI.setUnavailable(LibFunc_ZdlPvjSt11align_val_t);
469 TLI.setUnavailable(LibFunc_ZdlPvm);
470 TLI.setUnavailable(LibFunc_ZdlPvmSt11align_val_t);
471 TLI.setUnavailable(LibFunc_Znaj);
472 TLI.setUnavailable(LibFunc_ZnajRKSt9nothrow_t);
473 TLI.setUnavailable(LibFunc_ZnajSt11align_val_t);
474 TLI.setUnavailable(LibFunc_ZnajSt11align_val_tRKSt9nothrow_t);
475 TLI.setUnavailable(LibFunc_Znam);
476 TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t);
477 TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t);
478 TLI.setUnavailable(LibFunc_ZnamSt11align_val_t);
479 TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t);
480 TLI.setUnavailable(LibFunc_Znwj);
481 TLI.setUnavailable(LibFunc_ZnwjRKSt9nothrow_t);
482 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_t);
483 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t);
484 TLI.setUnavailable(LibFunc_Znwm);
485 TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t);
486 TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t);
487 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t);
488 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t);
489 TLI.setUnavailable(LibFunc_Znwm12__hot_cold_t);
490 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t12__hot_cold_t);
491 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
492 TLI.setUnavailable(LibFunc_Znam12__hot_cold_t);
493 TLI.setUnavailable(LibFunc_ZnamSt11align_val_t12__hot_cold_t);
494 TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
495 } else {
496 // Not MSVC, assume it's Itanium.
497 TLI.setUnavailable(LibFunc_msvc_new_int);
498 TLI.setUnavailable(LibFunc_msvc_new_int_nothrow);
499 TLI.setUnavailable(LibFunc_msvc_new_longlong);
500 TLI.setUnavailable(LibFunc_msvc_new_longlong_nothrow);
501 TLI.setUnavailable(LibFunc_msvc_delete_ptr32);
502 TLI.setUnavailable(LibFunc_msvc_delete_ptr32_nothrow);
503 TLI.setUnavailable(LibFunc_msvc_delete_ptr32_int);
504 TLI.setUnavailable(LibFunc_msvc_delete_ptr64);
505 TLI.setUnavailable(LibFunc_msvc_delete_ptr64_nothrow);
506 TLI.setUnavailable(LibFunc_msvc_delete_ptr64_longlong);
507 TLI.setUnavailable(LibFunc_msvc_new_array_int);
508 TLI.setUnavailable(LibFunc_msvc_new_array_int_nothrow);
509 TLI.setUnavailable(LibFunc_msvc_new_array_longlong);
510 TLI.setUnavailable(LibFunc_msvc_new_array_longlong_nothrow);
511 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32);
512 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32_nothrow);
513 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32_int);
514 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64);
515 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64_nothrow);
516 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64_longlong);
517 }
518
519 switch (T.getOS()) {
520 case Triple::MacOSX:
521 // exp10 and exp10f are not available on OS X until 10.9 and iOS until 7.0
522 // and their names are __exp10 and __exp10f. exp10l is not available on
523 // OS X or iOS.
524 TLI.setUnavailable(LibFunc_exp10l);
525 if (T.isMacOSXVersionLT(10, 9)) {
526 TLI.setUnavailable(LibFunc_exp10);
527 TLI.setUnavailable(LibFunc_exp10f);
528 } else {
529 TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
530 TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
531 }
532 break;
533 case Triple::IOS:
534 case Triple::TvOS:
535 case Triple::WatchOS:
536 TLI.setUnavailable(LibFunc_exp10l);
537 if (!T.isWatchOS() &&
538 (T.isOSVersionLT(7, 0) || (T.isOSVersionLT(9, 0) && T.isX86()))) {
539 TLI.setUnavailable(LibFunc_exp10);
540 TLI.setUnavailable(LibFunc_exp10f);
541 } else {
542 TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
543 TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
544 }
545 break;
546 case Triple::Linux:
547 // exp10, exp10f, exp10l is available on Linux (GLIBC) but are extremely
548 // buggy prior to glibc version 2.18. Until this version is widely deployed
549 // or we have a reasonable detection strategy, we cannot use exp10 reliably
550 // on Linux.
551 //
552 // Fall through to disable all of them.
553 [[fallthrough]];
554 default:
555 TLI.setUnavailable(LibFunc_exp10);
556 TLI.setUnavailable(LibFunc_exp10f);
557 TLI.setUnavailable(LibFunc_exp10l);
558 }
559
560 // ffsl is available on at least Darwin, Mac OS X, iOS, FreeBSD, and
561 // Linux (GLIBC):
562 // http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/ffsl.3.html
563 // http://svn.freebsd.org/base/head/lib/libc/string/ffsl.c
564 // http://www.gnu.org/software/gnulib/manual/html_node/ffsl.html
565 switch (T.getOS()) {
566 case Triple::Darwin:
567 case Triple::MacOSX:
568 case Triple::IOS:
569 case Triple::TvOS:
570 case Triple::WatchOS:
571 case Triple::FreeBSD:
572 case Triple::Linux:
573 break;
574 default:
575 TLI.setUnavailable(LibFunc_ffsl);
576 }
577
578 // ffsll is available on at least FreeBSD and Linux (GLIBC):
579 // http://svn.freebsd.org/base/head/lib/libc/string/ffsll.c
580 // http://www.gnu.org/software/gnulib/manual/html_node/ffsll.html
581 switch (T.getOS()) {
582 case Triple::Darwin:
583 case Triple::MacOSX:
584 case Triple::IOS:
585 case Triple::TvOS:
586 case Triple::WatchOS:
587 case Triple::FreeBSD:
588 case Triple::Linux:
589 break;
590 default:
591 TLI.setUnavailable(LibFunc_ffsll);
592 }
593
594 // The following functions are available on at least FreeBSD:
595 // http://svn.freebsd.org/base/head/lib/libc/string/fls.c
596 // http://svn.freebsd.org/base/head/lib/libc/string/flsl.c
597 // http://svn.freebsd.org/base/head/lib/libc/string/flsll.c
598 if (!T.isOSFreeBSD()) {
599 TLI.setUnavailable(LibFunc_fls);
600 TLI.setUnavailable(LibFunc_flsl);
601 TLI.setUnavailable(LibFunc_flsll);
602 }
603
604 // The following functions are only available on GNU/Linux (using glibc).
605 // Linux variants without glibc (eg: bionic, musl) may have some subset.
606 if (!T.isOSLinux() || !T.isGNUEnvironment()) {
607 TLI.setUnavailable(LibFunc_dunder_strdup);
608 TLI.setUnavailable(LibFunc_dunder_strtok_r);
609 TLI.setUnavailable(LibFunc_dunder_isoc99_scanf);
610 TLI.setUnavailable(LibFunc_dunder_isoc99_sscanf);
611 TLI.setUnavailable(LibFunc_under_IO_getc);
612 TLI.setUnavailable(LibFunc_under_IO_putc);
613 // But, Android and musl have memalign.
614 if (!T.isAndroid() && !T.isMusl())
615 TLI.setUnavailable(LibFunc_memalign);
616 TLI.setUnavailable(LibFunc_fopen64);
617 TLI.setUnavailable(LibFunc_fseeko64);
618 TLI.setUnavailable(LibFunc_fstat64);
619 TLI.setUnavailable(LibFunc_fstatvfs64);
620 TLI.setUnavailable(LibFunc_ftello64);
621 TLI.setUnavailable(LibFunc_lstat64);
622 TLI.setUnavailable(LibFunc_open64);
623 TLI.setUnavailable(LibFunc_stat64);
624 TLI.setUnavailable(LibFunc_statvfs64);
625 TLI.setUnavailable(LibFunc_tmpfile64);
626
627 // Relaxed math functions are included in math-finite.h on Linux (GLIBC).
628 // Note that math-finite.h is no longer supported by top-of-tree GLIBC,
629 // so we keep these functions around just so that they're recognized by
630 // the ConstantFolder.
631 TLI.setUnavailable(LibFunc_acos_finite);
632 TLI.setUnavailable(LibFunc_acosf_finite);
633 TLI.setUnavailable(LibFunc_acosl_finite);
634 TLI.setUnavailable(LibFunc_acosh_finite);
635 TLI.setUnavailable(LibFunc_acoshf_finite);
636 TLI.setUnavailable(LibFunc_acoshl_finite);
637 TLI.setUnavailable(LibFunc_asin_finite);
638 TLI.setUnavailable(LibFunc_asinf_finite);
639 TLI.setUnavailable(LibFunc_asinl_finite);
640 TLI.setUnavailable(LibFunc_atan2_finite);
641 TLI.setUnavailable(LibFunc_atan2f_finite);
642 TLI.setUnavailable(LibFunc_atan2l_finite);
643 TLI.setUnavailable(LibFunc_atanh_finite);
644 TLI.setUnavailable(LibFunc_atanhf_finite);
645 TLI.setUnavailable(LibFunc_atanhl_finite);
646 TLI.setUnavailable(LibFunc_cosh_finite);
647 TLI.setUnavailable(LibFunc_coshf_finite);
648 TLI.setUnavailable(LibFunc_coshl_finite);
649 TLI.setUnavailable(LibFunc_exp10_finite);
650 TLI.setUnavailable(LibFunc_exp10f_finite);
651 TLI.setUnavailable(LibFunc_exp10l_finite);
652 TLI.setUnavailable(LibFunc_exp2_finite);
653 TLI.setUnavailable(LibFunc_exp2f_finite);
654 TLI.setUnavailable(LibFunc_exp2l_finite);
655 TLI.setUnavailable(LibFunc_exp_finite);
656 TLI.setUnavailable(LibFunc_expf_finite);
657 TLI.setUnavailable(LibFunc_expl_finite);
658 TLI.setUnavailable(LibFunc_log10_finite);
659 TLI.setUnavailable(LibFunc_log10f_finite);
660 TLI.setUnavailable(LibFunc_log10l_finite);
661 TLI.setUnavailable(LibFunc_log2_finite);
662 TLI.setUnavailable(LibFunc_log2f_finite);
663 TLI.setUnavailable(LibFunc_log2l_finite);
664 TLI.setUnavailable(LibFunc_log_finite);
665 TLI.setUnavailable(LibFunc_logf_finite);
666 TLI.setUnavailable(LibFunc_logl_finite);
667 TLI.setUnavailable(LibFunc_pow_finite);
668 TLI.setUnavailable(LibFunc_powf_finite);
669 TLI.setUnavailable(LibFunc_powl_finite);
670 TLI.setUnavailable(LibFunc_sinh_finite);
671 TLI.setUnavailable(LibFunc_sinhf_finite);
672 TLI.setUnavailable(LibFunc_sinhl_finite);
673 TLI.setUnavailable(LibFunc_sqrt_finite);
674 TLI.setUnavailable(LibFunc_sqrtf_finite);
675 TLI.setUnavailable(LibFunc_sqrtl_finite);
676 }
677
678 if ((T.isOSLinux() && T.isGNUEnvironment()) ||
679 (T.isAndroid() && !T.isAndroidVersionLT(28))) {
680 // available IO unlocked variants on GNU/Linux and Android P or later
681 TLI.setAvailable(LibFunc_getc_unlocked);
682 TLI.setAvailable(LibFunc_getchar_unlocked);
683 TLI.setAvailable(LibFunc_putc_unlocked);
684 TLI.setAvailable(LibFunc_putchar_unlocked);
685 TLI.setAvailable(LibFunc_fputc_unlocked);
686 TLI.setAvailable(LibFunc_fgetc_unlocked);
687 TLI.setAvailable(LibFunc_fread_unlocked);
688 TLI.setAvailable(LibFunc_fwrite_unlocked);
689 TLI.setAvailable(LibFunc_fputs_unlocked);
690 TLI.setAvailable(LibFunc_fgets_unlocked);
691 }
692
693 if (T.isAndroid() && T.isAndroidVersionLT(21)) {
694 TLI.setUnavailable(LibFunc_stpcpy);
695 TLI.setUnavailable(LibFunc_stpncpy);
696 }
697
698 if (T.isPS()) {
699 // PS4/PS5 do have memalign.
700 TLI.setAvailable(LibFunc_memalign);
701
702 // PS4/PS5 do not have new/delete with "unsigned int" size parameter;
703 // they only have the "unsigned long" versions.
704 TLI.setUnavailable(LibFunc_ZdaPvj);
705 TLI.setUnavailable(LibFunc_ZdaPvjSt11align_val_t);
706 TLI.setUnavailable(LibFunc_ZdlPvj);
707 TLI.setUnavailable(LibFunc_ZdlPvjSt11align_val_t);
708 TLI.setUnavailable(LibFunc_Znaj);
709 TLI.setUnavailable(LibFunc_ZnajRKSt9nothrow_t);
710 TLI.setUnavailable(LibFunc_ZnajSt11align_val_t);
711 TLI.setUnavailable(LibFunc_ZnajSt11align_val_tRKSt9nothrow_t);
712 TLI.setUnavailable(LibFunc_Znwj);
713 TLI.setUnavailable(LibFunc_ZnwjRKSt9nothrow_t);
714 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_t);
715 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t);
716
717 // None of the *_chk functions.
718 TLI.setUnavailable(LibFunc_memccpy_chk);
719 TLI.setUnavailable(LibFunc_memcpy_chk);
720 TLI.setUnavailable(LibFunc_memmove_chk);
721 TLI.setUnavailable(LibFunc_mempcpy_chk);
722 TLI.setUnavailable(LibFunc_memset_chk);
723 TLI.setUnavailable(LibFunc_snprintf_chk);
724 TLI.setUnavailable(LibFunc_sprintf_chk);
725 TLI.setUnavailable(LibFunc_stpcpy_chk);
726 TLI.setUnavailable(LibFunc_stpncpy_chk);
727 TLI.setUnavailable(LibFunc_strcat_chk);
728 TLI.setUnavailable(LibFunc_strcpy_chk);
729 TLI.setUnavailable(LibFunc_strlcat_chk);
730 TLI.setUnavailable(LibFunc_strlcpy_chk);
731 TLI.setUnavailable(LibFunc_strlen_chk);
732 TLI.setUnavailable(LibFunc_strncat_chk);
733 TLI.setUnavailable(LibFunc_strncpy_chk);
734 TLI.setUnavailable(LibFunc_vsnprintf_chk);
735 TLI.setUnavailable(LibFunc_vsprintf_chk);
736
737 // Various Posix system functions.
738 TLI.setUnavailable(LibFunc_access);
739 TLI.setUnavailable(LibFunc_chmod);
740 TLI.setUnavailable(LibFunc_chown);
741 TLI.setUnavailable(LibFunc_closedir);
742 TLI.setUnavailable(LibFunc_ctermid);
743 TLI.setUnavailable(LibFunc_execl);
744 TLI.setUnavailable(LibFunc_execle);
745 TLI.setUnavailable(LibFunc_execlp);
746 TLI.setUnavailable(LibFunc_execv);
747 TLI.setUnavailable(LibFunc_execvP);
748 TLI.setUnavailable(LibFunc_execve);
749 TLI.setUnavailable(LibFunc_execvp);
750 TLI.setUnavailable(LibFunc_execvpe);
751 TLI.setUnavailable(LibFunc_fork);
752 TLI.setUnavailable(LibFunc_fstat);
753 TLI.setUnavailable(LibFunc_fstatvfs);
754 TLI.setUnavailable(LibFunc_getenv);
755 TLI.setUnavailable(LibFunc_getitimer);
756 TLI.setUnavailable(LibFunc_getlogin_r);
757 TLI.setUnavailable(LibFunc_getpwnam);
758 TLI.setUnavailable(LibFunc_gettimeofday);
759 TLI.setUnavailable(LibFunc_lchown);
760 TLI.setUnavailable(LibFunc_lstat);
761 TLI.setUnavailable(LibFunc_mkdir);
762 TLI.setUnavailable(LibFunc_open);
763 TLI.setUnavailable(LibFunc_opendir);
764 TLI.setUnavailable(LibFunc_pclose);
765 TLI.setUnavailable(LibFunc_popen);
766 TLI.setUnavailable(LibFunc_pread);
767 TLI.setUnavailable(LibFunc_pwrite);
768 TLI.setUnavailable(LibFunc_read);
769 TLI.setUnavailable(LibFunc_readlink);
770 TLI.setUnavailable(LibFunc_realpath);
771 TLI.setUnavailable(LibFunc_rename);
772 TLI.setUnavailable(LibFunc_rmdir);
773 TLI.setUnavailable(LibFunc_setitimer);
774 TLI.setUnavailable(LibFunc_stat);
775 TLI.setUnavailable(LibFunc_statvfs);
776 TLI.setUnavailable(LibFunc_system);
777 TLI.setUnavailable(LibFunc_times);
778 TLI.setUnavailable(LibFunc_tmpfile);
779 TLI.setUnavailable(LibFunc_unlink);
780 TLI.setUnavailable(LibFunc_uname);
781 TLI.setUnavailable(LibFunc_unsetenv);
782 TLI.setUnavailable(LibFunc_utime);
783 TLI.setUnavailable(LibFunc_utimes);
784 TLI.setUnavailable(LibFunc_valloc);
785 TLI.setUnavailable(LibFunc_write);
786
787 // Miscellaneous other functions not provided.
788 TLI.setUnavailable(LibFunc_atomic_load);
789 TLI.setUnavailable(LibFunc_atomic_store);
790 TLI.setUnavailable(LibFunc___kmpc_alloc_shared);
791 TLI.setUnavailable(LibFunc___kmpc_free_shared);
792 TLI.setUnavailable(LibFunc_dunder_strndup);
793 TLI.setUnavailable(LibFunc_bcmp);
794 TLI.setUnavailable(LibFunc_bcopy);
795 TLI.setUnavailable(LibFunc_bzero);
796 TLI.setUnavailable(LibFunc_cabs);
797 TLI.setUnavailable(LibFunc_cabsf);
798 TLI.setUnavailable(LibFunc_cabsl);
799 TLI.setUnavailable(LibFunc_ffs);
800 TLI.setUnavailable(LibFunc_flockfile);
801 TLI.setUnavailable(LibFunc_fseeko);
802 TLI.setUnavailable(LibFunc_ftello);
803 TLI.setUnavailable(LibFunc_ftrylockfile);
804 TLI.setUnavailable(LibFunc_funlockfile);
805 TLI.setUnavailable(LibFunc_htonl);
806 TLI.setUnavailable(LibFunc_htons);
807 TLI.setUnavailable(LibFunc_isascii);
808 TLI.setUnavailable(LibFunc_memccpy);
809 TLI.setUnavailable(LibFunc_mempcpy);
810 TLI.setUnavailable(LibFunc_memrchr);
811 TLI.setUnavailable(LibFunc_ntohl);
812 TLI.setUnavailable(LibFunc_ntohs);
813 TLI.setUnavailable(LibFunc_reallocf);
814 TLI.setUnavailable(LibFunc_roundeven);
815 TLI.setUnavailable(LibFunc_roundevenf);
816 TLI.setUnavailable(LibFunc_roundevenl);
817 TLI.setUnavailable(LibFunc_stpcpy);
818 TLI.setUnavailable(LibFunc_stpncpy);
819 TLI.setUnavailable(LibFunc_strlcat);
820 TLI.setUnavailable(LibFunc_strlcpy);
821 TLI.setUnavailable(LibFunc_strndup);
822 TLI.setUnavailable(LibFunc_strnlen);
823 TLI.setUnavailable(LibFunc_toascii);
824 }
825
826 // As currently implemented in clang, NVPTX code has no standard library to
827 // speak of. Headers provide a standard-ish library implementation, but many
828 // of the signatures are wrong -- for example, many libm functions are not
829 // extern "C".
830 //
831 // libdevice, an IR library provided by nvidia, is linked in by the front-end,
832 // but only used functions are provided to llvm. Moreover, most of the
833 // functions in libdevice don't map precisely to standard library functions.
834 //
835 // FIXME: Having no standard library prevents e.g. many fastmath
836 // optimizations, so this situation should be fixed.
837 if (T.isNVPTX()) {
839 TLI.setAvailable(LibFunc_nvvm_reflect);
840 TLI.setAvailable(llvm::LibFunc_malloc);
841 TLI.setAvailable(llvm::LibFunc_free);
842
843 // TODO: We could enable the following two according to [0] but we haven't
844 // done an evaluation wrt. the performance implications.
845 // [0]
846 // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#dynamic-global-memory-allocation-and-operations
847 //
848 // TLI.setAvailable(llvm::LibFunc_memcpy);
849 // TLI.setAvailable(llvm::LibFunc_memset);
850
851 TLI.setAvailable(llvm::LibFunc___kmpc_alloc_shared);
852 TLI.setAvailable(llvm::LibFunc___kmpc_free_shared);
853 } else {
854 TLI.setUnavailable(LibFunc_nvvm_reflect);
855 }
856
857 // These vec_malloc/free routines are only available on AIX.
858 if (!T.isOSAIX()) {
859 TLI.setUnavailable(LibFunc_vec_calloc);
860 TLI.setUnavailable(LibFunc_vec_malloc);
861 TLI.setUnavailable(LibFunc_vec_realloc);
862 TLI.setUnavailable(LibFunc_vec_free);
863 }
864
866}
867
869 // Default to everything being available.
870 memset(AvailableArray, -1, sizeof(AvailableArray));
871
872 initialize(*this, Triple(), StandardNames);
873}
874
876 // Default to everything being available.
877 memset(AvailableArray, -1, sizeof(AvailableArray));
878
879 initialize(*this, T, StandardNames);
880}
881
883 : CustomNames(TLI.CustomNames), ShouldExtI32Param(TLI.ShouldExtI32Param),
884 ShouldExtI32Return(TLI.ShouldExtI32Return),
885 ShouldSignExtI32Param(TLI.ShouldSignExtI32Param),
886 ShouldSignExtI32Return(TLI.ShouldSignExtI32Return),
887 SizeOfInt(TLI.SizeOfInt) {
888 memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
889 VectorDescs = TLI.VectorDescs;
890 ScalarDescs = TLI.ScalarDescs;
891}
892
894 : CustomNames(std::move(TLI.CustomNames)),
895 ShouldExtI32Param(TLI.ShouldExtI32Param),
896 ShouldExtI32Return(TLI.ShouldExtI32Return),
897 ShouldSignExtI32Param(TLI.ShouldSignExtI32Param),
898 ShouldSignExtI32Return(TLI.ShouldSignExtI32Return),
899 SizeOfInt(TLI.SizeOfInt) {
900 std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
901 AvailableArray);
902 VectorDescs = TLI.VectorDescs;
903 ScalarDescs = TLI.ScalarDescs;
904}
905
907 CustomNames = TLI.CustomNames;
908 ShouldExtI32Param = TLI.ShouldExtI32Param;
909 ShouldExtI32Return = TLI.ShouldExtI32Return;
910 ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
911 ShouldSignExtI32Return = TLI.ShouldSignExtI32Return;
912 SizeOfInt = TLI.SizeOfInt;
913 memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
914 return *this;
915}
916
918 CustomNames = std::move(TLI.CustomNames);
919 ShouldExtI32Param = TLI.ShouldExtI32Param;
920 ShouldExtI32Return = TLI.ShouldExtI32Return;
921 ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
922 ShouldSignExtI32Return = TLI.ShouldSignExtI32Return;
923 SizeOfInt = TLI.SizeOfInt;
924 std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
925 AvailableArray);
926 return *this;
927}
928
930 // Filter out empty names and names containing null bytes, those can't be in
931 // our table.
932 if (funcName.empty() || funcName.contains('\0'))
933 return StringRef();
934
935 // Check for \01 prefix that is used to mangle __asm declarations and
936 // strip it if present.
938}
939
941 funcName = sanitizeFunctionName(funcName);
942 if (funcName.empty())
943 return false;
944
945 const auto *Start = std::begin(StandardNames);
946 const auto *End = std::end(StandardNames);
947 const auto *I = std::lower_bound(Start, End, funcName);
948 if (I != End && *I == funcName) {
949 F = (LibFunc)(I - Start);
950 return true;
951 }
952 return false;
953}
954
955// Return true if ArgTy matches Ty.
956
957static bool matchType(FuncArgTypeID ArgTy, const Type *Ty, unsigned IntBits,
958 unsigned SizeTBits) {
959 switch (ArgTy) {
960 case Void:
961 return Ty->isVoidTy();
962 case Bool:
963 return Ty->isIntegerTy(8);
964 case Int16:
965 return Ty->isIntegerTy(16);
966 case Int32:
967 return Ty->isIntegerTy(32);
968 case Int:
969 return Ty->isIntegerTy(IntBits);
970 case IntPlus:
971 return Ty->isIntegerTy() && Ty->getPrimitiveSizeInBits() >= IntBits;
972 case IntX:
973 return Ty->isIntegerTy();
974 case Long:
975 // TODO: Figure out and use long size.
976 return Ty->isIntegerTy() && Ty->getPrimitiveSizeInBits() >= IntBits;
977 case Int64:
978 return Ty->isIntegerTy(64);
979 case LLong:
980 return Ty->isIntegerTy(64);
981 case SizeT:
982 case SSizeT:
983 return Ty->isIntegerTy(SizeTBits);
984 case Flt:
985 return Ty->isFloatTy();
986 case Dbl:
987 return Ty->isDoubleTy();
988 // TODO: Tighten this up.
989 case LDbl:
990 return Ty->isFloatingPointTy();
991 case Floating:
992 return Ty->isFloatingPointTy();
993 case Ptr:
994 return Ty->isPointerTy();
995 case Struct:
996 return Ty->isStructTy();
997 default:
998 break;
999 }
1000
1001 llvm_unreachable("Invalid type");
1002}
1003
1004bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
1005 LibFunc F,
1006 const Module &M) const {
1007 unsigned NumParams = FTy.getNumParams();
1008
1009 switch (F) {
1010 // Special handling for <complex.h> functions:
1011 case LibFunc_cabs:
1012 case LibFunc_cabsf:
1013 case LibFunc_cabsl: {
1014 Type *RetTy = FTy.getReturnType();
1015 if (!RetTy->isFloatingPointTy())
1016 return false;
1017
1018 Type *ParamTy = FTy.getParamType(0);
1019 // NOTE: These prototypes are target specific and currently support
1020 // "complex" passed as an array or discrete real & imaginary parameters.
1021 // Add other calling conventions to enable libcall optimizations.
1022 if (NumParams == 1)
1023 return (ParamTy->isArrayTy() && ParamTy->getArrayNumElements() == 2 &&
1024 ParamTy->getArrayElementType() == RetTy);
1025 else if (NumParams == 2)
1026 return ParamTy == RetTy && FTy.getParamType(1) == RetTy;
1027
1028 return false;
1029 }
1030 // Special handling for the sincospi functions that return either
1031 // a struct or vector:
1032 case LibFunc_sincospi_stret:
1033 case LibFunc_sincospif_stret: {
1034 if (NumParams != 1)
1035 return false;
1036
1037 Type *RetTy = FTy.getReturnType();
1038 Type *ParamTy = FTy.getParamType(0);
1039 if (auto *Ty = dyn_cast<StructType>(RetTy)) {
1040 if (Ty->getNumElements() != 2)
1041 return false;
1042 return (Ty->getElementType(0) == ParamTy &&
1043 Ty->getElementType(1) == ParamTy);
1044 }
1045
1046 if (auto *Ty = dyn_cast<FixedVectorType>(RetTy)) {
1047 if (Ty->getNumElements() != 2)
1048 return false;
1049 return Ty->getElementType() == ParamTy;
1050 }
1051
1052 return false;
1053 }
1054
1055 default:
1056 break;
1057 }
1058
1059 unsigned IntBits = getIntSize();
1060 unsigned SizeTBits = getSizeTSize(M);
1061 unsigned Idx = 0;
1062
1063 // Iterate over the type ids in the function prototype, matching each
1064 // against the function's type FTy, starting with its return type.
1065 // Return true if both match in number and kind, inclduing the ellipsis.
1066 Type *Ty = FTy.getReturnType(), *LastTy = Ty;
1067 const auto &ProtoTypes = Signatures[F];
1068 for (auto TyID : ProtoTypes) {
1069 if (Idx && TyID == Void)
1070 // Except in the first position where it designates the function's
1071 // return type Void ends the argument list.
1072 break;
1073
1074 if (TyID == Ellip) {
1075 // The ellipsis ends the protoype list but is not a part of FTy's
1076 // argument list. Except when it's last it must be followed by
1077 // Void.
1078 assert(Idx == ProtoTypes.size() - 1 || ProtoTypes[Idx + 1] == Void);
1079 return FTy.isFunctionVarArg();
1080 }
1081
1082 if (TyID == Same) {
1083 assert(Idx != 0 && "Type ID 'Same' must not be first!");
1084 if (Ty != LastTy)
1085 return false;
1086 } else {
1087 if (!Ty || !matchType(TyID, Ty, IntBits, SizeTBits))
1088 return false;
1089 LastTy = Ty;
1090 }
1091
1092 if (Idx == NumParams) {
1093 // There's at least one and at most two more type ids than there are
1094 // arguments in FTy's argument list.
1095 Ty = nullptr;
1096 ++Idx;
1097 continue;
1098 }
1099
1100 Ty = FTy.getParamType(Idx++);
1101 }
1102
1103 // Return success only if all entries on both lists have been processed
1104 // and the function is not a variadic one.
1105 return Idx == NumParams + 1 && !FTy.isFunctionVarArg();
1106}
1107
1109 LibFunc &F) const {
1110 // Intrinsics don't overlap w/libcalls; if our module has a large number of
1111 // intrinsics, this ends up being an interesting compile time win since we
1112 // avoid string normalization and comparison.
1113 if (FDecl.isIntrinsic()) return false;
1114
1115 const Module *M = FDecl.getParent();
1116 assert(M && "Expecting FDecl to be connected to a Module.");
1117
1118 return getLibFunc(FDecl.getName(), F) &&
1119 isValidProtoForLibFunc(*FDecl.getFunctionType(), F, *M);
1120}
1121
1123 memset(AvailableArray, 0, sizeof(AvailableArray));
1124}
1125
1126static bool compareByScalarFnName(const VecDesc &LHS, const VecDesc &RHS) {
1127 return LHS.ScalarFnName < RHS.ScalarFnName;
1128}
1129
1130static bool compareByVectorFnName(const VecDesc &LHS, const VecDesc &RHS) {
1131 return LHS.VectorFnName < RHS.VectorFnName;
1132}
1133
1134static bool compareWithScalarFnName(const VecDesc &LHS, StringRef S) {
1135 return LHS.ScalarFnName < S;
1136}
1137
1139 llvm::append_range(VectorDescs, Fns);
1140 llvm::sort(VectorDescs, compareByScalarFnName);
1141
1142 llvm::append_range(ScalarDescs, Fns);
1143 llvm::sort(ScalarDescs, compareByVectorFnName);
1144}
1145
1147 enum VectorLibrary VecLib, const llvm::Triple &TargetTriple) {
1148 switch (VecLib) {
1149 case Accelerate: {
1150 const VecDesc VecFuncs[] = {
1151 #define TLI_DEFINE_ACCELERATE_VECFUNCS
1152 #include "llvm/Analysis/VecFuncs.def"
1153 };
1154 addVectorizableFunctions(VecFuncs);
1155 break;
1156 }
1157 case DarwinLibSystemM: {
1158 const VecDesc VecFuncs[] = {
1159 #define TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS
1160 #include "llvm/Analysis/VecFuncs.def"
1161 };
1162 addVectorizableFunctions(VecFuncs);
1163 break;
1164 }
1165 case LIBMVEC_X86: {
1166 const VecDesc VecFuncs[] = {
1167 #define TLI_DEFINE_LIBMVEC_X86_VECFUNCS
1168 #include "llvm/Analysis/VecFuncs.def"
1169 };
1170 addVectorizableFunctions(VecFuncs);
1171 break;
1172 }
1173 case MASSV: {
1174 const VecDesc VecFuncs[] = {
1175 #define TLI_DEFINE_MASSV_VECFUNCS
1176 #include "llvm/Analysis/VecFuncs.def"
1177 };
1178 addVectorizableFunctions(VecFuncs);
1179 break;
1180 }
1181 case SVML: {
1182 const VecDesc VecFuncs[] = {
1183 #define TLI_DEFINE_SVML_VECFUNCS
1184 #include "llvm/Analysis/VecFuncs.def"
1185 };
1186 addVectorizableFunctions(VecFuncs);
1187 break;
1188 }
1189 case SLEEFGNUABI: {
1190 const VecDesc VecFuncs_VF2[] = {
1191#define TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS
1192#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF, /* MASK = */ false},
1193#include "llvm/Analysis/VecFuncs.def"
1194 };
1195 const VecDesc VecFuncs_VF4[] = {
1196#define TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS
1197#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF) {SCAL, VEC, VF, /* MASK = */ false},
1198#include "llvm/Analysis/VecFuncs.def"
1199 };
1200 const VecDesc VecFuncs_VFScalable[] = {
1201#define TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS
1202#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK) {SCAL, VEC, VF, MASK},
1203#include "llvm/Analysis/VecFuncs.def"
1204 };
1205
1206 switch (TargetTriple.getArch()) {
1207 default:
1208 break;
1211 addVectorizableFunctions(VecFuncs_VF2);
1212 addVectorizableFunctions(VecFuncs_VF4);
1213 addVectorizableFunctions(VecFuncs_VFScalable);
1214 break;
1215 }
1216 break;
1217 }
1218 case NoLibrary:
1219 break;
1220 }
1221}
1222
1224 funcName = sanitizeFunctionName(funcName);
1225 if (funcName.empty())
1226 return false;
1227
1228 std::vector<VecDesc>::const_iterator I =
1229 llvm::lower_bound(VectorDescs, funcName, compareWithScalarFnName);
1230 return I != VectorDescs.end() && StringRef(I->ScalarFnName) == funcName;
1231}
1232
1234 const ElementCount &VF,
1235 bool Masked) const {
1237 if (F.empty())
1238 return F;
1239 std::vector<VecDesc>::const_iterator I =
1241 while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == F) {
1242 if ((I->VectorizationFactor == VF) && (I->Masked == Masked))
1243 return I->VectorFnName;
1244 ++I;
1245 }
1246 return StringRef();
1247}
1248
1251 if (!BaselineInfoImpl)
1252 BaselineInfoImpl =
1253 TargetLibraryInfoImpl(Triple(F.getParent()->getTargetTriple()));
1254 return TargetLibraryInfo(*BaselineInfoImpl, &F);
1255}
1256
1258 if (auto *ShortWChar = cast_or_null<ConstantAsMetadata>(
1259 M.getModuleFlag("wchar_size")))
1260 return cast<ConstantInt>(ShortWChar->getValue())->getZExtValue();
1261 return 0;
1262}
1263
1265 // There is really no guarantee that sizeof(size_t) is equal to sizeof(int*).
1266 // If that isn't true then it should be possible to derive the SizeTTy from
1267 // the target triple here instead and do an early return.
1268
1269 // Historically LLVM assume that size_t has same size as intptr_t (hence
1270 // deriving the size from sizeof(int*) in address space zero). This should
1271 // work for most targets. For future consideration: DataLayout also implement
1272 // getIndexSizeInBits which might map better to size_t compared to
1273 // getPointerSizeInBits. Hard coding address space zero here might be
1274 // unfortunate as well. Maybe getDefaultGlobalsAddressSpace() or
1275 // getAllocaAddrSpace() is better.
1276 unsigned AddressSpace = 0;
1277 return M.getDataLayout().getPointerSizeInBits(AddressSpace);
1278}
1279
1283}
1284
1288}
1289
1291 const TargetLibraryInfoImpl &TLIImpl)
1292 : ImmutablePass(ID), TLA(TLIImpl) {
1294}
1295
1296AnalysisKey TargetLibraryAnalysis::Key;
1297
1298// Register the basic pass.
1300 "Target Library Information", false, true)
1302
1303void TargetLibraryInfoWrapperPass::anchor() {}
1304
1306 ElementCount &FixedVF,
1307 ElementCount &ScalableVF) const {
1308 ScalarF = sanitizeFunctionName(ScalarF);
1309 // Use '0' here because a type of the form <vscale x 1 x ElTy> is not the
1310 // same as a scalar.
1311 ScalableVF = ElementCount::getScalable(0);
1312 FixedVF = ElementCount::getFixed(1);
1313 if (ScalarF.empty())
1314 return;
1315
1316 std::vector<VecDesc>::const_iterator I =
1317 llvm::lower_bound(VectorDescs, ScalarF, compareWithScalarFnName);
1318 while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == ScalarF) {
1319 ElementCount *VF =
1320 I->VectorizationFactor.isScalable() ? &ScalableVF : &FixedVF;
1321 if (ElementCount::isKnownGT(I->VectorizationFactor, *VF))
1322 *VF = I->VectorizationFactor;
1323 ++I;
1324 }
1325}
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:678
This file contains the declarations for the subclasses of Constant, which represent the different fla...
return RetTy
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
bool End
Definition: ELF_riscv.cpp:464
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool hasSinCosPiStret(const Triple &T)
static StringRef sanitizeFunctionName(StringRef funcName)
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames)
Initialize the set of available library functions based on the specified target triple.
static bool matchType(FuncArgTypeID ArgTy, const Type *Ty, unsigned IntBits, unsigned SizeTBits)
static bool hasBcmp(const Triple &TT)
static cl::opt< TargetLibraryInfoImpl::VectorLibrary > ClVectorLibrary("vector-library", cl::Hidden, cl::desc("Vector functions library"), cl::init(TargetLibraryInfoImpl::NoLibrary), cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none", "No vector functions library"), clEnumValN(TargetLibraryInfoImpl::Accelerate, "Accelerate", "Accelerate framework"), clEnumValN(TargetLibraryInfoImpl::DarwinLibSystemM, "Darwin_libsystem_m", "Darwin libsystem_m"), clEnumValN(TargetLibraryInfoImpl::LIBMVEC_X86, "LIBMVEC-X86", "GLIBC Vector Math library"), clEnumValN(TargetLibraryInfoImpl::MASSV, "MASSV", "IBM MASS vector library"), clEnumValN(TargetLibraryInfoImpl::SVML, "SVML", "Intel SVML library"), clEnumValN(TargetLibraryInfoImpl::SLEEFGNUABI, "sleefgnuabi", "SIMD Library for Evaluating Elementary Functions")))
static bool compareByScalarFnName(const VecDesc &LHS, const VecDesc &RHS)
static bool compareByVectorFnName(const VecDesc &LHS, const VecDesc &RHS)
static const FuncProtoTy Signatures[]
static bool isCallingConvCCompatible(CallingConv::ID CC, StringRef TT, FunctionType *FuncTy)
FuncArgTypeID
@ IntPlus
@ Floating
@ Struct
@ SSizeT
std::array< FuncArgTypeID, 8 > FuncProtoTy
static bool compareWithScalarFnName(const VecDesc &LHS, StringRef S)
Value * RHS
Value * LHS
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1190
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1471
FunctionType * getFunctionType() const
Definition: InstrTypes.h:1270
static constexpr ElementCount getScalable(ScalarTy MinVal)
Definition: TypeSize.h:294
static constexpr ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:291
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:174
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:209
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:562
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:282
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:70
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:258
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition: StringRef.h:857
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
Definition: StringRef.h:428
TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &)
Implementation of the target library information.
void setShouldExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext or zeroext attributes if they...
void setShouldExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext or zeroext attributes if they ...
unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
void getWidestVF(StringRef ScalarF, ElementCount &FixedVF, ElementCount &Scalable) const
Returns the largest vectorization factor used in the list of vector functions.
bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const
Return true if the function F has a vector equivalent with vectorization factor VF.
void setShouldSignExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext attribute if they correspond ...
void setAvailableWithName(LibFunc F, StringRef Name)
Forces a function to be marked as available and provide an alternate name that must be used.
unsigned getIntSize() const
Get size of a C-level int or unsigned int, in bits.
void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib, const llvm::Triple &TargetTriple)
Calls addVectorizableFunctions with a known preset of functions for the given vector library.
void setIntSize(unsigned Bits)
Initialize the C-level size of an integer.
unsigned getSizeTSize(const Module &M) const
Returns the size of the size_t type in bits.
void addVectorizableFunctions(ArrayRef< VecDesc > Fns)
Add a set of scalar -> vector mappings, queryable via getVectorizedFunction and getScalarizedFunction...
static bool isCallingConvCCompatible(CallBase *CI)
Returns true if call site / callee has cdecl-compatible calling conventions.
void setShouldSignExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext attribute if they correspond t...
TargetLibraryInfoImpl & operator=(const TargetLibraryInfoImpl &TLI)
void disableAllFunctions()
Disables all builtins.
VectorLibrary
List of known vector-functions libraries.
void setUnavailable(LibFunc F)
Forces a function to be marked as unavailable.
StringRef getVectorizedFunction(StringRef F, const ElementCount &VF, bool Masked) const
Return the name of the equivalent of F, vectorized with factor VF.
void setAvailable(LibFunc F)
Forces a function to be marked as available.
Provides information about what library functions are available for the current target.
static void initExtensionsForTriple(bool &ShouldExtI32Param, bool &ShouldExtI32Return, bool &ShouldSignExtI32Param, bool &ShouldSignExtI32Return, const Triple &T)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
@ Emscripten
Definition: Triple.h:225
@ aarch64_be
Definition: Triple.h:52
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:357
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:253
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:256
Type * getArrayElementType() const
Definition: Type.h:404
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:154
uint64_t getArrayNumElements() const
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:250
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:157
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition: Type.h:185
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:229
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:140
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:31
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition: TypeSize.h:205
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ ARM_APCS
ARM Procedure Calling Standard (obsolete, but still used on some targets).
Definition: CallingConv.h:104
@ ARM_AAPCS
ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:108
@ ARM_AAPCS_VFP
Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:111
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:703
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:445
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AddressSpace
Definition: NVPTXBaseInfo.h:21
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:2129
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1744
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1999
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:2038
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1946
void initializeTargetLibraryInfoWrapperPassPass(PassRegistry &)
Definition: BitVector.h:858
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
Describes a possible vectorization of a function.