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