1 //===-- TargetLibraryInfo.h - Library information ---------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H 11 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H 12 13 #include "llvm/ADT/DenseMap.h" 14 #include "llvm/ADT/Optional.h" 15 #include "llvm/ADT/Triple.h" 16 #include "llvm/IR/CallSite.h" 17 #include "llvm/IR/Function.h" 18 #include "llvm/IR/Module.h" 19 #include "llvm/IR/PassManager.h" 20 #include "llvm/Pass.h" 21 22 namespace llvm { 23 template <typename T> class ArrayRef; 24 25 /// Describes a possible vectorization of a function. 26 /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized 27 /// by a factor 'VectorizationFactor'. 28 struct VecDesc { 29 StringRef ScalarFnName; 30 StringRef VectorFnName; 31 unsigned VectorizationFactor; 32 }; 33 34 enum LibFunc { 35 #define TLI_DEFINE_ENUM 36 #include "llvm/Analysis/TargetLibraryInfo.def" 37 38 NumLibFuncs 39 }; 40 41 /// Implementation of the target library information. 42 /// 43 /// This class constructs tables that hold the target library information and 44 /// make it available. However, it is somewhat expensive to compute and only 45 /// depends on the triple. So users typically interact with the \c 46 /// TargetLibraryInfo wrapper below. 47 class TargetLibraryInfoImpl { 48 friend class TargetLibraryInfo; 49 50 unsigned char AvailableArray[(NumLibFuncs+3)/4]; 51 llvm::DenseMap<unsigned, std::string> CustomNames; 52 static StringRef const StandardNames[NumLibFuncs]; 53 bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param; 54 55 enum AvailabilityState { 56 StandardName = 3, // (memset to all ones) 57 CustomName = 1, 58 Unavailable = 0 // (memset to all zeros) 59 }; 60 void setState(LibFunc F, AvailabilityState State) { 61 AvailableArray[F/4] &= ~(3 << 2*(F&3)); 62 AvailableArray[F/4] |= State << 2*(F&3); 63 } 64 AvailabilityState getState(LibFunc F) const { 65 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3); 66 } 67 68 /// Vectorization descriptors - sorted by ScalarFnName. 69 std::vector<VecDesc> VectorDescs; 70 /// Scalarization descriptors - same content as VectorDescs but sorted based 71 /// on VectorFnName rather than ScalarFnName. 72 std::vector<VecDesc> ScalarDescs; 73 74 /// Return true if the function type FTy is valid for the library function 75 /// F, regardless of whether the function is available. 76 bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F, 77 const DataLayout *DL) const; 78 79 public: 80 /// List of known vector-functions libraries. 81 /// 82 /// The vector-functions library defines, which functions are vectorizable 83 /// and with which factor. The library can be specified by either frontend, 84 /// or a commandline option, and then used by 85 /// addVectorizableFunctionsFromVecLib for filling up the tables of 86 /// vectorizable functions. 87 enum VectorLibrary { 88 NoLibrary, // Don't use any vector library. 89 Accelerate, // Use Accelerate framework. 90 SVML // Intel short vector math library. 91 }; 92 93 TargetLibraryInfoImpl(); 94 explicit TargetLibraryInfoImpl(const Triple &T); 95 96 // Provide value semantics. 97 TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI); 98 TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI); 99 TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI); 100 TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI); 101 102 /// Searches for a particular function name. 103 /// 104 /// If it is one of the known library functions, return true and set F to the 105 /// corresponding value. 106 bool getLibFunc(StringRef funcName, LibFunc &F) const; 107 108 /// Searches for a particular function name, also checking that its type is 109 /// valid for the library function matching that name. 110 /// 111 /// If it is one of the known library functions, return true and set F to the 112 /// corresponding value. 113 bool getLibFunc(const Function &FDecl, LibFunc &F) const; 114 115 /// Forces a function to be marked as unavailable. 116 void setUnavailable(LibFunc F) { 117 setState(F, Unavailable); 118 } 119 120 /// Forces a function to be marked as available. 121 void setAvailable(LibFunc F) { 122 setState(F, StandardName); 123 } 124 125 /// Forces a function to be marked as available and provide an alternate name 126 /// that must be used. 127 void setAvailableWithName(LibFunc F, StringRef Name) { 128 if (StandardNames[F] != Name) { 129 setState(F, CustomName); 130 CustomNames[F] = Name; 131 assert(CustomNames.find(F) != CustomNames.end()); 132 } else { 133 setState(F, StandardName); 134 } 135 } 136 137 /// Disables all builtins. 138 /// 139 /// This can be used for options like -fno-builtin. 140 void disableAllFunctions(); 141 142 /// Add a set of scalar -> vector mappings, queryable via 143 /// getVectorizedFunction and getScalarizedFunction. 144 void addVectorizableFunctions(ArrayRef<VecDesc> Fns); 145 146 /// Calls addVectorizableFunctions with a known preset of functions for the 147 /// given vector library. 148 void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib); 149 150 /// Return true if the function F has a vector equivalent with vectorization 151 /// factor VF. 152 bool isFunctionVectorizable(StringRef F, unsigned VF) const { 153 return !getVectorizedFunction(F, VF).empty(); 154 } 155 156 /// Return true if the function F has a vector equivalent with any 157 /// vectorization factor. 158 bool isFunctionVectorizable(StringRef F) const; 159 160 /// Return the name of the equivalent of F, vectorized with factor VF. If no 161 /// such mapping exists, return the empty string. 162 StringRef getVectorizedFunction(StringRef F, unsigned VF) const; 163 164 /// Return true if the function F has a scalar equivalent, and set VF to be 165 /// the vectorization factor. 166 bool isFunctionScalarizable(StringRef F, unsigned &VF) const { 167 return !getScalarizedFunction(F, VF).empty(); 168 } 169 170 /// Return the name of the equivalent of F, scalarized. If no such mapping 171 /// exists, return the empty string. 172 /// 173 /// Set VF to the vectorization factor. 174 StringRef getScalarizedFunction(StringRef F, unsigned &VF) const; 175 176 /// Set to true iff i32 parameters to library functions should have signext 177 /// or zeroext attributes if they correspond to C-level int or unsigned int, 178 /// respectively. 179 void setShouldExtI32Param(bool Val) { 180 ShouldExtI32Param = Val; 181 } 182 183 /// Set to true iff i32 results from library functions should have signext 184 /// or zeroext attributes if they correspond to C-level int or unsigned int, 185 /// respectively. 186 void setShouldExtI32Return(bool Val) { 187 ShouldExtI32Return = Val; 188 } 189 190 /// Set to true iff i32 parameters to library functions should have signext 191 /// attribute if they correspond to C-level int or unsigned int. 192 void setShouldSignExtI32Param(bool Val) { 193 ShouldSignExtI32Param = Val; 194 } 195 196 /// Returns the size of the wchar_t type in bytes. 197 unsigned getWCharSize(const Module &M) const; 198 199 /// Returns size of the default wchar_t type on target \p T. This is mostly 200 /// intended to verify that the size in the frontend matches LLVM. All other 201 /// queries should use getWCharSize() instead. 202 static unsigned getTargetWCharSize(const Triple &T); 203 }; 204 205 /// Provides information about what library functions are available for 206 /// the current target. 207 /// 208 /// This both allows optimizations to handle them specially and frontends to 209 /// disable such optimizations through -fno-builtin etc. 210 class TargetLibraryInfo { 211 friend class TargetLibraryAnalysis; 212 friend class TargetLibraryInfoWrapperPass; 213 214 const TargetLibraryInfoImpl *Impl; 215 216 public: 217 explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {} 218 219 // Provide value semantics. 220 TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {} 221 TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {} 222 TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) { 223 Impl = TLI.Impl; 224 return *this; 225 } 226 TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) { 227 Impl = TLI.Impl; 228 return *this; 229 } 230 231 /// Searches for a particular function name. 232 /// 233 /// If it is one of the known library functions, return true and set F to the 234 /// corresponding value. 235 bool getLibFunc(StringRef funcName, LibFunc &F) const { 236 return Impl->getLibFunc(funcName, F); 237 } 238 239 bool getLibFunc(const Function &FDecl, LibFunc &F) const { 240 return Impl->getLibFunc(FDecl, F); 241 } 242 243 /// If a callsite does not have the 'nobuiltin' attribute, return if the 244 /// called function is a known library function and set F to that function. 245 bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const { 246 return !CS.isNoBuiltin() && CS.getCalledFunction() && 247 getLibFunc(*(CS.getCalledFunction()), F); 248 } 249 250 /// Tests whether a library function is available. 251 bool has(LibFunc F) const { 252 return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable; 253 } 254 bool isFunctionVectorizable(StringRef F, unsigned VF) const { 255 return Impl->isFunctionVectorizable(F, VF); 256 } 257 bool isFunctionVectorizable(StringRef F) const { 258 return Impl->isFunctionVectorizable(F); 259 } 260 StringRef getVectorizedFunction(StringRef F, unsigned VF) const { 261 return Impl->getVectorizedFunction(F, VF); 262 } 263 264 /// Tests if the function is both available and a candidate for optimized code 265 /// generation. 266 bool hasOptimizedCodeGen(LibFunc F) const { 267 if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable) 268 return false; 269 switch (F) { 270 default: break; 271 case LibFunc_copysign: case LibFunc_copysignf: case LibFunc_copysignl: 272 case LibFunc_fabs: case LibFunc_fabsf: case LibFunc_fabsl: 273 case LibFunc_sin: case LibFunc_sinf: case LibFunc_sinl: 274 case LibFunc_cos: case LibFunc_cosf: case LibFunc_cosl: 275 case LibFunc_sqrt: case LibFunc_sqrtf: case LibFunc_sqrtl: 276 case LibFunc_sqrt_finite: case LibFunc_sqrtf_finite: 277 case LibFunc_sqrtl_finite: 278 case LibFunc_fmax: case LibFunc_fmaxf: case LibFunc_fmaxl: 279 case LibFunc_fmin: case LibFunc_fminf: case LibFunc_fminl: 280 case LibFunc_floor: case LibFunc_floorf: case LibFunc_floorl: 281 case LibFunc_nearbyint: case LibFunc_nearbyintf: case LibFunc_nearbyintl: 282 case LibFunc_ceil: case LibFunc_ceilf: case LibFunc_ceill: 283 case LibFunc_rint: case LibFunc_rintf: case LibFunc_rintl: 284 case LibFunc_round: case LibFunc_roundf: case LibFunc_roundl: 285 case LibFunc_trunc: case LibFunc_truncf: case LibFunc_truncl: 286 case LibFunc_log2: case LibFunc_log2f: case LibFunc_log2l: 287 case LibFunc_exp2: case LibFunc_exp2f: case LibFunc_exp2l: 288 case LibFunc_memcmp: case LibFunc_strcmp: case LibFunc_strcpy: 289 case LibFunc_stpcpy: case LibFunc_strlen: case LibFunc_strnlen: 290 case LibFunc_memchr: case LibFunc_mempcpy: 291 return true; 292 } 293 return false; 294 } 295 296 StringRef getName(LibFunc F) const { 297 auto State = Impl->getState(F); 298 if (State == TargetLibraryInfoImpl::Unavailable) 299 return StringRef(); 300 if (State == TargetLibraryInfoImpl::StandardName) 301 return Impl->StandardNames[F]; 302 assert(State == TargetLibraryInfoImpl::CustomName); 303 return Impl->CustomNames.find(F)->second; 304 } 305 306 /// Returns extension attribute kind to be used for i32 parameters 307 /// corresponding to C-level int or unsigned int. May be zeroext, signext, 308 /// or none. 309 Attribute::AttrKind getExtAttrForI32Param(bool Signed = true) const { 310 if (Impl->ShouldExtI32Param) 311 return Signed ? Attribute::SExt : Attribute::ZExt; 312 if (Impl->ShouldSignExtI32Param) 313 return Attribute::SExt; 314 return Attribute::None; 315 } 316 317 /// Returns extension attribute kind to be used for i32 return values 318 /// corresponding to C-level int or unsigned int. May be zeroext, signext, 319 /// or none. 320 Attribute::AttrKind getExtAttrForI32Return(bool Signed = true) const { 321 if (Impl->ShouldExtI32Return) 322 return Signed ? Attribute::SExt : Attribute::ZExt; 323 return Attribute::None; 324 } 325 326 /// \copydoc TargetLibraryInfoImpl::getWCharSize() 327 unsigned getWCharSize(const Module &M) const { 328 return Impl->getWCharSize(M); 329 } 330 331 /// Handle invalidation from the pass manager. 332 /// 333 /// If we try to invalidate this info, just return false. It cannot become 334 /// invalid even if the module or function changes. 335 bool invalidate(Module &, const PreservedAnalyses &, 336 ModuleAnalysisManager::Invalidator &) { 337 return false; 338 } 339 bool invalidate(Function &, const PreservedAnalyses &, 340 FunctionAnalysisManager::Invalidator &) { 341 return false; 342 } 343 }; 344 345 /// Analysis pass providing the \c TargetLibraryInfo. 346 /// 347 /// Note that this pass's result cannot be invalidated, it is immutable for the 348 /// life of the module. 349 class TargetLibraryAnalysis : public AnalysisInfoMixin<TargetLibraryAnalysis> { 350 public: 351 typedef TargetLibraryInfo Result; 352 353 /// Default construct the library analysis. 354 /// 355 /// This will use the module's triple to construct the library info for that 356 /// module. 357 TargetLibraryAnalysis() {} 358 359 /// Construct a library analysis with preset info. 360 /// 361 /// This will directly copy the preset info into the result without 362 /// consulting the module's triple. 363 TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl) 364 : PresetInfoImpl(std::move(PresetInfoImpl)) {} 365 366 TargetLibraryInfo run(Module &M, ModuleAnalysisManager &); 367 TargetLibraryInfo run(Function &F, FunctionAnalysisManager &); 368 369 private: 370 friend AnalysisInfoMixin<TargetLibraryAnalysis>; 371 static AnalysisKey Key; 372 373 Optional<TargetLibraryInfoImpl> PresetInfoImpl; 374 375 StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls; 376 377 TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T); 378 }; 379 380 class TargetLibraryInfoWrapperPass : public ImmutablePass { 381 TargetLibraryInfoImpl TLIImpl; 382 TargetLibraryInfo TLI; 383 384 virtual void anchor(); 385 386 public: 387 static char ID; 388 TargetLibraryInfoWrapperPass(); 389 explicit TargetLibraryInfoWrapperPass(const Triple &T); 390 explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI); 391 392 TargetLibraryInfo &getTLI() { return TLI; } 393 const TargetLibraryInfo &getTLI() const { return TLI; } 394 }; 395 396 } // end namespace llvm 397 398 #endif 399