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