TLI: Add addVectorizableFunctionsFromVecLib.

[mzolotukhin]

Summary

Add a function addVectorizableFunctionsFromVecLib to TLI. It is a wrapper for
addVectorizableFunctions and uses preset tables for known vector-libraries.

[hfinkel]

include/llvm/Analysis/TargetLibraryInfo.h

75

Please add a comment here explaining what this general feature is, and that it can be used via the addVectorizableFunctionsFromVecLib function.

135

Please don't put this implementation in the header. It will become large quickly.

[hfinkel]

Also, please add a command line option that can call addVectorizableFunctionsFromVecLib from the constructor so that we can test this via opt. We'll need this so that you can write regression tests for all of the Accelerate functions being added.

[mzolotukhin]

Address Hal's remarks:

• Move addVectorizableFunctionsFromVecLib from header file.
• Add CL option for specifying vector library.
• Add comment beforei 'enum VectorLibrary'.

[hfinkel]

include/llvm/Analysis/TargetLibraryInfo.h

20

This should be included only in the .cpp file.

327

This does not belong here; just have it in the .cpp file.

[hfinkel]

lib/Analysis/TargetLibraryInfo.cpp

19

Implied by the other comments, but this should be static.

[mzolotukhin]

• Make ClVectorLibrary static.

[hfinkel]

LGTM, pending the addition of regression tests.

[mzolotukhin]

• Add regression tests for veclib calls.

[mzolotukhin]

• Fix regex in the regression tests.

[hfinkel]

This test depends on the X86 code model, and needs to be in the test/Transforms/LoopVectorize/X86 directory.

test/Transforms/LoopVectorize/veclib-calls.ll

7 ↗

(On Diff #21671)

Please, here and below, check for the 'v' in the name, so we make sure that we've actually produced a call to the vector function, not an incorrect call to the scalar function with vector types somehow.

[hfinkel]

Also, please add tests where you convert the intrinsics into function calls. Please add a negative test where the nobuiltin attribute is present.

[mzolotukhin]

• Update tests according to Hal's remarks.

[hfinkel]

LGTM.

[mzolotukhin]

Hal, thank you for the reviews!

The patch was committed in r232531.

include/llvm/Analysis/TargetLibraryInfo.h

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 /// VecDesc - Describes a possible vectorization of a function.
 /// Function 'VectorFnName' is equivalent to 'ScalarFnName' vectorized
 /// by a factor 'VectorizationFactor'.
 struct VecDesc {
   const char *ScalarFnName;
   const char *VectorFnName;
class TargetLibraryInfoImpl {
 
   /// Vectorization descriptors - sorted by ScalarFnName.
   std::vector<VecDesc> VectorDescs;
   /// Scalarization descriptors - same content as VectorDescs but sorted based
   /// on VectorFnName rather than ScalarFnName.
   std::vector<VecDesc> ScalarDescs;
 
 public:
+  /// \brief  List of known vector-functions libraries.
+  ///
+  /// The vector-functions library defines, which functions are vectorizable
+  /// and with which factor. The library can be specified by either frontend,
+  /// or a commandline option, and then used by
+  /// addVectorizableFunctionsFromVecLib for filling up the tables of
+  /// vectorizable functions.
+  enum VectorLibrary {
+    NoLibrary, // Don't use any vector library.
+    Accelerate // Use Accelerate framework.
+  };
+
   TargetLibraryInfoImpl();
   explicit TargetLibraryInfoImpl(const Triple &T);
 
   // Provide value semantics.
   TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI);
   TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI);
   TargetLibraryInfoImpl &operator=(const TargetLibraryInfoImpl &TLI);
   TargetLibraryInfoImpl &operator=(TargetLibraryInfoImpl &&TLI);
public:
   ///
   /// This can be used for options like -fno-builtin.
   void disableAllFunctions();
 
   /// addVectorizableFunctions - Add a set of scalar -> vector mappings,
   /// queryable via getVectorizedFunction and getScalarizedFunction.
   void addVectorizableFunctions(ArrayRef<VecDesc> Fns);
 
+  /// Calls addVectorizableFunctions with a known preset of functions for the
+  /// given vector library.
+  void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib);
+
   /// isFunctionVectorizable - Return true if the function F has a
   /// vector equivalent with vectorization factor VF.
   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
     return !getVectorizedFunction(F, VF).empty();
   }
 
   /// isFunctionVectorizable - Return true if the function F has a
   /// vector equivalent with any vectorization factor.
public:
   TargetLibraryInfoWrapperPass();
   explicit TargetLibraryInfoWrapperPass(const Triple &T);
   explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
 
   TargetLibraryInfo &getTLI() { return TLI; }
   const TargetLibraryInfo &getTLI() const { return TLI; }
 };
 
+extern cl::opt<TargetLibraryInfoImpl::VectorLibrary> ClVectorLibrary;
 } // end namespace llvm
 
 #endif

lib/Analysis/TargetLibraryInfo.cpp

 //===-- TargetLibraryInfo.cpp - Runtime library information ----------------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLibraryInfo class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/CommandLine.h"
 using namespace llvm;
 
+cl::opt<TargetLibraryInfoImpl::VectorLibrary> llvm::ClVectorLibrary(
+    "vector-library", cl::Hidden, cl::desc("Vector functions library"),
+    cl::init(TargetLibraryInfoImpl::NoLibrary),
+    cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none",
+                          "No vector functions library"),
+               clEnumValN(TargetLibraryInfoImpl::Accelerate, "Accelerate",
+                          "Accelerate framework"),
+               clEnumValEnd));
+
 const char* TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
   {
 #define TLI_DEFINE_STRING
 #include "llvm/Analysis/TargetLibraryInfo.def"
   };
 
 static bool hasSinCosPiStret(const Triple &T) {
   // Only Darwin variants have _stret versions of combined trig functions.
if (!T.isOSLinux()) {
     TLI.setUnavailable(LibFunc::fstatvfs64);
     TLI.setUnavailable(LibFunc::ftello64);
     TLI.setUnavailable(LibFunc::lstat64);
     TLI.setUnavailable(LibFunc::open64);
     TLI.setUnavailable(LibFunc::stat64);
     TLI.setUnavailable(LibFunc::statvfs64);
     TLI.setUnavailable(LibFunc::tmpfile64);
   }
+
+  TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
   // Default to everything being available.
   memset(AvailableArray, -1, sizeof(AvailableArray));
 
   initialize(*this, Triple(), StandardNames);
 }

 void TargetLibraryInfoImpl::addVectorizableFunctions(ArrayRef<VecDesc> Fns) {
   VectorDescs.insert(VectorDescs.end(), Fns.begin(), Fns.end());
   std::sort(VectorDescs.begin(), VectorDescs.end(), compareByScalarFnName);
 
   ScalarDescs.insert(ScalarDescs.end(), Fns.begin(), Fns.end());
   std::sort(ScalarDescs.begin(), ScalarDescs.end(), compareByVectorFnName);
 }
 
+void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib(
+    enum VectorLibrary VecLib) {
+  switch (VecLib) {
+  case Accelerate: {
+    const VecDesc VecFuncs[] = {
+        {"expf", "vexpf", 4},
+        {"llvm.exp.f32", "vexpf", 4},
+        {"logf", "vlogf", 4},
+        {"llvm.log.f32", "vlogf", 4},
+        {"sqrtf", "vsqrtf", 4},
+        {"llvm.sqrt.f32", "vsqrtf", 4},
+        {"fabsf", "vfabsf", 4},
+        {"llvm.fabs.f32", "vfabsf", 4},
+    };
+    addVectorizableFunctions(VecFuncs);
+    break;
+  }
+  case NoLibrary:
+    break;
+  }
+}
+
 bool TargetLibraryInfoImpl::isFunctionVectorizable(StringRef funcName) const {
   funcName = sanitizeFunctionName(funcName);
   if (funcName.empty())
     return false;
 
   std::vector<VecDesc>::const_iterator I = std::lower_bound(
       VectorDescs.begin(), VectorDescs.end(), funcName,
       compareWithScalarFnName);