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