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