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