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