LCOV - code coverage report
Current view: top level - include/llvm/Analysis - TargetLibraryInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 40 40 100.0 %
Date: 2018-02-21 06:32:55 Functions: 8 9 88.9 %
Legend: Lines: hit not hit

          Line data    Source code
       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      287719 : 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     1228021 :     AvailableArray[F/4] &= ~(3 << 2*(F&3));
      62     1228021 :     AvailableArray[F/4] |= State << 2*(F&3);
      63             :   }
      64             :   AvailabilityState getState(LibFunc F) const {
      65     2141946 :     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        2613 :   void setAvailableWithName(LibFunc F, StringRef Name) {
     128        2613 :     if (StandardNames[F] != Name) {
     129             :       setState(F, CustomName);
     130        7838 :       CustomNames[F] = Name;
     131             :       assert(CustomNames.find(F) != CustomNames.end());
     132             :     } else {
     133             :       setState(F, StandardName);
     134             :     }
     135        2613 :   }
     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         672 :     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       45944 :     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       45944 :     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       45944 :     ShouldSignExtI32Param = Val;
     194             :   }
     195             : 
     196             :   /// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
     197             :   /// This queries the 'wchar_size' metadata.
     198             :   unsigned getWCharSize(const Module &M) const;
     199             : };
     200             : 
     201             : /// Provides information about what library functions are available for
     202             : /// the current target.
     203             : ///
     204             : /// This both allows optimizations to handle them specially and frontends to
     205             : /// disable such optimizations through -fno-builtin etc.
     206             : class TargetLibraryInfo {
     207             :   friend class TargetLibraryAnalysis;
     208             :   friend class TargetLibraryInfoWrapperPass;
     209             : 
     210             :   const TargetLibraryInfoImpl *Impl;
     211             : 
     212             : public:
     213       57547 :   explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
     214             : 
     215             :   // Provide value semantics.
     216             :   TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
     217        4904 :   TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
     218             :   TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
     219             :     Impl = TLI.Impl;
     220             :     return *this;
     221             :   }
     222             :   TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
     223             :     Impl = TLI.Impl;
     224             :     return *this;
     225             :   }
     226             : 
     227             :   /// Searches for a particular function name.
     228             :   ///
     229             :   /// If it is one of the known library functions, return true and set F to the
     230             :   /// corresponding value.
     231             :   bool getLibFunc(StringRef funcName, LibFunc &F) const {
     232     8845661 :     return Impl->getLibFunc(funcName, F);
     233             :   }
     234             : 
     235             :   bool getLibFunc(const Function &FDecl, LibFunc &F) const {
     236     9388993 :     return Impl->getLibFunc(FDecl, F);
     237             :   }
     238             : 
     239             :   /// If a callsite does not have the 'nobuiltin' attribute, return if the
     240             :   /// called function is a known library function and set F to that function.
     241      322203 :   bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const {
     242      632526 :     return !CS.isNoBuiltin() && CS.getCalledFunction() &&
     243      322203 :            getLibFunc(*(CS.getCalledFunction()), F);
     244             :   }
     245             : 
     246             :   /// Tests whether a library function is available.
     247             :   bool has(LibFunc F) const {
     248     1306282 :     return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
     249             :   }
     250             :   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
     251         336 :     return Impl->isFunctionVectorizable(F, VF);
     252             :   }
     253             :   bool isFunctionVectorizable(StringRef F) const {
     254        1427 :     return Impl->isFunctionVectorizable(F);
     255             :   }
     256             :   StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
     257          64 :     return Impl->getVectorizedFunction(F, VF);
     258             :   }
     259             : 
     260             :   /// Tests if the function is both available and a candidate for optimized code
     261             :   /// generation.
     262       14383 :   bool hasOptimizedCodeGen(LibFunc F) const {
     263       28766 :     if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
     264             :       return false;
     265        7773 :     switch (F) {
     266             :     default: break;
     267             :     case LibFunc_copysign:     case LibFunc_copysignf:  case LibFunc_copysignl:
     268             :     case LibFunc_fabs:         case LibFunc_fabsf:      case LibFunc_fabsl:
     269             :     case LibFunc_sin:          case LibFunc_sinf:       case LibFunc_sinl:
     270             :     case LibFunc_cos:          case LibFunc_cosf:       case LibFunc_cosl:
     271             :     case LibFunc_sqrt:         case LibFunc_sqrtf:      case LibFunc_sqrtl:
     272             :     case LibFunc_sqrt_finite:  case LibFunc_sqrtf_finite:
     273             :                                                    case LibFunc_sqrtl_finite:
     274             :     case LibFunc_fmax:         case LibFunc_fmaxf:      case LibFunc_fmaxl:
     275             :     case LibFunc_fmin:         case LibFunc_fminf:      case LibFunc_fminl:
     276             :     case LibFunc_floor:        case LibFunc_floorf:     case LibFunc_floorl:
     277             :     case LibFunc_nearbyint:    case LibFunc_nearbyintf: case LibFunc_nearbyintl:
     278             :     case LibFunc_ceil:         case LibFunc_ceilf:      case LibFunc_ceill:
     279             :     case LibFunc_rint:         case LibFunc_rintf:      case LibFunc_rintl:
     280             :     case LibFunc_round:        case LibFunc_roundf:     case LibFunc_roundl:
     281             :     case LibFunc_trunc:        case LibFunc_truncf:     case LibFunc_truncl:
     282             :     case LibFunc_log2:         case LibFunc_log2f:      case LibFunc_log2l:
     283             :     case LibFunc_exp2:         case LibFunc_exp2f:      case LibFunc_exp2l:
     284             :     case LibFunc_memcmp:       case LibFunc_strcmp:     case LibFunc_strcpy:
     285             :     case LibFunc_stpcpy:       case LibFunc_strlen:     case LibFunc_strnlen:
     286             :     case LibFunc_memchr:       case LibFunc_mempcpy:
     287             :       return true;
     288             :     }
     289        6204 :     return false;
     290             :   }
     291             : 
     292      792244 :   StringRef getName(LibFunc F) const {
     293      792244 :     auto State = Impl->getState(F);
     294      792244 :     if (State == TargetLibraryInfoImpl::Unavailable)
     295         156 :       return StringRef();
     296      792088 :     if (State == TargetLibraryInfoImpl::StandardName)
     297      792061 :       return Impl->StandardNames[F];
     298             :     assert(State == TargetLibraryInfoImpl::CustomName);
     299          54 :     return Impl->CustomNames.find(F)->second;
     300             :   }
     301             : 
     302             :   /// Returns extension attribute kind to be used for i32 parameters
     303             :   /// corresponding to C-level int or unsigned int.  May be zeroext, signext,
     304             :   /// or none.
     305             :   Attribute::AttrKind getExtAttrForI32Param(bool Signed = true) const {
     306          36 :     if (Impl->ShouldExtI32Param)
     307             :       return Signed ? Attribute::SExt : Attribute::ZExt;
     308          28 :     if (Impl->ShouldSignExtI32Param)
     309             :       return Attribute::SExt;
     310             :     return Attribute::None;
     311             :   }
     312             : 
     313             :   /// Returns extension attribute kind to be used for i32 return values
     314             :   /// corresponding to C-level int or unsigned int.  May be zeroext, signext,
     315             :   /// or none.
     316             :   Attribute::AttrKind getExtAttrForI32Return(bool Signed = true) const {
     317             :     if (Impl->ShouldExtI32Return)
     318             :       return Signed ? Attribute::SExt : Attribute::ZExt;
     319             :     return Attribute::None;
     320             :   }
     321             : 
     322             :   /// \copydoc TargetLibraryInfoImpl::getWCharSize()
     323             :   unsigned getWCharSize(const Module &M) const {
     324         107 :     return Impl->getWCharSize(M);
     325             :   }
     326             : 
     327             :   /// Handle invalidation from the pass manager.
     328             :   ///
     329             :   /// If we try to invalidate this info, just return false. It cannot become
     330             :   /// invalid even if the module or function changes.
     331             :   bool invalidate(Module &, const PreservedAnalyses &,
     332             :                   ModuleAnalysisManager::Invalidator &) {
     333             :     return false;
     334             :   }
     335             :   bool invalidate(Function &, const PreservedAnalyses &,
     336             :                   FunctionAnalysisManager::Invalidator &) {
     337             :     return false;
     338             :   }
     339             : };
     340             : 
     341             : /// Analysis pass providing the \c TargetLibraryInfo.
     342             : ///
     343             : /// Note that this pass's result cannot be invalidated, it is immutable for the
     344             : /// life of the module.
     345       10510 : class TargetLibraryAnalysis : public AnalysisInfoMixin<TargetLibraryAnalysis> {
     346             : public:
     347             :   typedef TargetLibraryInfo Result;
     348             : 
     349             :   /// Default construct the library analysis.
     350             :   ///
     351             :   /// This will use the module's triple to construct the library info for that
     352             :   /// module.
     353             :   TargetLibraryAnalysis() {}
     354             : 
     355             :   /// Construct a library analysis with preset info.
     356             :   ///
     357             :   /// This will directly copy the preset info into the result without
     358             :   /// consulting the module's triple.
     359             :   TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
     360             :       : PresetInfoImpl(std::move(PresetInfoImpl)) {}
     361             : 
     362             :   TargetLibraryInfo run(Module &M, ModuleAnalysisManager &);
     363             :   TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
     364             : 
     365             : private:
     366             :   friend AnalysisInfoMixin<TargetLibraryAnalysis>;
     367             :   static AnalysisKey Key;
     368             : 
     369             :   Optional<TargetLibraryInfoImpl> PresetInfoImpl;
     370             : 
     371             :   StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
     372             : 
     373             :   TargetLibraryInfoImpl &lookupInfoImpl(const Triple &T);
     374             : };
     375             : 
     376       54785 : class TargetLibraryInfoWrapperPass : public ImmutablePass {
     377             :   TargetLibraryInfoImpl TLIImpl;
     378             :   TargetLibraryInfo TLI;
     379             : 
     380             :   virtual void anchor();
     381             : 
     382             : public:
     383             :   static char ID;
     384             :   TargetLibraryInfoWrapperPass();
     385             :   explicit TargetLibraryInfoWrapperPass(const Triple &T);
     386             :   explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
     387             : 
     388     5180805 :   TargetLibraryInfo &getTLI() { return TLI; }
     389             :   const TargetLibraryInfo &getTLI() const { return TLI; }
     390             : };
     391             : 
     392             : } // end namespace llvm
     393             : 
     394             : #endif

Generated by: LCOV version 1.13