include/llvm/Analysis/TargetLibraryInfo.h

   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/ArrayRef.h"
  15 #include "llvm/ADT/Optional.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/IR/Function.h"
  18 #include "llvm/IR/Module.h"
  19 #include "llvm/Pass.h"
  20
  21 // BEGIN ANDROID-SPECIFIC
  22 #ifdef WIN32
  23 #ifdef fseeko
  24 #undef fseeko
  25 #endif
  26 #ifdef ftello
  27 #undef ftello
  28 #endif
  29 #endif  // WIN32
  30 // END ANDROID-SPECIFIC
  31
  32 namespace llvm {
  33 /// VecDesc - Describes a possible vectorization of a function.
  34 /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
  35 /// by a factor 'VectorizationFactor'.
  36 struct VecDesc {
  37   const char *ScalarFnName;
  38   const char *VectorFnName;
  39   unsigned VectorizationFactor;
  40 };
  41 class PreservedAnalyses;
  42
  43   namespace LibFunc {
  44     enum Func {
  45 #define TLI_DEFINE_ENUM
  46 #include "llvm/Analysis/TargetLibraryInfo.def"
  47
  48       NumLibFuncs
  49     };
  50   }
  51
  52 /// \brief Implementation of the target library information.
  53 ///
  54 /// This class constructs tables that hold the target library information and
  55 /// make it available. However, it is somewhat expensive to compute and only
  56 /// depends on the triple. So users typicaly interact with the \c
  57 /// TargetLibraryInfo wrapper below.
  58 class TargetLibraryInfoImpl {
  59   friend class TargetLibraryInfo;
  60
  61   unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
  62   llvm::DenseMap<unsigned, std::string> CustomNames;
  63   static const char *const StandardNames[LibFunc::NumLibFuncs];
  64
  65   enum AvailabilityState {
  66     StandardName = 3, // (memset to all ones)
  67     CustomName = 1,
  68     Unavailable = 0  // (memset to all zeros)
  69   };
  70   void setState(LibFunc::Func F, AvailabilityState State) {
  71     AvailableArray[F/4] &= ~(3 << 2*(F&3));
  72     AvailableArray[F/4] |= State << 2*(F&3);
  73   }
  74   AvailabilityState getState(LibFunc::Func F) const {
  75     return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
  76   }
  77
  78   /// Vectorization descriptors - sorted by ScalarFnName.
  79   std::vector<VecDesc> VectorDescs;
  80   /// Scalarization descriptors - same content as VectorDescs but sorted based
  81   /// on VectorFnName rather than ScalarFnName.
  82   std::vector<VecDesc> ScalarDescs;
  83
  84 public:
  85   /// \brief  List of known vector-functions libraries.
  86   ///
  87   /// The vector-functions library defines, which functions are vectorizable
  88   /// and with which factor. The library can be specified by either frontend,
  89   /// or a commandline option, and then used by
  90   /// addVectorizableFunctionsFromVecLib for filling up the tables of
  91   /// vectorizable functions.
  92   enum VectorLibrary {
  93     NoLibrary, // Don't use any vector library.
  94     Accelerate // Use Accelerate framework.
  95   };
  96
  97   TargetLibraryInfoImpl();
  98   explicit TargetLibraryInfoImpl(const Triple &T);
  99
 100   // Provide value semantics.
 101   TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
 102   TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
 103   TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
 104   TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI);
 105
 106   /// \brief Searches for a particular function name.
 107   ///
 108   /// If it is one of the known library functions, return true and set F to the
 109   /// corresponding value.
 110   bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
 111
 112   /// \brief Forces a function to be marked as unavailable.
 113   void setUnavailable(LibFunc::Func F) {
 114     setState(F, Unavailable);
 115   }
 116
 117   /// \brief Forces a function to be marked as available.
 118   void setAvailable(LibFunc::Func F) {
 119     setState(F, StandardName);
 120   }
 121
 122   /// \brief Forces a function to be marked as available and provide an
 123   /// alternate name that must be used.
 124   void setAvailableWithName(LibFunc::Func F, StringRef Name) {
 125     if (StandardNames[F] != Name) {
 126       setState(F, CustomName);
 127       CustomNames[F] = Name;
 128       assert(CustomNames.find(F) != CustomNames.end());
 129     } else {
 130       setState(F, StandardName);
 131     }
 132   }
 133
 134   /// \brief Disables all builtins.
 135   ///
 136   /// This can be used for options like -fno-builtin.
 137   void disableAllFunctions();
 138
 139   /// addVectorizableFunctions - Add a set of scalar -> vector mappings,
 140   /// queryable via getVectorizedFunction and getScalarizedFunction.
 141   void addVectorizableFunctions(ArrayRef<VecDesc> Fns);
 142
 143   /// Calls addVectorizableFunctions with a known preset of functions for the
 144   /// given vector library.
 145   void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib);
 146
 147   /// isFunctionVectorizable - Return true if the function F has a
 148   /// vector equivalent with vectorization factor VF.
 149   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
 150     return !getVectorizedFunction(F, VF).empty();
 151   }
 152
 153   /// isFunctionVectorizable - Return true if the function F has a
 154   /// vector equivalent with any vectorization factor.
 155   bool isFunctionVectorizable(StringRef F) const;
 156
 157   /// getVectorizedFunction - Return the name of the equivalent of
 158   /// F, vectorized with factor VF. If no such mapping exists,
 159   /// return the empty string.
 160   StringRef getVectorizedFunction(StringRef F, unsigned VF) const;
 161
 162   /// isFunctionScalarizable - Return true if the function F has a
 163   /// scalar equivalent, and set VF to be the vectorization factor.
 164   bool isFunctionScalarizable(StringRef F, unsigned &VF) const {
 165     return !getScalarizedFunction(F, VF).empty();
 166   }
 167
 168   /// getScalarizedFunction - Return the name of the equivalent of
 169   /// F, scalarized. If no such mapping exists, return the empty string.
 170   ///
 171   /// Set VF to the vectorization factor.
 172   StringRef getScalarizedFunction(StringRef F, unsigned &VF) const;
 173 };
 174
 175 /// \brief Provides information about what library functions are available for
 176 /// the current target.
 177 ///
 178 /// This both allows optimizations to handle them specially and frontends to
 179 /// disable such optimizations through -fno-builtin etc.
 180 class TargetLibraryInfo {
 181   friend class TargetLibraryAnalysis;
 182   friend class TargetLibraryInfoWrapperPass;
 183
 184   const TargetLibraryInfoImpl *Impl;
 185
 186 public:
 187   explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl) : Impl(&Impl) {}
 188
 189   // Provide value semantics.
 190   TargetLibraryInfo(const TargetLibraryInfo &TLI) : Impl(TLI.Impl) {}
 191   TargetLibraryInfo(TargetLibraryInfo &&TLI) : Impl(TLI.Impl) {}
 192   TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
 193     Impl = TLI.Impl;
 194     return *this;
 195   }
 196   TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
 197     Impl = TLI.Impl;
 198     return *this;
 199   }
 200
 201   /// \brief Searches for a particular function name.
 202   ///
 203   /// If it is one of the known library functions, return true and set F to the
 204   /// corresponding value.
 205   bool getLibFunc(StringRef funcName, LibFunc::Func &F) const {
 206     return Impl->getLibFunc(funcName, F);
 207   }
 208
 209   /// \brief Tests whether a library function is available.
 210   bool has(LibFunc::Func F) const {
 211     return Impl->getState(F) != TargetLibraryInfoImpl::Unavailable;
 212   }
 213   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
 214     return Impl->isFunctionVectorizable(F, VF);
 215   };
 216   bool isFunctionVectorizable(StringRef F) const {
 217     return Impl->isFunctionVectorizable(F);
 218   };
 219   StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
 220     return Impl->getVectorizedFunction(F, VF);
 221   };
 222
 223   /// \brief Tests if the function is both available and a candidate for
 224   /// optimized code generation.
 225   bool hasOptimizedCodeGen(LibFunc::Func F) const {
 226     if (Impl->getState(F) == TargetLibraryInfoImpl::Unavailable)
 227       return false;
 228     switch (F) {
 229     default: break;
 230     case LibFunc::copysign:  case LibFunc::copysignf:  case LibFunc::copysignl:
 231     case LibFunc::fabs:      case LibFunc::fabsf:      case LibFunc::fabsl:
 232     case LibFunc::sin:       case LibFunc::sinf:       case LibFunc::sinl:
 233     case LibFunc::cos:       case LibFunc::cosf:       case LibFunc::cosl:
 234     case LibFunc::sqrt:      case LibFunc::sqrtf:      case LibFunc::sqrtl:
 235     case LibFunc::sqrt_finite: case LibFunc::sqrtf_finite:
 236                                                   case LibFunc::sqrtl_finite:
 237     case LibFunc::fmax:      case LibFunc::fmaxf:      case LibFunc::fmaxl:
 238     case LibFunc::fmin:      case LibFunc::fminf:      case LibFunc::fminl:
 239     case LibFunc::floor:     case LibFunc::floorf:     case LibFunc::floorl:
 240     case LibFunc::nearbyint: case LibFunc::nearbyintf: case LibFunc::nearbyintl:
 241     case LibFunc::ceil:      case LibFunc::ceilf:      case LibFunc::ceill:
 242     case LibFunc::rint:      case LibFunc::rintf:      case LibFunc::rintl:
 243     case LibFunc::round:     case LibFunc::roundf:     case LibFunc::roundl:
 244     case LibFunc::trunc:     case LibFunc::truncf:     case LibFunc::truncl:
 245     case LibFunc::log2:      case LibFunc::log2f:      case LibFunc::log2l:
 246     case LibFunc::exp2:      case LibFunc::exp2f:      case LibFunc::exp2l:
 247     case LibFunc::memcmp:    case LibFunc::strcmp:     case LibFunc::strcpy:
 248     case LibFunc::stpcpy:    case LibFunc::strlen:     case LibFunc::strnlen:
 249     case LibFunc::memchr:
 250       return true;
 251     }
 252     return false;
 253   }
 254
 255   StringRef getName(LibFunc::Func F) const {
 256     auto State = Impl->getState(F);
 257     if (State == TargetLibraryInfoImpl::Unavailable)
 258       return StringRef();
 259     if (State == TargetLibraryInfoImpl::StandardName)
 260       return Impl->StandardNames[F];
 261     assert(State == TargetLibraryInfoImpl::CustomName);
 262     return Impl->CustomNames.find(F)->second;
 263   }
 264
 265   /// \brief Handle invalidation from the pass manager.
 266   ///
 267   /// If we try to invalidate this info, just return false. It cannot become
 268   /// invalid even if the module changes.
 269   bool invalidate(Module &, const PreservedAnalyses &) { return false; }
 270 };
 271
 272 /// \brief Analysis pass providing the \c TargetLibraryInfo.
 273 ///
 274 /// Note that this pass's result cannot be invalidated, it is immutable for the
 275 /// life of the module.
 276 class TargetLibraryAnalysis {
 277 public:
 278   typedef TargetLibraryInfo Result;
 279
 280   /// \brief Opaque, unique identifier for this analysis pass.
 281   static void *ID() { return (void *)&PassID; }
 282
 283   /// \brief Default construct the library analysis.
 284   ///
 285   /// This will use the module's triple to construct the library info for that
 286   /// module.
 287   TargetLibraryAnalysis() {}
 288
 289   /// \brief Construct a library analysis with preset info.
 290   ///
 291   /// This will directly copy the preset info into the result without
 292   /// consulting the module's triple.
 293   TargetLibraryAnalysis(TargetLibraryInfoImpl PresetInfoImpl)
 294       : PresetInfoImpl(std::move(PresetInfoImpl)) {}
 295
 296   // Move semantics. We spell out the constructors for MSVC.
 297   TargetLibraryAnalysis(TargetLibraryAnalysis &&Arg)
 298       : PresetInfoImpl(std::move(Arg.PresetInfoImpl)), Impls(std::move(Arg.Impls)) {}
 299   TargetLibraryAnalysis &operator=(TargetLibraryAnalysis &&RHS) {
 300     PresetInfoImpl = std::move(RHS.PresetInfoImpl);
 301     Impls = std::move(RHS.Impls);
 302     return *this;
 303   }
 304
 305   TargetLibraryInfo run(Module &M);
 306   TargetLibraryInfo run(Function &F);
 307
 308   /// \brief Provide access to a name for this pass for debugging purposes.
 309   static StringRef name() { return "TargetLibraryAnalysis"; }
 310
 311 private:
 312   static char PassID;
 313
 314   Optional<TargetLibraryInfoImpl> PresetInfoImpl;
 315
 316   StringMap<std::unique_ptr<TargetLibraryInfoImpl>> Impls;
 317
 318   TargetLibraryInfoImpl &lookupInfoImpl(Triple T);
 319 };
 320
 321 class TargetLibraryInfoWrapperPass : public ImmutablePass {
 322   TargetLibraryInfoImpl TLIImpl;
 323   TargetLibraryInfo TLI;
 324
 325   virtual void anchor();
 326
 327 public:
 328   static char ID;
 329   TargetLibraryInfoWrapperPass();
 330   explicit TargetLibraryInfoWrapperPass(const Triple &T);
 331   explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
 332
 333   TargetLibraryInfo &getTLI() { return TLI; }
 334   const TargetLibraryInfo &getTLI() const { return TLI; }
 335 };
 336
 337 } // end namespace llvm
 338
 339 #endif