LCOV - code coverage report
Current view: top level - include/llvm/Analysis - TargetLibraryInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 45 45 100.0 %
Date: 2017-09-14 15:23:50 Functions: 7 8 87.5 %
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      276859 : 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     1147459 :     AvailableArray[F/4] &= ~(3 << 2*(F&3));
      62      860415 :     AvailableArray[F/4] |= State << 2*(F&3);
      63             :   }
      64             :   AvailabilityState getState(LibFunc F) const {
      65     1700286 :     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     1186593 :     setState(F, Unavailable);
     118             :   }
     119             : 
     120             :   /// Forces a function to be marked as available.
     121             :   void setAvailable(LibFunc F) {
     122         574 :     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        2372 :   void setAvailableWithName(LibFunc F, StringRef Name) {
     128        2372 :     if (StandardNames[F] != Name) {
     129        2372 :       setState(F, CustomName);
     130        7116 :       CustomNames[F] = Name;
     131             :       assert(CustomNames.find(F) != CustomNames.end());
     132             :     } else {
     133             :       setState(F, StandardName);
     134             :     }
     135        2372 :   }
     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         670 :     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       33301 :     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       33301 :     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       33301 :     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       39836 :   explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
     218             : 
     219             :   // Provide value semantics.
     220             :   TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
     221        4158 :   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     8642396 :     return Impl->getLibFunc(funcName, F);
     237             :   }
     238             : 
     239             :   bool getLibFunc(const Function &FDecl, LibFunc &F) const {
     240     8947048 :     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      456312 :   bool getLibFunc(ImmutableCallSite CS, LibFunc &F) const {
     246     1365314 :     return !CS.isNoBuiltin() && CS.getCalledFunction() &&
     247     1365314 :            getLibFunc(*(CS.getCalledFunction()), F);
     248             :   }
     249             : 
     250             :   /// Tests whether a library function is available.
     251             :   bool has(LibFunc F) const {
     252     2209250 :     return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
     253             :   }
     254             :   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
     255         670 :     return Impl->isFunctionVectorizable(F, VF);
     256             :   }
     257             :   bool isFunctionVectorizable(StringRef F) const {
     258        1369 :     return Impl->isFunctionVectorizable(F);
     259             :   }
     260             :   StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
     261          64 :     return Impl->getVectorizedFunction(F, VF);
     262             :   }
     263             : 
     264             :   /// Tests if the function is both available and a candidate for optimized code
     265             :   /// generation.
     266        7567 :   bool hasOptimizedCodeGen(LibFunc F) const {
     267       15134 :     if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
     268             :       return false;
     269        7564 :     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        6048 :     return false;
     294             :   }
     295             : 
     296      586493 :   StringRef getName(LibFunc F) const {
     297     1172986 :     auto State = Impl->getState(F);
     298      586493 :     if (State == TargetLibraryInfoImpl::Unavailable)
     299          72 :       return StringRef();
     300      586421 :     if (State == TargetLibraryInfoImpl::StandardName)
     301      586394 :       return Impl->StandardNames[F];
     302             :     assert(State == TargetLibraryInfoImpl::CustomName);
     303          54 :     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          36 :     if (Impl->ShouldExtI32Param)
     311             :       return Signed ? Attribute::SExt : Attribute::ZExt;
     312          28 :     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         105 :     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        9400 : 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        4560 :   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         162 :       : 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       37486 : 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     4508372 :   TargetLibraryInfo &getTLI() { return TLI; }
     393             :   const TargetLibraryInfo &getTLI() const { return TLI; }
     394             : };
     395             : 
     396             : } // end namespace llvm
     397             : 
     398             : #endif

Generated by: LCOV version 1.13