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