LLVM 22.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
13#include "llvm/Analysis/TargetLibraryInfo.h"
14#include "llvm/ADT/DenseMap.h"
15#include "llvm/ADT/SmallString.h"
16#include "llvm/IR/Constants.h"
17#include "llvm/IR/Module.h"
18#include "llvm/IR/SystemLibraries.h"
19#include "llvm/InitializePasses.h"
20#include "llvm/TargetParser/Triple.h"
21using namespace llvm;
22
23StringLiteral const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
24 {
25#define TLI_DEFINE_STRING
26#include "llvm/Analysis/TargetLibraryInfo.def"
27};
28
29std::string VecDesc::getVectorFunctionABIVariantString() const {
30 assert(!VectorFnName.empty() && "Vector function name must not be empty.");
31 SmallString<256> Buffer;
32 llvm::raw_svector_ostream Out(Buffer);
33 Out << VABIPrefix << "_" << ScalarFnName << "(" << VectorFnName << ")";
34 return std::string(Out.str());
35}
36
37// Recognized types of library function arguments and return types.
38enum FuncArgTypeID : char {
39 Void = 0, // Must be zero.
40 Bool, // 8 bits on all targets
41 Int16,
42 Int32,
43 Int,
44 IntPlus, // Int or bigger.
45 Long, // Either 32 or 64 bits.
46 IntX, // Any integer type.
47 Int64,
48 LLong, // 64 bits on all targets.
49 SizeT, // size_t.
50 SSizeT, // POSIX ssize_t.
51 Flt, // IEEE float.
52 Dbl, // IEEE double.
53 LDbl, // Any floating type (TODO: tighten this up).
54 Floating, // Any floating type.
55 Ptr, // Any pointer type.
56 Struct, // Any struct type.
57 Ellip, // The ellipsis (...).
58 Same, // Same argument type as the previous one.
59};
60
61typedef std::array<FuncArgTypeID, 8> FuncProtoTy;
62
63static const FuncProtoTy Signatures[] = {
64#define TLI_DEFINE_SIG
65#include "llvm/Analysis/TargetLibraryInfo.def"
66};
67
68static_assert(sizeof Signatures / sizeof *Signatures == LibFunc::NumLibFuncs,
69 "Missing library function signatures");
70
71static bool hasSinCosPiStret(const Triple &T) {
72 // Only Darwin variants have _stret versions of combined trig functions.
73 if (!T.isOSDarwin())
74 return false;
75
76 // The ABI is rather complicated on x86, so don't do anything special there.
77 if (T.getArch() == Triple::x86)
78 return false;
79
80 if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9))
81 return false;
82
83 if (T.isiOS() && T.isOSVersionLT(7, 0))
84 return false;
85
86 return true;
87}
88
89static bool hasBcmp(const Triple &TT) {
90 // Posix removed support from bcmp() in 2001, but the glibc and several
91 // implementations of the libc still have it.
92 if (TT.isOSLinux())
93 return TT.isGNUEnvironment() || TT.isMusl();
94 // Both NetBSD and OpenBSD are planning to remove the function. Windows does
95 // not have it.
96 return TT.isOSFreeBSD() || TT.isOSSolaris();
97}
98
99static bool isCallingConvCCompatible(CallingConv::ID CC, const Triple &TT,
100 FunctionType *FuncTy) {
101 switch (CC) {
102 default:
103 return false;
104 case llvm::CallingConv::C:
105 return true;
106 case llvm::CallingConv::ARM_APCS:
107 case llvm::CallingConv::ARM_AAPCS:
108 case llvm::CallingConv::ARM_AAPCS_VFP: {
109
110 // The iOS ABI diverges from the standard in some cases, so for now don't
111 // try to simplify those calls.
112 if (TT.isiOS())
113 return false;
114
115 if (!FuncTy->getReturnType()->isPointerTy() &&
116 !FuncTy->getReturnType()->isIntegerTy() &&
117 !FuncTy->getReturnType()->isVoidTy())
118 return false;
119
120 for (auto *Param : FuncTy->params()) {
121 if (!Param->isPointerTy() && !Param->isIntegerTy())
122 return false;
123 }
124 return true;
125 }
126 }
127 return false;
128}
129
130bool TargetLibraryInfoImpl::isCallingConvCCompatible(CallBase *CI) {
131 return ::isCallingConvCCompatible(CI->getCallingConv(),
132 CI->getModule()->getTargetTriple(),
133 CI->getFunctionType());
134}
135
136bool TargetLibraryInfoImpl::isCallingConvCCompatible(Function *F) {
137 return ::isCallingConvCCompatible(F->getCallingConv(),
138 F->getParent()->getTargetTriple(),
139 F->getFunctionType());
140}
141
142static void initializeBase(TargetLibraryInfoImpl &TLI, const Triple &T) {
143 bool ShouldExtI32Param, ShouldExtI32Return;
144 bool ShouldSignExtI32Param, ShouldSignExtI32Return;
145 TargetLibraryInfo::initExtensionsForTriple(
146 ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param,
147 ShouldSignExtI32Return, T);
148 TLI.setShouldExtI32Param(ShouldExtI32Param);
149 TLI.setShouldExtI32Return(ShouldExtI32Return);
150 TLI.setShouldSignExtI32Param(ShouldSignExtI32Param);
151 TLI.setShouldSignExtI32Return(ShouldSignExtI32Return);
152
153 // Let's assume by default that the size of int is 32 bits, unless the target
154 // is a 16-bit architecture because then it most likely is 16 bits. If that
155 // isn't true for a target those defaults should be overridden below.
156 TLI.setIntSize(T.isArch16Bit() ? 16 : 32);
157}
158
159/// Initialize the set of available library functions based on the specified
160/// target triple. This should be carefully written so that a missing target
161/// triple gets a sane set of defaults.
162static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T,
163 ArrayRef<StringLiteral> StandardNames,
164 VectorLibrary VecLib) {
165 // Set IO unlocked variants as unavailable
166 // Set them as available per system below
167 TLI.setUnavailable(LibFunc_getc_unlocked);
168 TLI.setUnavailable(LibFunc_getchar_unlocked);
169 TLI.setUnavailable(LibFunc_putc_unlocked);
170 TLI.setUnavailable(LibFunc_putchar_unlocked);
171 TLI.setUnavailable(LibFunc_fputc_unlocked);
172 TLI.setUnavailable(LibFunc_fgetc_unlocked);
173 TLI.setUnavailable(LibFunc_fread_unlocked);
174 TLI.setUnavailable(LibFunc_fwrite_unlocked);
175 TLI.setUnavailable(LibFunc_fputs_unlocked);
176 TLI.setUnavailable(LibFunc_fgets_unlocked);
177
178 // There is really no runtime library on AMDGPU, apart from
179 // __kmpc_alloc/free_shared.
180 if (T.isAMDGPU()) {
181 TLI.disableAllFunctions();
182 TLI.setAvailable(llvm::LibFunc___kmpc_alloc_shared);
183 TLI.setAvailable(llvm::LibFunc___kmpc_free_shared);
184 return;
185 }
186
187 // DXIL does not support libcalls, and disabling them here prevents a number
188 // of passes from introducing libcalls into DXIL which would otherwise
189 // complicate lowering/legalization
190 if (T.isDXIL()) {
191 TLI.disableAllFunctions();
192 return;
193 }
194
195 // memset_pattern{4,8,16} is only available on iOS 3.0 and Mac OS X 10.5 and
196 // later. All versions of watchOS support it.
197 if (T.isMacOSX()) {
198 // available IO unlocked variants on Mac OS X
199 TLI.setAvailable(LibFunc_getc_unlocked);
200 TLI.setAvailable(LibFunc_getchar_unlocked);
201 TLI.setAvailable(LibFunc_putc_unlocked);
202 TLI.setAvailable(LibFunc_putchar_unlocked);
203 TLI.setUnavailable(LibFunc_memrchr);
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_hypotf);
291 TLI.setUnavailable(LibFunc_log10f);
292 TLI.setUnavailable(LibFunc_logf);
293 TLI.setUnavailable(LibFunc_modff);
294 TLI.setUnavailable(LibFunc_powf);
295 TLI.setUnavailable(LibFunc_remainderf);
296 TLI.setUnavailable(LibFunc_remquof);
297 TLI.setUnavailable(LibFunc_fdimf);
298 TLI.setUnavailable(LibFunc_sinf);
299 TLI.setUnavailable(LibFunc_sinhf);
300 TLI.setUnavailable(LibFunc_sqrtf);
301 TLI.setUnavailable(LibFunc_tanf);
302 TLI.setUnavailable(LibFunc_tanhf);
303 }
304 if (!isARM)
305 TLI.setUnavailable(LibFunc_fabsf);
306 TLI.setUnavailable(LibFunc_frexpf);
307 TLI.setUnavailable(LibFunc_ldexpf);
308
309 // Win32 does not support long double C89 math functions.
310 TLI.setUnavailable(LibFunc_acosl);
311 TLI.setUnavailable(LibFunc_asinl);
312 TLI.setUnavailable(LibFunc_atan2l);
313 TLI.setUnavailable(LibFunc_atanl);
314 TLI.setUnavailable(LibFunc_ceill);
315 TLI.setUnavailable(LibFunc_cosl);
316 TLI.setUnavailable(LibFunc_coshl);
317 TLI.setUnavailable(LibFunc_expl);
318 TLI.setUnavailable(LibFunc_fabsl);
319 TLI.setUnavailable(LibFunc_floorl);
320 TLI.setUnavailable(LibFunc_fmodl);
321 TLI.setUnavailable(LibFunc_frexpl);
322 TLI.setUnavailable(LibFunc_hypotl);
323 TLI.setUnavailable(LibFunc_ldexpl);
324 TLI.setUnavailable(LibFunc_log10l);
325 TLI.setUnavailable(LibFunc_logl);
326 TLI.setUnavailable(LibFunc_modfl);
327 TLI.setUnavailable(LibFunc_powl);
328 TLI.setUnavailable(LibFunc_remainderl);
329 TLI.setUnavailable(LibFunc_remquol);
330 TLI.setUnavailable(LibFunc_fdiml);
331 TLI.setUnavailable(LibFunc_sinl);
332 TLI.setUnavailable(LibFunc_sinhl);
333 TLI.setUnavailable(LibFunc_sqrtl);
334 TLI.setUnavailable(LibFunc_tanl);
335 TLI.setUnavailable(LibFunc_tanhl);
336
337 // Win32 does not fully support C99 math functions.
338 if (!hasPartialC99) {
339 TLI.setUnavailable(LibFunc_acosh);
340 TLI.setUnavailable(LibFunc_acoshf);
341 TLI.setUnavailable(LibFunc_asinh);
342 TLI.setUnavailable(LibFunc_asinhf);
343 TLI.setUnavailable(LibFunc_atanh);
344 TLI.setUnavailable(LibFunc_atanhf);
345 TLI.setAvailableWithName(LibFunc_cabs, "_cabs");
346 TLI.setUnavailable(LibFunc_cabsf);
347 TLI.setUnavailable(LibFunc_cbrt);
348 TLI.setUnavailable(LibFunc_cbrtf);
349 TLI.setAvailableWithName(LibFunc_copysign, "_copysign");
350 TLI.setAvailableWithName(LibFunc_copysignf, "_copysignf");
351 TLI.setUnavailable(LibFunc_exp2);
352 TLI.setUnavailable(LibFunc_exp2f);
353 TLI.setUnavailable(LibFunc_expm1);
354 TLI.setUnavailable(LibFunc_expm1f);
355 TLI.setUnavailable(LibFunc_fmax);
356 TLI.setUnavailable(LibFunc_fmaxf);
357 TLI.setUnavailable(LibFunc_fmin);
358 TLI.setUnavailable(LibFunc_fminf);
359 TLI.setUnavailable(LibFunc_log1p);
360 TLI.setUnavailable(LibFunc_log1pf);
361 TLI.setUnavailable(LibFunc_log2);
362 TLI.setUnavailable(LibFunc_log2f);
363 TLI.setAvailableWithName(LibFunc_logb, "_logb");
364 TLI.setUnavailable(LibFunc_ilogb);
365 TLI.setUnavailable(LibFunc_ilogbf);
366 if (hasPartialFloat)
367 TLI.setAvailableWithName(LibFunc_logbf, "_logbf");
368 else
369 TLI.setUnavailable(LibFunc_logbf);
370 TLI.setUnavailable(LibFunc_nextafter);
371 TLI.setUnavailable(LibFunc_nextafterf);
372 TLI.setUnavailable(LibFunc_nexttoward);
373 TLI.setUnavailable(LibFunc_nexttowardf);
374 TLI.setUnavailable(LibFunc_rint);
375 TLI.setUnavailable(LibFunc_rintf);
376 TLI.setUnavailable(LibFunc_round);
377 TLI.setUnavailable(LibFunc_roundf);
378 TLI.setUnavailable(LibFunc_scalbln);
379 TLI.setUnavailable(LibFunc_scalblnf);
380 TLI.setUnavailable(LibFunc_scalblnl);
381 TLI.setUnavailable(LibFunc_scalbn);
382 TLI.setUnavailable(LibFunc_scalbnf);
383 TLI.setUnavailable(LibFunc_scalbnl);
384 TLI.setUnavailable(LibFunc_trunc);
385 TLI.setUnavailable(LibFunc_truncf);
386 }
387
388 // Win32 does not support long double C99 math functions.
389 TLI.setUnavailable(LibFunc_acoshl);
390 TLI.setUnavailable(LibFunc_asinhl);
391 TLI.setUnavailable(LibFunc_atanhl);
392 TLI.setUnavailable(LibFunc_cabsl);
393 TLI.setUnavailable(LibFunc_cbrtl);
394 TLI.setUnavailable(LibFunc_copysignl);
395 TLI.setUnavailable(LibFunc_exp2l);
396 TLI.setUnavailable(LibFunc_expm1l);
397 TLI.setUnavailable(LibFunc_fmaxl);
398 TLI.setUnavailable(LibFunc_fminl);
399 TLI.setUnavailable(LibFunc_log1pl);
400 TLI.setUnavailable(LibFunc_log2l);
401 TLI.setUnavailable(LibFunc_logbl);
402 TLI.setUnavailable(LibFunc_ilogbl);
403 TLI.setUnavailable(LibFunc_nearbyintl);
404 TLI.setUnavailable(LibFunc_nextafterl);
405 TLI.setUnavailable(LibFunc_nexttowardl);
406 TLI.setUnavailable(LibFunc_rintl);
407 TLI.setUnavailable(LibFunc_roundl);
408 TLI.setUnavailable(LibFunc_scalblnl);
409 TLI.setUnavailable(LibFunc_scalbnl);
410 TLI.setUnavailable(LibFunc_truncl);
411
412 // Win32 does not support these functions, but
413 // they are generally available on POSIX-compliant systems.
414 TLI.setUnavailable(LibFunc_access);
415 TLI.setUnavailable(LibFunc_chmod);
416 TLI.setUnavailable(LibFunc_closedir);
417 TLI.setUnavailable(LibFunc_fdopen);
418 TLI.setUnavailable(LibFunc_fileno);
419 TLI.setUnavailable(LibFunc_fseeko);
420 TLI.setUnavailable(LibFunc_fstat);
421 TLI.setUnavailable(LibFunc_ftello);
422 TLI.setUnavailable(LibFunc_gettimeofday);
423 TLI.setUnavailable(LibFunc_memccpy);
424 TLI.setUnavailable(LibFunc_mkdir);
425 TLI.setUnavailable(LibFunc_open);
426 TLI.setUnavailable(LibFunc_opendir);
427 TLI.setUnavailable(LibFunc_pclose);
428 TLI.setUnavailable(LibFunc_popen);
429 TLI.setUnavailable(LibFunc_read);
430 TLI.setUnavailable(LibFunc_rmdir);
431 TLI.setUnavailable(LibFunc_stat);
432 TLI.setUnavailable(LibFunc_strcasecmp);
433 TLI.setUnavailable(LibFunc_strncasecmp);
434 TLI.setUnavailable(LibFunc_unlink);
435 TLI.setUnavailable(LibFunc_utime);
436 TLI.setUnavailable(LibFunc_write);
437 }
438
439 if (T.isOSWindows() && !T.isWindowsCygwinEnvironment()) {
440 // These functions aren't available in either MSVC or MinGW environments.
441 TLI.setUnavailable(LibFunc_bcmp);
442 TLI.setUnavailable(LibFunc_bcopy);
443 TLI.setUnavailable(LibFunc_bzero);
444 TLI.setUnavailable(LibFunc_chown);
445 TLI.setUnavailable(LibFunc_ctermid);
446 TLI.setUnavailable(LibFunc_ffs);
447 TLI.setUnavailable(LibFunc_flockfile);
448 TLI.setUnavailable(LibFunc_fstatvfs);
449 TLI.setUnavailable(LibFunc_ftrylockfile);
450 TLI.setUnavailable(LibFunc_funlockfile);
451 TLI.setUnavailable(LibFunc_getitimer);
452 TLI.setUnavailable(LibFunc_getlogin_r);
453 TLI.setUnavailable(LibFunc_getpwnam);
454 TLI.setUnavailable(LibFunc_htonl);
455 TLI.setUnavailable(LibFunc_htons);
456 TLI.setUnavailable(LibFunc_lchown);
457 TLI.setUnavailable(LibFunc_lstat);
458 TLI.setUnavailable(LibFunc_memrchr);
459 TLI.setUnavailable(LibFunc_ntohl);
460 TLI.setUnavailable(LibFunc_ntohs);
461 TLI.setUnavailable(LibFunc_pread);
462 TLI.setUnavailable(LibFunc_pwrite);
463 TLI.setUnavailable(LibFunc_readlink);
464 TLI.setUnavailable(LibFunc_realpath);
465 TLI.setUnavailable(LibFunc_setitimer);
466 TLI.setUnavailable(LibFunc_statvfs);
467 TLI.setUnavailable(LibFunc_stpcpy);
468 TLI.setUnavailable(LibFunc_stpncpy);
469 TLI.setUnavailable(LibFunc_times);
470 TLI.setUnavailable(LibFunc_uname);
471 TLI.setUnavailable(LibFunc_unsetenv);
472 TLI.setUnavailable(LibFunc_utimes);
473
474 // MinGW does have ldexpf, but it is a plain wrapper over regular ldexp.
475 // Therefore it's not beneficial to transform code to use it, i.e.
476 // just pretend that the function is not available.
477 TLI.setUnavailable(LibFunc_ldexpf);
478 }
479
480 // Pick just one set of new/delete variants.
481 if (T.isOSMSVCRT()) {
482 // MSVC, doesn't have the Itanium new/delete.
483 TLI.setUnavailable(LibFunc_ZdaPv);
484 TLI.setUnavailable(LibFunc_ZdaPvRKSt9nothrow_t);
485 TLI.setUnavailable(LibFunc_ZdaPvSt11align_val_t);
486 TLI.setUnavailable(LibFunc_ZdaPvSt11align_val_tRKSt9nothrow_t);
487 TLI.setUnavailable(LibFunc_ZdaPvj);
488 TLI.setUnavailable(LibFunc_ZdaPvjSt11align_val_t);
489 TLI.setUnavailable(LibFunc_ZdaPvm);
490 TLI.setUnavailable(LibFunc_ZdaPvmSt11align_val_t);
491 TLI.setUnavailable(LibFunc_ZdlPv);
492 TLI.setUnavailable(LibFunc_ZdlPvRKSt9nothrow_t);
493 TLI.setUnavailable(LibFunc_ZdlPvSt11align_val_t);
494 TLI.setUnavailable(LibFunc_ZdlPvSt11align_val_tRKSt9nothrow_t);
495 TLI.setUnavailable(LibFunc_ZdlPvj);
496 TLI.setUnavailable(LibFunc_ZdlPvjSt11align_val_t);
497 TLI.setUnavailable(LibFunc_ZdlPvm);
498 TLI.setUnavailable(LibFunc_ZdlPvmSt11align_val_t);
499 TLI.setUnavailable(LibFunc_Znaj);
500 TLI.setUnavailable(LibFunc_ZnajRKSt9nothrow_t);
501 TLI.setUnavailable(LibFunc_ZnajSt11align_val_t);
502 TLI.setUnavailable(LibFunc_ZnajSt11align_val_tRKSt9nothrow_t);
503 TLI.setUnavailable(LibFunc_Znam);
504 TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t);
505 TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t);
506 TLI.setUnavailable(LibFunc_ZnamSt11align_val_t);
507 TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t);
508 TLI.setUnavailable(LibFunc_Znwj);
509 TLI.setUnavailable(LibFunc_ZnwjRKSt9nothrow_t);
510 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_t);
511 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t);
512 TLI.setUnavailable(LibFunc_Znwm);
513 TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t);
514 TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t);
515 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t);
516 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t);
517 TLI.setUnavailable(LibFunc_Znwm12__hot_cold_t);
518 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t12__hot_cold_t);
519 TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
520 TLI.setUnavailable(LibFunc_Znam12__hot_cold_t);
521 TLI.setUnavailable(LibFunc_ZnamSt11align_val_t12__hot_cold_t);
522 TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
523 TLI.setUnavailable(LibFunc_size_returning_new);
524 TLI.setUnavailable(LibFunc_size_returning_new_hot_cold);
525 TLI.setUnavailable(LibFunc_size_returning_new_aligned);
526 TLI.setUnavailable(LibFunc_size_returning_new_aligned_hot_cold);
527 } else {
528 // Not MSVC, assume it's Itanium.
529 TLI.setUnavailable(LibFunc_msvc_new_int);
530 TLI.setUnavailable(LibFunc_msvc_new_int_nothrow);
531 TLI.setUnavailable(LibFunc_msvc_new_longlong);
532 TLI.setUnavailable(LibFunc_msvc_new_longlong_nothrow);
533 TLI.setUnavailable(LibFunc_msvc_delete_ptr32);
534 TLI.setUnavailable(LibFunc_msvc_delete_ptr32_nothrow);
535 TLI.setUnavailable(LibFunc_msvc_delete_ptr32_int);
536 TLI.setUnavailable(LibFunc_msvc_delete_ptr64);
537 TLI.setUnavailable(LibFunc_msvc_delete_ptr64_nothrow);
538 TLI.setUnavailable(LibFunc_msvc_delete_ptr64_longlong);
539 TLI.setUnavailable(LibFunc_msvc_new_array_int);
540 TLI.setUnavailable(LibFunc_msvc_new_array_int_nothrow);
541 TLI.setUnavailable(LibFunc_msvc_new_array_longlong);
542 TLI.setUnavailable(LibFunc_msvc_new_array_longlong_nothrow);
543 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32);
544 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32_nothrow);
545 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr32_int);
546 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64);
547 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64_nothrow);
548 TLI.setUnavailable(LibFunc_msvc_delete_array_ptr64_longlong);
549 }
550
551 switch (T.getOS()) {
552 case Triple::MacOSX:
553 // exp10 and exp10f are not available on OS X until 10.9 and iOS until 7.0
554 // and their names are __exp10 and __exp10f. exp10l is not available on
555 // OS X or iOS.
556 TLI.setUnavailable(LibFunc_exp10l);
557 if (T.isMacOSXVersionLT(10, 9)) {
558 TLI.setUnavailable(LibFunc_exp10);
559 TLI.setUnavailable(LibFunc_exp10f);
560 } else {
561 TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
562 TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
563 }
564 break;
565 case Triple::IOS:
566 case Triple::TvOS:
567 case Triple::WatchOS:
568 case Triple::XROS:
569 TLI.setUnavailable(LibFunc_exp10l);
570 if (!T.isWatchOS() &&
571 (T.isOSVersionLT(7, 0) || (T.isOSVersionLT(9, 0) && T.isX86()))) {
572 TLI.setUnavailable(LibFunc_exp10);
573 TLI.setUnavailable(LibFunc_exp10f);
574 } else {
575 TLI.setAvailableWithName(LibFunc_exp10, "__exp10");
576 TLI.setAvailableWithName(LibFunc_exp10f, "__exp10f");
577 }
578 break;
579 case Triple::Linux:
580 // exp10, exp10f, exp10l is available on Linux (GLIBC) but are extremely
581 // buggy prior to glibc version 2.18. Until this version is widely deployed
582 // or we have a reasonable detection strategy, we cannot use exp10 reliably
583 // on Linux.
584 //
585 // Fall through to disable all of them.
586 [[fallthrough]];
587 default:
588 TLI.setUnavailable(LibFunc_exp10);
589 TLI.setUnavailable(LibFunc_exp10f);
590 TLI.setUnavailable(LibFunc_exp10l);
591 }
592
593 // ffsl is available on at least Darwin, Mac OS X, iOS, FreeBSD, and
594 // Linux (GLIBC):
595 // http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/ffsl.3.html
596 // http://svn.freebsd.org/base/head/lib/libc/string/ffsl.c
597 // http://www.gnu.org/software/gnulib/manual/html_node/ffsl.html
598 switch (T.getOS()) {
599 case Triple::Darwin:
600 case Triple::MacOSX:
601 case Triple::IOS:
602 case Triple::TvOS:
603 case Triple::WatchOS:
604 case Triple::XROS:
605 case Triple::FreeBSD:
606 case Triple::Linux:
607 break;
608 default:
609 TLI.setUnavailable(LibFunc_ffsl);
610 }
611
612 // ffsll is available on at least FreeBSD and Linux (GLIBC):
613 // http://svn.freebsd.org/base/head/lib/libc/string/ffsll.c
614 // http://www.gnu.org/software/gnulib/manual/html_node/ffsll.html
615 switch (T.getOS()) {
616 case Triple::Darwin:
617 case Triple::MacOSX:
618 case Triple::IOS:
619 case Triple::TvOS:
620 case Triple::WatchOS:
621 case Triple::XROS:
622 case Triple::FreeBSD:
623 case Triple::Linux:
624 break;
625 default:
626 TLI.setUnavailable(LibFunc_ffsll);
627 }
628
629 // The following functions are available on at least FreeBSD:
630 // http://svn.freebsd.org/base/head/lib/libc/string/fls.c
631 // http://svn.freebsd.org/base/head/lib/libc/string/flsl.c
632 // http://svn.freebsd.org/base/head/lib/libc/string/flsll.c
633 if (!T.isOSFreeBSD()) {
634 TLI.setUnavailable(LibFunc_fls);
635 TLI.setUnavailable(LibFunc_flsl);
636 TLI.setUnavailable(LibFunc_flsll);
637 }
638
639 // The following functions are only available on GNU/Linux (using glibc).
640 // Linux variants without glibc (eg: bionic, musl) may have some subset.
641 if (!T.isOSLinux() || !T.isGNUEnvironment()) {
642 TLI.setUnavailable(LibFunc_dunder_strdup);
643 TLI.setUnavailable(LibFunc_dunder_strtok_r);
644 TLI.setUnavailable(LibFunc_dunder_isoc99_scanf);
645 TLI.setUnavailable(LibFunc_dunder_isoc99_sscanf);
646 TLI.setUnavailable(LibFunc_under_IO_getc);
647 TLI.setUnavailable(LibFunc_under_IO_putc);
648 // But, Android and musl have memalign.
649 if (!T.isAndroid() && !T.isMusl())
650 TLI.setUnavailable(LibFunc_memalign);
651 TLI.setUnavailable(LibFunc_fopen64);
652 TLI.setUnavailable(LibFunc_fseeko64);
653 TLI.setUnavailable(LibFunc_fstat64);
654 TLI.setUnavailable(LibFunc_fstatvfs64);
655 TLI.setUnavailable(LibFunc_ftello64);
656 TLI.setUnavailable(LibFunc_lstat64);
657 TLI.setUnavailable(LibFunc_open64);
658 TLI.setUnavailable(LibFunc_stat64);
659 TLI.setUnavailable(LibFunc_statvfs64);
660 TLI.setUnavailable(LibFunc_tmpfile64);
661
662 // Relaxed math functions are included in math-finite.h on Linux (GLIBC).
663 // Note that math-finite.h is no longer supported by top-of-tree GLIBC,
664 // so we keep these functions around just so that they're recognized by
665 // the ConstantFolder.
666 TLI.setUnavailable(LibFunc_acos_finite);
667 TLI.setUnavailable(LibFunc_acosf_finite);
668 TLI.setUnavailable(LibFunc_acosl_finite);
669 TLI.setUnavailable(LibFunc_acosh_finite);
670 TLI.setUnavailable(LibFunc_acoshf_finite);
671 TLI.setUnavailable(LibFunc_acoshl_finite);
672 TLI.setUnavailable(LibFunc_asin_finite);
673 TLI.setUnavailable(LibFunc_asinf_finite);
674 TLI.setUnavailable(LibFunc_asinl_finite);
675 TLI.setUnavailable(LibFunc_atan2_finite);
676 TLI.setUnavailable(LibFunc_atan2f_finite);
677 TLI.setUnavailable(LibFunc_atan2l_finite);
678 TLI.setUnavailable(LibFunc_atanh_finite);
679 TLI.setUnavailable(LibFunc_atanhf_finite);
680 TLI.setUnavailable(LibFunc_atanhl_finite);
681 TLI.setUnavailable(LibFunc_cosh_finite);
682 TLI.setUnavailable(LibFunc_coshf_finite);
683 TLI.setUnavailable(LibFunc_coshl_finite);
684 TLI.setUnavailable(LibFunc_exp10_finite);
685 TLI.setUnavailable(LibFunc_exp10f_finite);
686 TLI.setUnavailable(LibFunc_exp10l_finite);
687 TLI.setUnavailable(LibFunc_exp2_finite);
688 TLI.setUnavailable(LibFunc_exp2f_finite);
689 TLI.setUnavailable(LibFunc_exp2l_finite);
690 TLI.setUnavailable(LibFunc_exp_finite);
691 TLI.setUnavailable(LibFunc_expf_finite);
692 TLI.setUnavailable(LibFunc_expl_finite);
693 TLI.setUnavailable(LibFunc_log10_finite);
694 TLI.setUnavailable(LibFunc_log10f_finite);
695 TLI.setUnavailable(LibFunc_log10l_finite);
696 TLI.setUnavailable(LibFunc_log2_finite);
697 TLI.setUnavailable(LibFunc_log2f_finite);
698 TLI.setUnavailable(LibFunc_log2l_finite);
699 TLI.setUnavailable(LibFunc_log_finite);
700 TLI.setUnavailable(LibFunc_logf_finite);
701 TLI.setUnavailable(LibFunc_logl_finite);
702 TLI.setUnavailable(LibFunc_pow_finite);
703 TLI.setUnavailable(LibFunc_powf_finite);
704 TLI.setUnavailable(LibFunc_powl_finite);
705 TLI.setUnavailable(LibFunc_sinh_finite);
706 TLI.setUnavailable(LibFunc_sinhf_finite);
707 TLI.setUnavailable(LibFunc_sinhl_finite);
708 TLI.setUnavailable(LibFunc_sqrt_finite);
709 TLI.setUnavailable(LibFunc_sqrtf_finite);
710 TLI.setUnavailable(LibFunc_sqrtl_finite);
711 }
712
713 if ((T.isOSLinux() && T.isGNUEnvironment()) ||
714 (T.isAndroid() && !T.isAndroidVersionLT(28))) {
715 // available IO unlocked variants on GNU/Linux and Android P or later
716 TLI.setAvailable(LibFunc_getc_unlocked);
717 TLI.setAvailable(LibFunc_getchar_unlocked);
718 TLI.setAvailable(LibFunc_putc_unlocked);
719 TLI.setAvailable(LibFunc_putchar_unlocked);
720 TLI.setAvailable(LibFunc_fputc_unlocked);
721 TLI.setAvailable(LibFunc_fgetc_unlocked);
722 TLI.setAvailable(LibFunc_fread_unlocked);
723 TLI.setAvailable(LibFunc_fwrite_unlocked);
724 TLI.setAvailable(LibFunc_fputs_unlocked);
725 TLI.setAvailable(LibFunc_fgets_unlocked);
726 }
727
728 if (T.isPS()) {
729 // PS4/PS5 do have memalign.
730 TLI.setAvailable(LibFunc_memalign);
731
732 // PS4/PS5 do not have new/delete with "unsigned int" size parameter;
733 // they only have the "unsigned long" versions.
734 TLI.setUnavailable(LibFunc_ZdaPvj);
735 TLI.setUnavailable(LibFunc_ZdaPvjSt11align_val_t);
736 TLI.setUnavailable(LibFunc_ZdlPvj);
737 TLI.setUnavailable(LibFunc_ZdlPvjSt11align_val_t);
738 TLI.setUnavailable(LibFunc_Znaj);
739 TLI.setUnavailable(LibFunc_ZnajRKSt9nothrow_t);
740 TLI.setUnavailable(LibFunc_ZnajSt11align_val_t);
741 TLI.setUnavailable(LibFunc_ZnajSt11align_val_tRKSt9nothrow_t);
742 TLI.setUnavailable(LibFunc_Znwj);
743 TLI.setUnavailable(LibFunc_ZnwjRKSt9nothrow_t);
744 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_t);
745 TLI.setUnavailable(LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t);
746
747 // None of the *_chk functions.
748 TLI.setUnavailable(LibFunc_memccpy_chk);
749 TLI.setUnavailable(LibFunc_memcpy_chk);
750 TLI.setUnavailable(LibFunc_memmove_chk);
751 TLI.setUnavailable(LibFunc_mempcpy_chk);
752 TLI.setUnavailable(LibFunc_memset_chk);
753 TLI.setUnavailable(LibFunc_snprintf_chk);
754 TLI.setUnavailable(LibFunc_sprintf_chk);
755 TLI.setUnavailable(LibFunc_stpcpy_chk);
756 TLI.setUnavailable(LibFunc_stpncpy_chk);
757 TLI.setUnavailable(LibFunc_strcat_chk);
758 TLI.setUnavailable(LibFunc_strcpy_chk);
759 TLI.setUnavailable(LibFunc_strlcat_chk);
760 TLI.setUnavailable(LibFunc_strlcpy_chk);
761 TLI.setUnavailable(LibFunc_strlen_chk);
762 TLI.setUnavailable(LibFunc_strncat_chk);
763 TLI.setUnavailable(LibFunc_strncpy_chk);
764 TLI.setUnavailable(LibFunc_vsnprintf_chk);
765 TLI.setUnavailable(LibFunc_vsprintf_chk);
766
767 // Various Posix system functions.
768 TLI.setUnavailable(LibFunc_access);
769 TLI.setUnavailable(LibFunc_chmod);
770 TLI.setUnavailable(LibFunc_chown);
771 TLI.setUnavailable(LibFunc_closedir);
772 TLI.setUnavailable(LibFunc_ctermid);
773 TLI.setUnavailable(LibFunc_execl);
774 TLI.setUnavailable(LibFunc_execle);
775 TLI.setUnavailable(LibFunc_execlp);
776 TLI.setUnavailable(LibFunc_execv);
777 TLI.setUnavailable(LibFunc_execvP);
778 TLI.setUnavailable(LibFunc_execve);
779 TLI.setUnavailable(LibFunc_execvp);
780 TLI.setUnavailable(LibFunc_execvpe);
781 TLI.setUnavailable(LibFunc_fork);
782 TLI.setUnavailable(LibFunc_fstat);
783 TLI.setUnavailable(LibFunc_fstatvfs);
784 TLI.setUnavailable(LibFunc_getenv);
785 TLI.setUnavailable(LibFunc_getitimer);
786 TLI.setUnavailable(LibFunc_getlogin_r);
787 TLI.setUnavailable(LibFunc_getpwnam);
788 TLI.setUnavailable(LibFunc_gettimeofday);
789 TLI.setUnavailable(LibFunc_lchown);
790 TLI.setUnavailable(LibFunc_lstat);
791 TLI.setUnavailable(LibFunc_mkdir);
792 TLI.setUnavailable(LibFunc_open);
793 TLI.setUnavailable(LibFunc_opendir);
794 TLI.setUnavailable(LibFunc_pclose);
795 TLI.setUnavailable(LibFunc_popen);
796 TLI.setUnavailable(LibFunc_pread);
797 TLI.setUnavailable(LibFunc_pvalloc);
798 TLI.setUnavailable(LibFunc_pwrite);
799 TLI.setUnavailable(LibFunc_read);
800 TLI.setUnavailable(LibFunc_readlink);
801 TLI.setUnavailable(LibFunc_realpath);
802 TLI.setUnavailable(LibFunc_rename);
803 TLI.setUnavailable(LibFunc_rmdir);
804 TLI.setUnavailable(LibFunc_setitimer);
805 TLI.setUnavailable(LibFunc_stat);
806 TLI.setUnavailable(LibFunc_statvfs);
807 TLI.setUnavailable(LibFunc_system);
808 TLI.setUnavailable(LibFunc_times);
809 TLI.setUnavailable(LibFunc_tmpfile);
810 TLI.setUnavailable(LibFunc_unlink);
811 TLI.setUnavailable(LibFunc_uname);
812 TLI.setUnavailable(LibFunc_unsetenv);
813 TLI.setUnavailable(LibFunc_utime);
814 TLI.setUnavailable(LibFunc_utimes);
815 TLI.setUnavailable(LibFunc_valloc);
816 TLI.setUnavailable(LibFunc_write);
817
818 // Miscellaneous other functions not provided.
819 TLI.setUnavailable(LibFunc_atomic_load);
820 TLI.setUnavailable(LibFunc_atomic_store);
821 TLI.setUnavailable(LibFunc___kmpc_alloc_shared);
822 TLI.setUnavailable(LibFunc___kmpc_free_shared);
823 TLI.setUnavailable(LibFunc_dunder_strndup);
824 TLI.setUnavailable(LibFunc_bcmp);
825 TLI.setUnavailable(LibFunc_bcopy);
826 TLI.setUnavailable(LibFunc_bzero);
827 TLI.setUnavailable(LibFunc_cabs);
828 TLI.setUnavailable(LibFunc_cabsf);
829 TLI.setUnavailable(LibFunc_cabsl);
830 TLI.setUnavailable(LibFunc_ffs);
831 TLI.setUnavailable(LibFunc_flockfile);
832 TLI.setUnavailable(LibFunc_fseeko);
833 TLI.setUnavailable(LibFunc_ftello);
834 TLI.setUnavailable(LibFunc_ftrylockfile);
835 TLI.setUnavailable(LibFunc_funlockfile);
836 TLI.setUnavailable(LibFunc_htonl);
837 TLI.setUnavailable(LibFunc_htons);
838 TLI.setUnavailable(LibFunc_isascii);
839 TLI.setUnavailable(LibFunc_memccpy);
840 TLI.setUnavailable(LibFunc_mempcpy);
841 TLI.setUnavailable(LibFunc_memrchr);
842 TLI.setUnavailable(LibFunc_ntohl);
843 TLI.setUnavailable(LibFunc_ntohs);
844 TLI.setUnavailable(LibFunc_reallocarray);
845 TLI.setUnavailable(LibFunc_reallocf);
846 TLI.setUnavailable(LibFunc_roundeven);
847 TLI.setUnavailable(LibFunc_roundevenf);
848 TLI.setUnavailable(LibFunc_roundevenl);
849 TLI.setUnavailable(LibFunc_stpcpy);
850 TLI.setUnavailable(LibFunc_stpncpy);
851 TLI.setUnavailable(LibFunc_strlcat);
852 TLI.setUnavailable(LibFunc_strlcpy);
853 TLI.setUnavailable(LibFunc_strndup);
854 TLI.setUnavailable(LibFunc_strnlen);
855 TLI.setUnavailable(LibFunc_toascii);
856 }
857
858 if (T.isOSFreeBSD()) {
859 TLI.setAvailable(LibFunc_dunder_strtok_r);
860 TLI.setAvailable(LibFunc_memalign);
861 TLI.setAvailable(LibFunc_fputc_unlocked);
862 TLI.setAvailable(LibFunc_fputs_unlocked);
863 TLI.setAvailable(LibFunc_fread_unlocked);
864 TLI.setAvailable(LibFunc_fwrite_unlocked);
865 TLI.setAvailable(LibFunc_getc_unlocked);
866 TLI.setAvailable(LibFunc_getchar_unlocked);
867 TLI.setAvailable(LibFunc_putc_unlocked);
868 TLI.setAvailable(LibFunc_putchar_unlocked);
869
870 TLI.setUnavailable(LibFunc___kmpc_alloc_shared);
871 TLI.setUnavailable(LibFunc___kmpc_free_shared);
872 TLI.setUnavailable(LibFunc_dunder_strndup);
873 TLI.setUnavailable(LibFunc_memccpy_chk);
874 TLI.setUnavailable(LibFunc_strlen_chk);
875 TLI.setUnavailable(LibFunc_fmaximum_num);
876 TLI.setUnavailable(LibFunc_fmaximum_numf);
877 TLI.setUnavailable(LibFunc_fmaximum_numl);
878 TLI.setUnavailable(LibFunc_fminimum_num);
879 TLI.setUnavailable(LibFunc_fminimum_numf);
880 TLI.setUnavailable(LibFunc_fminimum_numl);
881 TLI.setUnavailable(LibFunc_roundeven);
882 TLI.setUnavailable(LibFunc_roundevenf);
883 TLI.setUnavailable(LibFunc_roundevenl);
884 }
885
886 // As currently implemented in clang, NVPTX code has no standard library to
887 // speak of. Headers provide a standard-ish library implementation, but many
888 // of the signatures are wrong -- for example, many libm functions are not
889 // extern "C".
890 //
891 // libdevice, an IR library provided by nvidia, is linked in by the front-end,
892 // but only used functions are provided to llvm. Moreover, most of the
893 // functions in libdevice don't map precisely to standard library functions.
894 //
895 // FIXME: Having no standard library prevents e.g. many fastmath
896 // optimizations, so this situation should be fixed.
897 if (T.isNVPTX()) {
898 TLI.disableAllFunctions();
899 TLI.setAvailable(LibFunc_nvvm_reflect);
900 TLI.setAvailable(llvm::LibFunc_malloc);
901 TLI.setAvailable(llvm::LibFunc_free);
902
903 // TODO: We could enable the following two according to [0] but we haven't
904 // done an evaluation wrt. the performance implications.
905 // [0]
906 // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#dynamic-global-memory-allocation-and-operations
907 //
908 // TLI.setAvailable(llvm::LibFunc_memcpy);
909 // TLI.setAvailable(llvm::LibFunc_memset);
910
911 TLI.setAvailable(llvm::LibFunc___kmpc_alloc_shared);
912 TLI.setAvailable(llvm::LibFunc___kmpc_free_shared);
913 } else {
914 TLI.setUnavailable(LibFunc_nvvm_reflect);
915 }
916
917 // These vec_malloc/free routines are only available on AIX.
918 if (!T.isOSAIX()) {
919 TLI.setUnavailable(LibFunc_vec_calloc);
920 TLI.setUnavailable(LibFunc_vec_malloc);
921 TLI.setUnavailable(LibFunc_vec_realloc);
922 TLI.setUnavailable(LibFunc_vec_free);
923 }
924
925 if (T.isOSAIX())
926 TLI.setUnavailable(LibFunc_memrchr);
927
928 TLI.addVectorizableFunctionsFromVecLib(VecLib, T);
929}
930
931/// Initialize the set of available library functions based on the specified
932/// target triple. This should be carefully written so that a missing target
933/// triple gets a sane set of defaults.
934static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
935 ArrayRef<StringLiteral> StandardNames,
936 VectorLibrary VecLib) {
937 initializeBase(TLI, T);
938 initializeLibCalls(TLI, T, StandardNames, VecLib);
939}
940
941TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T,
942 VectorLibrary VecLib) {
943 // Default to everything being available.
944 memset(AvailableArray, -1, sizeof(AvailableArray));
945
946 initialize(*this, T, StandardNames, VecLib);
947}
948
949TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)
950 : CustomNames(TLI.CustomNames), ShouldExtI32Param(TLI.ShouldExtI32Param),
951 ShouldExtI32Return(TLI.ShouldExtI32Return),
952 ShouldSignExtI32Param(TLI.ShouldSignExtI32Param),
953 ShouldSignExtI32Return(TLI.ShouldSignExtI32Return),
954 SizeOfInt(TLI.SizeOfInt) {
955 memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
956 VectorDescs = TLI.VectorDescs;
957 ScalarDescs = TLI.ScalarDescs;
958}
959
960TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
961 : CustomNames(std::move(TLI.CustomNames)),
962 ShouldExtI32Param(TLI.ShouldExtI32Param),
963 ShouldExtI32Return(TLI.ShouldExtI32Return),
964 ShouldSignExtI32Param(TLI.ShouldSignExtI32Param),
965 ShouldSignExtI32Return(TLI.ShouldSignExtI32Return),
966 SizeOfInt(TLI.SizeOfInt) {
967 std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
968 AvailableArray);
969 VectorDescs = TLI.VectorDescs;
970 ScalarDescs = TLI.ScalarDescs;
971}
972
973TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const TargetLibraryInfoImpl &TLI) {
974 CustomNames = TLI.CustomNames;
975 ShouldExtI32Param = TLI.ShouldExtI32Param;
976 ShouldExtI32Return = TLI.ShouldExtI32Return;
977 ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
978 ShouldSignExtI32Return = TLI.ShouldSignExtI32Return;
979 SizeOfInt = TLI.SizeOfInt;
980 memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
981 return *this;
982}
983
984TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) {
985 CustomNames = std::move(TLI.CustomNames);
986 ShouldExtI32Param = TLI.ShouldExtI32Param;
987 ShouldExtI32Return = TLI.ShouldExtI32Return;
988 ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
989 ShouldSignExtI32Return = TLI.ShouldSignExtI32Return;
990 SizeOfInt = TLI.SizeOfInt;
991 std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
992 AvailableArray);
993 return *this;
994}
995
996static StringRef sanitizeFunctionName(StringRef funcName) {
997 // Filter out empty names and names containing null bytes, those can't be in
998 // our table.
999 if (funcName.empty() || funcName.contains('\0'))
1000 return StringRef();
1001
1002 // Check for \01 prefix that is used to mangle __asm declarations and
1003 // strip it if present.
1004 return GlobalValue::dropLLVMManglingEscape(funcName);
1005}
1006
1007static DenseMap<StringRef, LibFunc>
1008buildIndexMap(ArrayRef<StringLiteral> StandardNames) {
1009 DenseMap<StringRef, LibFunc> Indices;
1010 unsigned Idx = 0;
1011 Indices.reserve(LibFunc::NumLibFuncs);
1012 for (const auto &Func : StandardNames)
1013 Indices[Func] = static_cast<LibFunc>(Idx++);
1014 return Indices;
1015}
1016
1017bool TargetLibraryInfoImpl::getLibFunc(StringRef funcName, LibFunc &F) const {
1018 funcName = sanitizeFunctionName(funcName);
1019 if (funcName.empty())
1020 return false;
1021
1022 static const DenseMap<StringRef, LibFunc> Indices =
1023 buildIndexMap(StandardNames);
1024
1025 if (auto Loc = Indices.find(funcName); Loc != Indices.end()) {
1026 F = Loc->second;
1027 return true;
1028 }
1029 return false;
1030}
1031
1032// Return true if ArgTy matches Ty.
1033
1034static bool matchType(FuncArgTypeID ArgTy, const Type *Ty, unsigned IntBits,
1035 unsigned SizeTBits) {
1036 switch (ArgTy) {
1037 case Void:
1038 return Ty->isVoidTy();
1039 case Bool:
1040 return Ty->isIntegerTy(8);
1041 case Int16:
1042 return Ty->isIntegerTy(16);
1043 case Int32:
1044 return Ty->isIntegerTy(32);
1045 case Int:
1046 return Ty->isIntegerTy(IntBits);
1047 case IntPlus:
1048 return Ty->isIntegerTy() && Ty->getPrimitiveSizeInBits() >= IntBits;
1049 case IntX:
1050 return Ty->isIntegerTy();
1051 case Long:
1052 // TODO: Figure out and use long size.
1053 return Ty->isIntegerTy() && Ty->getPrimitiveSizeInBits() >= IntBits;
1054 case Int64:
1055 return Ty->isIntegerTy(64);
1056 case LLong:
1057 return Ty->isIntegerTy(64);
1058 case SizeT:
1059 case SSizeT:
1060 return Ty->isIntegerTy(SizeTBits);
1061 case Flt:
1062 return Ty->isFloatTy();
1063 case Dbl:
1064 return Ty->isDoubleTy();
1065 // TODO: Tighten this up.
1066 case LDbl:
1067 return Ty->isFloatingPointTy();
1068 case Floating:
1069 return Ty->isFloatingPointTy();
1070 case Ptr:
1071 return Ty->isPointerTy();
1072 case Struct:
1073 return Ty->isStructTy();
1074 default:
1075 break;
1076 }
1077
1078 llvm_unreachable("Invalid type");
1079}
1080
1081static bool isValidProtoForSizeReturningNew(const FunctionType &FTy, LibFunc F,
1082 const Module &M,
1083 int SizeTSizeBits) {
1084 switch (F) {
1085 case LibFunc_size_returning_new: {
1086 if (FTy.getNumParams() != 1 ||
1087 !FTy.getParamType(0)->isIntegerTy(SizeTSizeBits)) {
1088 return false;
1089 }
1090 } break;
1091 case LibFunc_size_returning_new_hot_cold: {
1092 if (FTy.getNumParams() != 2 ||
1093 !FTy.getParamType(0)->isIntegerTy(SizeTSizeBits) ||
1094 !FTy.getParamType(1)->isIntegerTy(8)) {
1095 return false;
1096 }
1097 } break;
1098 case LibFunc_size_returning_new_aligned: {
1099 if (FTy.getNumParams() != 2 ||
1100 !FTy.getParamType(0)->isIntegerTy(SizeTSizeBits) ||
1101 !FTy.getParamType(1)->isIntegerTy(SizeTSizeBits)) {
1102 return false;
1103 }
1104 } break;
1105 case LibFunc_size_returning_new_aligned_hot_cold:
1106 if (FTy.getNumParams() != 3 ||
1107 !FTy.getParamType(0)->isIntegerTy(SizeTSizeBits) ||
1108 !FTy.getParamType(1)->isIntegerTy(SizeTSizeBits) ||
1109 !FTy.getParamType(2)->isIntegerTy(8)) {
1110 return false;
1111 }
1112 break;
1113 default:
1114 return false;
1115 }
1116
1117 auto &Context = M.getContext();
1118 PointerType *PtrTy = PointerType::get(Context, 0);
1119 StructType *SizedPtrTy = StructType::get(
1120 Context, {PtrTy, Type::getIntNTy(Context, SizeTSizeBits)});
1121 return FTy.getReturnType() == SizedPtrTy;
1122}
1123
1124bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
1125 LibFunc F,
1126 const Module &M) const {
1127 unsigned NumParams = FTy.getNumParams();
1128
1129 switch (F) {
1130 // Special handling for <complex.h> functions:
1131 case LibFunc_cabs:
1132 case LibFunc_cabsf:
1133 case LibFunc_cabsl: {
1134 Type *RetTy = FTy.getReturnType();
1135 if (!RetTy->isFloatingPointTy() || NumParams == 0)
1136 return false;
1137
1138 Type *ParamTy = FTy.getParamType(0);
1139 // NOTE: These prototypes are target specific and currently support
1140 // "complex" passed as an array or discrete real & imaginary parameters.
1141 // Add other calling conventions to enable libcall optimizations.
1142 if (NumParams == 1)
1143 return (ParamTy->isArrayTy() && ParamTy->getArrayNumElements() == 2 &&
1144 ParamTy->getArrayElementType() == RetTy);
1145 else if (NumParams == 2)
1146 return ParamTy == RetTy && FTy.getParamType(1) == RetTy;
1147
1148 return false;
1149 }
1150 // Special handling for the sincospi functions that return either
1151 // a struct or vector:
1152 case LibFunc_sincospi_stret:
1153 case LibFunc_sincospif_stret: {
1154 if (NumParams != 1)
1155 return false;
1156
1157 Type *RetTy = FTy.getReturnType();
1158 Type *ParamTy = FTy.getParamType(0);
1159 if (auto *Ty = dyn_cast<StructType>(RetTy)) {
1160 if (Ty->getNumElements() != 2)
1161 return false;
1162 return (Ty->getElementType(0) == ParamTy &&
1163 Ty->getElementType(1) == ParamTy);
1164 }
1165
1166 if (auto *Ty = dyn_cast<FixedVectorType>(RetTy)) {
1167 if (Ty->getNumElements() != 2)
1168 return false;
1169 return Ty->getElementType() == ParamTy;
1170 }
1171
1172 return false;
1173 }
1174 // Special handling of __size_returning_new functions that return a struct
1175 // of type {void*, size_t}.
1176 case LibFunc_size_returning_new:
1177 case LibFunc_size_returning_new_hot_cold:
1178 case LibFunc_size_returning_new_aligned:
1179 case LibFunc_size_returning_new_aligned_hot_cold:
1180 return isValidProtoForSizeReturningNew(FTy, F, M, getSizeTSize(M));
1181 default:
1182 break;
1183 }
1184
1185 unsigned IntBits = getIntSize();
1186 unsigned SizeTBits = getSizeTSize(M);
1187 unsigned Idx = 0;
1188
1189 // Iterate over the type ids in the function prototype, matching each
1190 // against the function's type FTy, starting with its return type.
1191 // Return true if both match in number and kind, inclduing the ellipsis.
1192 Type *Ty = FTy.getReturnType(), *LastTy = Ty;
1193 const auto &ProtoTypes = Signatures[F];
1194 for (auto TyID : ProtoTypes) {
1195 if (Idx && TyID == Void)
1196 // Except in the first position where it designates the function's
1197 // return type Void ends the argument list.
1198 break;
1199
1200 if (TyID == Ellip) {
1201 // The ellipsis ends the protoype list but is not a part of FTy's
1202 // argument list. Except when it's last it must be followed by
1203 // Void.
1204 assert(Idx == ProtoTypes.size() - 1 || ProtoTypes[Idx + 1] == Void);
1205 return FTy.isFunctionVarArg();
1206 }
1207
1208 if (TyID == Same) {
1209 assert(Idx != 0 && "Type ID 'Same' must not be first!");
1210 if (Ty != LastTy)
1211 return false;
1212 } else {
1213 if (!Ty || !matchType(TyID, Ty, IntBits, SizeTBits))
1214 return false;
1215 LastTy = Ty;
1216 }
1217
1218 if (Idx == NumParams) {
1219 // There's at least one and at most two more type ids than there are
1220 // arguments in FTy's argument list.
1221 Ty = nullptr;
1222 ++Idx;
1223 continue;
1224 }
1225
1226 Ty = FTy.getParamType(Idx++);
1227 }
1228
1229 // Return success only if all entries on both lists have been processed
1230 // and the function is not a variadic one.
1231 return Idx == NumParams + 1 && !FTy.isFunctionVarArg();
1232}
1233
1234bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl,
1235 LibFunc &F) const {
1236 // Intrinsics don't overlap w/libcalls; if our module has a large number of
1237 // intrinsics, this ends up being an interesting compile time win since we
1238 // avoid string normalization and comparison.
1239 if (FDecl.isIntrinsic()) return false;
1240
1241 const Module *M = FDecl.getParent();
1242 assert(M && "Expecting FDecl to be connected to a Module.");
1243
1244 if (FDecl.LibFuncCache == Function::UnknownLibFunc)
1245 if (!getLibFunc(FDecl.getName(), FDecl.LibFuncCache))
1246 FDecl.LibFuncCache = NotLibFunc;
1247
1248 if (FDecl.LibFuncCache == NotLibFunc)
1249 return false;
1250
1251 F = FDecl.LibFuncCache;
1252 return isValidProtoForLibFunc(*FDecl.getFunctionType(), F, *M);
1253}
1254
1255bool TargetLibraryInfoImpl::getLibFunc(unsigned int Opcode, Type *Ty,
1256 LibFunc &F) const {
1257 // Must be a frem instruction with float or double arguments.
1258 if (Opcode != Instruction::FRem || (!Ty->isDoubleTy() && !Ty->isFloatTy()))
1259 return false;
1260
1261 F = Ty->isDoubleTy() ? LibFunc_fmod : LibFunc_fmodf;
1262 return true;
1263}
1264
1265void TargetLibraryInfoImpl::disableAllFunctions() {
1266 memset(AvailableArray, 0, sizeof(AvailableArray));
1267}
1268
1269static bool compareByScalarFnName(const VecDesc &LHS, const VecDesc &RHS) {
1270 return LHS.getScalarFnName() < RHS.getScalarFnName();
1271}
1272
1273static bool compareByVectorFnName(const VecDesc &LHS, const VecDesc &RHS) {
1274 return LHS.getVectorFnName() < RHS.getVectorFnName();
1275}
1276
1277static bool compareWithScalarFnName(const VecDesc &LHS, StringRef S) {
1278 return LHS.getScalarFnName() < S;
1279}
1280
1281void TargetLibraryInfoImpl::addVectorizableFunctions(ArrayRef<VecDesc> Fns) {
1282 llvm::append_range(VectorDescs, Fns);
1283 llvm::sort(VectorDescs, compareByScalarFnName);
1284
1285 llvm::append_range(ScalarDescs, Fns);
1286 llvm::sort(ScalarDescs, compareByVectorFnName);
1287}
1288
1289static const VecDesc VecFuncs_Accelerate[] = {
1290#define TLI_DEFINE_ACCELERATE_VECFUNCS
1291#include "llvm/Analysis/VecFuncs.def"
1292#undef TLI_DEFINE_ACCELERATE_VECFUNCS
1293};
1294
1295static const VecDesc VecFuncs_DarwinLibSystemM[] = {
1296#define TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS
1297#include "llvm/Analysis/VecFuncs.def"
1298#undef TLI_DEFINE_DARWIN_LIBSYSTEM_M_VECFUNCS
1299};
1300
1301static const VecDesc VecFuncs_LIBMVEC_X86[] = {
1302#define TLI_DEFINE_LIBMVEC_X86_VECFUNCS
1303#include "llvm/Analysis/VecFuncs.def"
1304#undef TLI_DEFINE_LIBMVEC_X86_VECFUNCS
1305};
1306
1307static const VecDesc VecFuncs_LIBMVEC_AARCH64[] = {
1308#define TLI_DEFINE_LIBMVEC_AARCH64_VECFUNCS
1309#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX, CC) \
1310 {SCAL, VEC, VF, MASK, VABI_PREFIX, CC},
1311#include "llvm/Analysis/VecFuncs.def"
1312#undef TLI_DEFINE_LIBMVEC_AARCH64_VECFUNCS
1313};
1314
1315static const VecDesc VecFuncs_MASSV[] = {
1316#define TLI_DEFINE_MASSV_VECFUNCS
1317#include "llvm/Analysis/VecFuncs.def"
1318#undef TLI_DEFINE_MASSV_VECFUNCS
1319};
1320
1321static const VecDesc VecFuncs_SVML[] = {
1322#define TLI_DEFINE_SVML_VECFUNCS
1323#include "llvm/Analysis/VecFuncs.def"
1324#undef TLI_DEFINE_SVML_VECFUNCS
1325};
1326
1327static const VecDesc VecFuncs_SLEEFGNUABI_VF2[] = {
1328#define TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS
1329#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, VABI_PREFIX) \
1330 {SCAL, VEC, VF, /* MASK = */ false, VABI_PREFIX, /* CC = */ std::nullopt},
1331#include "llvm/Analysis/VecFuncs.def"
1332#undef TLI_DEFINE_SLEEFGNUABI_VF2_VECFUNCS
1333};
1334static const VecDesc VecFuncs_SLEEFGNUABI_VF4[] = {
1335#define TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS
1336#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, VABI_PREFIX) \
1337 {SCAL, VEC, VF, /* MASK = */ false, VABI_PREFIX, /* CC = */ std::nullopt},
1338#include "llvm/Analysis/VecFuncs.def"
1339#undef TLI_DEFINE_SLEEFGNUABI_VF4_VECFUNCS
1340};
1341static const VecDesc VecFuncs_SLEEFGNUABI_VFScalable[] = {
1342#define TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS
1343#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX) \
1344 {SCAL, VEC, VF, MASK, VABI_PREFIX, /* CC = */ std::nullopt},
1345#include "llvm/Analysis/VecFuncs.def"
1346#undef TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS
1347};
1348
1349static const VecDesc VecFuncs_SLEEFGNUABI_VFScalableRISCV[] = {
1350#define TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS_RISCV
1351#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX) \
1352 {SCAL, VEC, VF, MASK, VABI_PREFIX, /* CC = */ std::nullopt},
1353#include "llvm/Analysis/VecFuncs.def"
1354#undef TLI_DEFINE_SLEEFGNUABI_SCALABLE_VECFUNCS_RISCV
1355};
1356
1357static const VecDesc VecFuncs_ArmPL[] = {
1358#define TLI_DEFINE_ARMPL_VECFUNCS
1359#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX, CC) \
1360 {SCAL, VEC, VF, MASK, VABI_PREFIX, CC},
1361#include "llvm/Analysis/VecFuncs.def"
1362#undef TLI_DEFINE_ARMPL_VECFUNCS
1363};
1364
1365const VecDesc VecFuncs_AMDLIBM[] = {
1366#define TLI_DEFINE_AMDLIBM_VECFUNCS
1367#define TLI_DEFINE_VECFUNC(SCAL, VEC, VF, MASK, VABI_PREFIX) \
1368 {SCAL, VEC, VF, MASK, VABI_PREFIX, /* CC = */ std::nullopt},
1369#include "llvm/Analysis/VecFuncs.def"
1370#undef TLI_DEFINE_AMDLIBM_VECFUNCS
1371};
1372
1373void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib(
1374 enum VectorLibrary VecLib, const llvm::Triple &TargetTriple) {
1375 switch (VecLib) {
1376 case VectorLibrary::Accelerate: {
1377 addVectorizableFunctions(VecFuncs_Accelerate);
1378 break;
1379 }
1380 case VectorLibrary::DarwinLibSystemM: {
1381 addVectorizableFunctions(VecFuncs_DarwinLibSystemM);
1382 break;
1383 }
1384 case VectorLibrary::LIBMVEC: {
1385 switch (TargetTriple.getArch()) {
1386 default:
1387 break;
1388 case llvm::Triple::x86:
1389 case llvm::Triple::x86_64:
1390 addVectorizableFunctions(VecFuncs_LIBMVEC_X86);
1391 break;
1392 case llvm::Triple::aarch64:
1393 case llvm::Triple::aarch64_be:
1394 addVectorizableFunctions(VecFuncs_LIBMVEC_AARCH64);
1395 break;
1396 }
1397 break;
1398 }
1399 case VectorLibrary::MASSV: {
1400 addVectorizableFunctions(VecFuncs_MASSV);
1401 break;
1402 }
1403 case VectorLibrary::SVML: {
1404 addVectorizableFunctions(VecFuncs_SVML);
1405 break;
1406 }
1407 case VectorLibrary::SLEEFGNUABI: {
1408 switch (TargetTriple.getArch()) {
1409 default:
1410 break;
1411 case llvm::Triple::aarch64:
1412 case llvm::Triple::aarch64_be:
1413 addVectorizableFunctions(VecFuncs_SLEEFGNUABI_VF2);
1414 addVectorizableFunctions(VecFuncs_SLEEFGNUABI_VF4);
1415 addVectorizableFunctions(VecFuncs_SLEEFGNUABI_VFScalable);
1416 break;
1417 case llvm::Triple::riscv64:
1418 addVectorizableFunctions(VecFuncs_SLEEFGNUABI_VFScalableRISCV);
1419 break;
1420 }
1421 break;
1422 }
1423 case VectorLibrary::ArmPL: {
1424 switch (TargetTriple.getArch()) {
1425 default:
1426 break;
1427 case llvm::Triple::aarch64:
1428 case llvm::Triple::aarch64_be:
1429 addVectorizableFunctions(VecFuncs_ArmPL);
1430 break;
1431 }
1432 break;
1433 }
1434 case VectorLibrary::AMDLIBM: {
1435 addVectorizableFunctions(VecFuncs_AMDLIBM);
1436 break;
1437 }
1438 case VectorLibrary::NoLibrary:
1439 break;
1440 }
1441}
1442
1443bool TargetLibraryInfoImpl::isFunctionVectorizable(StringRef funcName) const {
1444 funcName = sanitizeFunctionName(funcName);
1445 if (funcName.empty())
1446 return false;
1447
1448 std::vector<VecDesc>::const_iterator I =
1449 llvm::lower_bound(VectorDescs, funcName, compareWithScalarFnName);
1450 return I != VectorDescs.end() && StringRef(I->getScalarFnName()) == funcName;
1451}
1452
1453StringRef TargetLibraryInfoImpl::getVectorizedFunction(StringRef F,
1454 const ElementCount &VF,
1455 bool Masked) const {
1456 const VecDesc *VD = getVectorMappingInfo(F, VF, Masked);
1457 if (VD)
1458 return VD->getVectorFnName();
1459 return StringRef();
1460}
1461
1462const VecDesc *
1463TargetLibraryInfoImpl::getVectorMappingInfo(StringRef F, const ElementCount &VF,
1464 bool Masked) const {
1465 F = sanitizeFunctionName(F);
1466 if (F.empty())
1467 return nullptr;
1468 std::vector<VecDesc>::const_iterator I =
1469 llvm::lower_bound(VectorDescs, F, compareWithScalarFnName);
1470 while (I != VectorDescs.end() && StringRef(I->getScalarFnName()) == F) {
1471 if ((I->getVectorizationFactor() == VF) && (I->isMasked() == Masked))
1472 return &(*I);
1473 ++I;
1474 }
1475 return nullptr;
1476}
1477
1478TargetLibraryInfo TargetLibraryAnalysis::run(const Function &F,
1479 FunctionAnalysisManager &) {
1480 if (!BaselineInfoImpl)
1481 BaselineInfoImpl = TargetLibraryInfoImpl(F.getParent()->getTargetTriple());
1482 return TargetLibraryInfo(*BaselineInfoImpl, &F);
1483}
1484
1485unsigned TargetLibraryInfoImpl::getWCharSize(const Module &M) const {
1486 if (auto *ShortWChar = cast_or_null<ConstantAsMetadata>(
1487 M.getModuleFlag("wchar_size")))
1488 return cast<ConstantInt>(ShortWChar->getValue())->getZExtValue();
1489 return 0;
1490}
1491
1492unsigned TargetLibraryInfoImpl::getSizeTSize(const Module &M) const {
1493 // There is really no guarantee that sizeof(size_t) is equal to the index
1494 // size of the default address space. If that isn't true then it should be
1495 // possible to derive the SizeTTy from the target triple here instead and do
1496 // an early return.
1497
1498 // Hard coding address space zero may seem unfortunate, but a number of
1499 // configurations of common targets (i386, x86-64 x32, aarch64 x32, possibly
1500 // others) have larger-than-size_t index sizes on non-default address spaces,
1501 // making this the best default.
1502 return M.getDataLayout().getIndexSizeInBits(/*AddressSpace=*/0);
1503}
1504
1507
1510
1514
1518
1519AnalysisKey TargetLibraryAnalysis::Key;
1520
1521// Register the basic pass.
1522INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
1523 "Target Library Information", false, true)
1524char TargetLibraryInfoWrapperPass::ID = 0;
1525
1526void TargetLibraryInfoWrapperPass::anchor() {}
1527
1528void TargetLibraryInfoImpl::getWidestVF(StringRef ScalarF,
1529 ElementCount &FixedVF,
1530 ElementCount &ScalableVF) const {
1531 ScalarF = sanitizeFunctionName(ScalarF);
1532 // Use '0' here because a type of the form <vscale x 1 x ElTy> is not the
1533 // same as a scalar.
1534 ScalableVF = ElementCount::getScalable(0);
1535 FixedVF = ElementCount::getFixed(1);
1536 if (ScalarF.empty())
1537 return;
1538
1539 std::vector<VecDesc>::const_iterator I =
1540 llvm::lower_bound(VectorDescs, ScalarF, compareWithScalarFnName);
1541 while (I != VectorDescs.end() && StringRef(I->getScalarFnName()) == ScalarF) {
1542 ElementCount *VF =
1543 I->getVectorizationFactor().isScalable() ? &ScalableVF : &FixedVF;
1544 if (ElementCount::isKnownGT(I->getVectorizationFactor(), *VF))
1545 *VF = I->getVectorizationFactor();
1546 ++I;
1547 }
1548}
assert
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
Constants.h
This file contains the declarations for the subclasses of Constant, which represent the different fla...
DenseMap.h
This file defines the DenseMap class.
Module.h
Module.h This file contains the declarations for the Module class.
F
#define F(x, y, z)
Definition MD5.cpp:54
I
#define I(x, y, z)
Definition MD5.cpp:57
T
#define T
Definition Mips16ISelLowering.cpp:353
INITIALIZE_PASS
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition PassSupport.h:56
SmallString.h
This file defines the SmallString class.
hasSinCosPiStret
static bool hasSinCosPiStret(const Triple &T)
Definition TargetLibraryInfo.cpp:71
isCallingConvCCompatible
static bool isCallingConvCCompatible(CallingConv::ID CC, const Triple &TT, FunctionType *FuncTy)
Definition TargetLibraryInfo.cpp:99
initializeLibCalls
static void initializeLibCalls(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames, VectorLibrary VecLib)
Initialize the set of available library functions based on the specified target triple.
Definition TargetLibraryInfo.cpp:162
sanitizeFunctionName
static StringRef sanitizeFunctionName(StringRef funcName)
Definition TargetLibraryInfo.cpp:996
VecFuncs_MASSV
static const VecDesc VecFuncs_MASSV[]
Definition TargetLibraryInfo.cpp:1315
matchType
static bool matchType(FuncArgTypeID ArgTy, const Type *Ty, unsigned IntBits, unsigned SizeTBits)
Definition TargetLibraryInfo.cpp:1034
hasBcmp
static bool hasBcmp(const Triple &TT)
Definition TargetLibraryInfo.cpp:89
VecFuncs_SLEEFGNUABI_VF2
static const VecDesc VecFuncs_SLEEFGNUABI_VF2[]
Definition TargetLibraryInfo.cpp:1327
initializeBase
static void initializeBase(TargetLibraryInfoImpl &TLI, const Triple &T)
Definition TargetLibraryInfo.cpp:142
compareByScalarFnName
static bool compareByScalarFnName(const VecDesc &LHS, const VecDesc &RHS)
Definition TargetLibraryInfo.cpp:1269
VecFuncs_LIBMVEC_AARCH64
static const VecDesc VecFuncs_LIBMVEC_AARCH64[]
Definition TargetLibraryInfo.cpp:1307
compareByVectorFnName
static bool compareByVectorFnName(const VecDesc &LHS, const VecDesc &RHS)
Definition TargetLibraryInfo.cpp:1273
VecFuncs_SLEEFGNUABI_VF4
static const VecDesc VecFuncs_SLEEFGNUABI_VF4[]
Definition TargetLibraryInfo.cpp:1334
Signatures
static const FuncProtoTy Signatures[]
Definition TargetLibraryInfo.cpp:63
VecFuncs_ArmPL
static const VecDesc VecFuncs_ArmPL[]
Definition TargetLibraryInfo.cpp:1357
initialize
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringLiteral > StandardNames, VectorLibrary VecLib)
Initialize the set of available library functions based on the specified target triple.
Definition TargetLibraryInfo.cpp:934
VecFuncs_AMDLIBM
const VecDesc VecFuncs_AMDLIBM[]
Definition TargetLibraryInfo.cpp:1365
isValidProtoForSizeReturningNew
static bool isValidProtoForSizeReturningNew(const FunctionType &FTy, LibFunc F, const Module &M, int SizeTSizeBits)
Definition TargetLibraryInfo.cpp:1081
VecFuncs_LIBMVEC_X86
static const VecDesc VecFuncs_LIBMVEC_X86[]
Definition TargetLibraryInfo.cpp:1301
VecFuncs_DarwinLibSystemM
static const VecDesc VecFuncs_DarwinLibSystemM[]
Definition TargetLibraryInfo.cpp:1295
VecFuncs_SVML
static const VecDesc VecFuncs_SVML[]
Definition TargetLibraryInfo.cpp:1321
FuncProtoTy
std::array< FuncArgTypeID, 8 > FuncProtoTy
Definition TargetLibraryInfo.cpp:61
VecFuncs_SLEEFGNUABI_VFScalable
static const VecDesc VecFuncs_SLEEFGNUABI_VFScalable[]
Definition TargetLibraryInfo.cpp:1341
compareWithScalarFnName
static bool compareWithScalarFnName(const VecDesc &LHS, StringRef S)
Definition TargetLibraryInfo.cpp:1277
VecFuncs_Accelerate
static const VecDesc VecFuncs_Accelerate[]
Definition TargetLibraryInfo.cpp:1289
VecFuncs_SLEEFGNUABI_VFScalableRISCV
static const VecDesc VecFuncs_SLEEFGNUABI_VFScalableRISCV[]
Definition TargetLibraryInfo.cpp:1349
buildIndexMap
static DenseMap< StringRef, LibFunc > buildIndexMap(ArrayRef< StringLiteral > StandardNames)
Definition TargetLibraryInfo.cpp:1008
RHS
Value * RHS
Definition X86PartialReduction.cpp:81
LHS
Value * LHS
Definition X86PartialReduction.cpp:80
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition InstrTypes.h:1114
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition InstrTypes.h:1404
llvm::CallBase::getFunctionType
FunctionType * getFunctionType() const
Definition InstrTypes.h:1203
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition DenseMap.h:178
llvm::DenseMapBase::end
iterator end()
Definition DenseMap.h:81
llvm::DenseMapBase::reserve
void reserve(size_type NumEntries)
Grow the densemap so that it can contain at least NumEntries items before resizing again.
Definition DenseMap.h:114
llvm::ElementCount::getScalable
static constexpr ElementCount getScalable(ScalarTy MinVal)
Definition TypeSize.h:312
llvm::ElementCount::getFixed
static constexpr ElementCount getFixed(ScalarTy MinVal)
Definition TypeSize.h:309
llvm::FunctionType
Class to represent function types.
Definition DerivedTypes.h:105
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition Function.h:209
llvm::Function::isIntrinsic
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition Function.h:249
llvm::GlobalValue::dropLLVMManglingEscape
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition GlobalValue.h:569
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition GlobalValue.h:663
llvm::ImmutablePass::ImmutablePass
ImmutablePass(char &pid)
Definition Pass.h:287
llvm::Instruction::getModule
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition Instruction.cpp:82
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:67
llvm::Module::getTargetTriple
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition Module.h:281
llvm::PointerType::get
static LLVM_ABI PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space.
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:26
llvm::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition StringRef.h:854
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition StringRef.h:143
llvm::StringRef::contains
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
Definition StringRef.h:426
llvm::StructType
Class to represent struct types.
Definition DerivedTypes.h:218
llvm::StructType::get
static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition Type.cpp:413
llvm::TargetLibraryAnalysis::run
LLVM_ABI TargetLibraryInfo run(const Function &F, FunctionAnalysisManager &)
Definition TargetLibraryInfo.cpp:1478
llvm::TargetLibraryInfoImpl
Implementation of the target library information.
Definition TargetLibraryInfo.h:87
llvm::TargetLibraryInfoImpl::setShouldExtI32Param
void setShouldExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext or zeroext attributes if they...
Definition TargetLibraryInfo.h:212
llvm::TargetLibraryInfoImpl::setShouldExtI32Return
void setShouldExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext or zeroext attributes if they ...
Definition TargetLibraryInfo.h:219
llvm::TargetLibraryInfoImpl::getWCharSize
LLVM_ABI unsigned getWCharSize(const Module &M) const
Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
Definition TargetLibraryInfo.cpp:1485
llvm::TargetLibraryInfoImpl::getLibFunc
LLVM_ABI bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
Definition TargetLibraryInfo.cpp:1017
llvm::TargetLibraryInfoImpl::getWidestVF
LLVM_ABI void getWidestVF(StringRef ScalarF, ElementCount &FixedVF, ElementCount &Scalable) const
Returns the largest vectorization factor used in the list of vector functions.
Definition TargetLibraryInfo.cpp:1528
llvm::TargetLibraryInfoImpl::isFunctionVectorizable
bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const
Return true if the function F has a vector equivalent with vectorization factor VF.
Definition TargetLibraryInfo.h:189
llvm::TargetLibraryInfoImpl::setShouldSignExtI32Param
void setShouldSignExtI32Param(bool Val)
Set to true iff i32 parameters to library functions should have signext attribute if they correspond ...
Definition TargetLibraryInfo.h:225
llvm::TargetLibraryInfoImpl::setAvailableWithName
void setAvailableWithName(LibFunc F, StringRef Name)
Forces a function to be marked as available and provide an alternate name that must be used.
Definition TargetLibraryInfo.h:162
llvm::TargetLibraryInfoImpl::getIntSize
unsigned getIntSize() const
Get size of a C-level int or unsigned int, in bits.
Definition TargetLibraryInfo.h:243
llvm::TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib
LLVM_ABI void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib, const llvm::Triple &TargetTriple)
Calls addVectorizableFunctions with a known preset of functions for the given vector library.
Definition TargetLibraryInfo.cpp:1373
llvm::TargetLibraryInfoImpl::setIntSize
void setIntSize(unsigned Bits)
Initialize the C-level size of an integer.
Definition TargetLibraryInfo.h:248
llvm::TargetLibraryInfoImpl::getSizeTSize
LLVM_ABI unsigned getSizeTSize(const Module &M) const
Returns the size of the size_t type in bits.
Definition TargetLibraryInfo.cpp:1492
llvm::TargetLibraryInfoImpl::addVectorizableFunctions
LLVM_ABI void addVectorizableFunctions(ArrayRef< VecDesc > Fns)
Add a set of scalar -> vector mappings, queryable via getVectorizedFunction and getScalarizedFunction...
Definition TargetLibraryInfo.cpp:1281
llvm::TargetLibraryInfoImpl::getVectorMappingInfo
LLVM_ABI const VecDesc * getVectorMappingInfo(StringRef F, const ElementCount &VF, bool Masked) const
Return a pointer to a VecDesc object holding all info for scalar to vector mappings in TLI for the eq...
Definition TargetLibraryInfo.cpp:1463
llvm::TargetLibraryInfoImpl::isCallingConvCCompatible
static LLVM_ABI bool isCallingConvCCompatible(CallBase *CI)
Returns true if call site / callee has cdecl-compatible calling conventions.
Definition TargetLibraryInfo.cpp:130
llvm::TargetLibraryInfoImpl::setShouldSignExtI32Return
void setShouldSignExtI32Return(bool Val)
Set to true iff i32 results from library functions should have signext attribute if they correspond t...
Definition TargetLibraryInfo.h:231
llvm::TargetLibraryInfoImpl::operator=
LLVM_ABI TargetLibraryInfoImpl & operator=(const TargetLibraryInfoImpl &TLI)
Definition TargetLibraryInfo.cpp:973
llvm::TargetLibraryInfoImpl::disableAllFunctions
LLVM_ABI void disableAllFunctions()
Disables all builtins.
Definition TargetLibraryInfo.cpp:1265
llvm::TargetLibraryInfoImpl::setUnavailable
void setUnavailable(LibFunc F)
Forces a function to be marked as unavailable.
Definition TargetLibraryInfo.h:151
llvm::TargetLibraryInfoImpl::getVectorizedFunction
LLVM_ABI StringRef getVectorizedFunction(StringRef F, const ElementCount &VF, bool Masked) const
Return the name of the equivalent of F, vectorized with factor VF.
Definition TargetLibraryInfo.cpp:1453
llvm::TargetLibraryInfoImpl::setAvailable
void setAvailable(LibFunc F)
Forces a function to be marked as available.
Definition TargetLibraryInfo.h:156
llvm::TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass
TargetLibraryInfoWrapperPass()
The default constructor should not be used and is only for pass manager initialization purposes.
Definition TargetLibraryInfo.cpp:1505
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition TargetLibraryInfo.h:268
llvm::TargetLibraryInfo::initExtensionsForTriple
static void initExtensionsForTriple(bool &ShouldExtI32Param, bool &ShouldExtI32Return, bool &ShouldSignExtI32Param, bool &ShouldSignExtI32Return, const Triple &T)
Definition TargetLibraryInfo.h:454
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
llvm::Triple::getArch
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition Triple.h:413
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
llvm::Type::isArrayTy
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition Type.h:264
llvm::Type::getArrayElementType
Type * getArrayElementType() const
Definition Type.h:408
llvm::Type::getArrayNumElements
LLVM_ABI uint64_t getArrayNumElements() const
Definition DerivedTypes.h:425
llvm::Type::isFloatingPointTy
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
Definition Type.h:184
llvm::Type::getIntNTy
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition Type.cpp:300
llvm::Value::getName
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
Definition Value.cpp:322
llvm::VecDesc
Provides info so a possible vectorization of a function can be computed.
Definition TargetLibraryInfo.h:44
llvm::VecDesc::getVectorFunctionABIVariantString
LLVM_ABI std::string getVectorFunctionABIVariantString() const
Returns a vector function ABI variant string on the form: ZGV<isa><mask><vlen><vparams><scalarname>(<...
Definition TargetLibraryInfo.cpp:29
llvm::VecDesc::getVectorFnName
StringRef getVectorFnName() const
Definition TargetLibraryInfo.h:62
llvm::VersionTuple
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition VersionTuple.h:30
llvm::details::FixedOrScalableQuantity< ElementCount, unsigned >::isKnownGT
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition TypeSize.h:223
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition raw_ostream.h:692
llvm::raw_svector_ostream::str
StringRef str() const
Return a StringRef for the vector contents.
Definition raw_ostream.h:721
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition ErrorHandling.h:164
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition CallingConv.h:24
llvm::CallingConv::ARM_APCS
@ ARM_APCS
ARM Procedure Calling Standard (obsolete, but still used on some targets).
Definition CallingConv.h:107
llvm::CallingConv::ARM_AAPCS
@ ARM_AAPCS
ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition CallingConv.h:111
llvm::CallingConv::ARM_AAPCS_VFP
@ ARM_AAPCS_VFP
Same as ARM_AAPCS, but uses hard floating point ABI.
Definition CallingConv.h:114
llvm::CallingConv::C
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
llvm::dyn_cast
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition STLExtras.h:2136
llvm::cast_or_null
auto cast_or_null(const Y &Val)
Definition Casting.h:714
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition STLExtras.h:1622
llvm::lower_bound
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:1994
llvm::move
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:1867
llvm::cast
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
llvm::VectorLibrary
VectorLibrary
List of known vector-functions libraries.
Definition SystemLibraries.h:20
llvm::FunctionAnalysisManager
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition PassManager.h:563
std
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:867
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition Analysis.h:29
Generated on for LLVM by doxygen 1.14.0