Revert "[TLI] Per-function fveclib for math library used for vectorization"

[mehdi_amini]

Summary

This reverts commit 60c642e74be6af86906d9f3d982728be7bd4329f.

This patch is making the TLI "closed" for a predefined set of VecLib
while at the moment it is extensible for anyone to customize when using
LLVM as a library.
Reverting while we figure out a way to re-land it without losing the
generality of the current API.

[tejohnson]

lgtm

[wenlei]

@mehdi_amini @tejohnson When can we re-land this (with tweaks)? I'm under the impression that a test case demonstrating the 3rd party usage will be added very soon after this revert, then we can tweak the original patch to accommodate that usage, and re-land asap. Or am I missing something there? I'd like to get this unblocked asap. Currently we have to keep this as a private patch on our end which is a bit cumbersome, and I think this one can be useful for others too. Thanks..

[tejohnson]

In D77925#2016299, @wenlei wrote:

@mehdi_amini @tejohnson When can we re-land this (with tweaks)? I'm under the impression that a test case demonstrating the 3rd party usage will be added very soon after this revert, then we can tweak the original patch to accommodate that usage, and re-land asap. Or am I missing something there? I'd like to get this unblocked asap. Currently we have to keep this as a private patch on our end which is a bit cumbersome, and I think this one can be useful for others too. Thanks..

@bkramer can you work with Wenlei on this (original patch is D77632).

@wenlei, in the meantime you can see the use case here:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/xla/service/cpu/compiler_functor.cc#L198
for revising the patch.

[wenlei]

In D77925#2016326, @tejohnson wrote:

In D77925#2016299, @wenlei wrote:

@mehdi_amini @tejohnson When can we re-land this (with tweaks)? I'm under the impression that a test case demonstrating the 3rd party usage will be added very soon after this revert, then we can tweak the original patch to accommodate that usage, and re-land asap. Or am I missing something there? I'd like to get this unblocked asap. Currently we have to keep this as a private patch on our end which is a bit cumbersome, and I think this one can be useful for others too. Thanks..

@bkramer can you work with Wenlei on this (original patch is D77632).

@wenlei, in the meantime you can see the use case here:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/xla/service/cpu/compiler_functor.cc#L198
for revising the patch.

Thanks for pointer, @tejohnson. Looks like we need a way for others to provide a set of vector functions. How about we introduced a dedicated VecLib type Custom, in addition to the existing ones (Accelerate, SVML and MASSV), and expose a public API addCustomVectorizableFunctions(ArrayRef<VecDesc> Fns) for TLII to allow registering custom function list. This way we preserve the openness through Custom, but also keep it clean and structured.

Then for XLA, you just need to specify -fveclib=Custom and call addCustomVectorizableFunctions instead of addVectorizableFunctions.

[mehdi_amini]

I rather have a non closed list of veclib: if you just have a map keyed by string instead of an enum it should just work out?

[wenlei]

In D77925#2220169, @mehdi_amini wrote:

I rather have a non closed list of veclib: if you just have a map keyed by string instead of an enum it should just work out?

The veclib type is also tied to the accepted values for -fveclib, which is a list of supported lib, anything outside of the list is rejected with error. If you want to allow arbitrary strings as key, it's inconsistent with the restricted/closed values for -fveclib. So basically there's no openness from clang/llvm tool, while there was some openness through the libraries. I think by introducing a "Custom" veclib type, we can solve the impedance mismatch there. And in the XLA case, conceptually it's an indeed a custom veclib, right? Functionality-wise, Custom should just work for XLA usage too.

[wenlei]

In D77925#2220177, @wenlei wrote:

In D77925#2220169, @mehdi_amini wrote:

I rather have a non closed list of veclib: if you just have a map keyed by string instead of an enum it should just work out?

The veclib type is also tied to the accepted values for -fveclib, which is a list of supported lib, anything outside of the list is rejected with error. If you want to allow arbitrary strings as key, it's inconsistent with the restricted/closed values for -fveclib. So basically there's no openness from clang/llvm tool, while there was some openness through the libraries. I think by introducing a "Custom" veclib type, we can solve the impedance mismatch there. And in the XLA case, conceptually it's an indeed a custom veclib, right? Functionality-wise, Custom should just work for XLA usage too.

@mehdi_amini @tejohnson thoughts on the above?

[mehdi_amini]

Overall that would likely work for XLA. Something I'd like to mention though in response to:

The veclib type is also tied to the accepted values for -fveclib, which is a list of supported lib,

-fveclib is a Clang thing, it shouldn't limit what LLVM does. Of course LLVM needs to support Clang, but does not have to inherit the limitation of map 1:1 to Clang UI.
In particular as a library, it isn't clear why we would make the choice to write LLVM VecLib support this way.

[tejohnson]

In D77925#2229484, @mehdi_amini wrote:

Overall that would likely work for XLA. Something I'd like to mention though in response to:

The veclib type is also tied to the accepted values for -fveclib, which is a list of supported lib,

-fveclib is a Clang thing, it shouldn't limit what LLVM does. Of course LLVM needs to support Clang, but does not have to inherit the limitation of map 1:1 to Clang UI.
In particular as a library, it isn't clear why we would make the choice to write LLVM VecLib support this way.

Is there any benefit to keeping a closed list like this in LLVM? If not (and presumably clang is checking for valid values of -fveclib), then I think I agree with @mehdi_amini. Unless there is an efficiency reason for doing it via an enum. It's been awhile since I looked through this code in detail...

[wenlei]

In D77925#2236519, @tejohnson wrote:

In D77925#2229484, @mehdi_amini wrote:

Overall that would likely work for XLA. Something I'd like to mention though in response to:

The veclib type is also tied to the accepted values for -fveclib, which is a list of supported lib,

-fveclib is a Clang thing, it shouldn't limit what LLVM does. Of course LLVM needs to support Clang, but does not have to inherit the limitation of map 1:1 to Clang UI.
In particular as a library, it isn't clear why we would make the choice to write LLVM VecLib support this way.

Fair point. I was trying to differentiate the accepted veclib from any other custom lib. I guess it's somewhat like namespace, even though built-in ones are different from user defined ones, the underlying support doesn't have to differentiate them.

Is there any benefit to keeping a closed list like this in LLVM? If not (and presumably clang is checking for valid values of -fveclib), then I think I agree with @mehdi_amini. Unless there is an efficiency reason for doing it via an enum. It's been awhile since I looked through this code in detail...

I think performance should be fine, the attributes on functions are in string form already. TLI compatibility check will involve a string compare, but a short string compare shouldn't be disastrous. I was mainly trying to let LLVM match clang's supported list.

Will get back to this hopefully next week.

clang/lib/CodeGen/BackendUtil.cpp

static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
   PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
 }
 
 static void addMemTagOptimizationPasses(const PassManagerBuilder &Builder,
                                         legacy::PassManagerBase &PM) {
   PM.add(createStackSafetyGlobalInfoWrapperPass(/*SetMetadata=*/true));
 }
 
-static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple) {
-  return new TargetLibraryInfoImpl(TargetTriple);
+static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
+                                         const CodeGenOptions &CodeGenOpts) {
+  TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);
+
+  switch (CodeGenOpts.getVecLib()) {
+  case CodeGenOptions::Accelerate:
+    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
+    break;
+  case CodeGenOptions::MASSV:
+    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::MASSV);
+    break;
+  case CodeGenOptions::SVML:
+    TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
+    break;
+  default:
+    break;
+  }
+  return TLII;
 }
 
 static void addSymbolRewriterPass(const CodeGenOptions &Opts,
                                   legacy::PassManager *MPM) {
   llvm::SymbolRewriter::RewriteDescriptorList DL;
 
   llvm::SymbolRewriter::RewriteMapParser MapParser;
   for (const auto &MapFile : Opts.RewriteMapFiles)
void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
   if (CodeGenOpts.DisableLLVMPasses)
     return;
 
   // Figure out TargetLibraryInfo.  This needs to be added to MPM and FPM
   // manually (and not via PMBuilder), since some passes (eg. InstrProfiling)
   // are inserted before PMBuilder ones - they'd get the default-constructed
   // TLI with an unknown target otherwise.
   Triple TargetTriple(TheModule->getTargetTriple());
-  std::unique_ptr<TargetLibraryInfoImpl> TLII(createTLII(TargetTriple));
+  std::unique_ptr<TargetLibraryInfoImpl> TLII(
+      createTLII(TargetTriple, CodeGenOpts));
 
   // If we reached here with a non-empty index file name, then the index file
   // was empty and we are not performing ThinLTO backend compilation (used in
   // testing in a distributed build environment). Drop any the type test
   // assume sequences inserted for whole program vtables so that codegen doesn't
   // complain.
   if (!CodeGenOpts.ThinLTOIndexFile.empty())
     MPM.add(createLowerTypeTestsPass(/*ExportSummary=*/nullptr,

 }
 
 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                        BackendAction Action,
                                        raw_pwrite_stream &OS,
                                        raw_pwrite_stream *DwoOS) {
   // Add LibraryInfo.
   llvm::Triple TargetTriple(TheModule->getTargetTriple());
-  std::unique_ptr<TargetLibraryInfoImpl> TLII(createTLII(TargetTriple));
+  std::unique_ptr<TargetLibraryInfoImpl> TLII(
+      createTLII(TargetTriple, CodeGenOpts));
   CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));
 
   // Normal mode, emit a .s or .o file by running the code generator. Note,
   // this also adds codegenerator level optimization passes.
   CodeGenFileType CGFT = getCodeGenFileType(Action);
 
   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
   // "codegen" passes so that it isn't run multiple times when there is
#include "llvm/Support/Extension.def"
   ModuleAnalysisManager MAM(CodeGenOpts.DebugPassManager);
 
   // Register the AA manager first so that our version is the one used.
   FAM.registerPass([&] { return PB.buildDefaultAAPipeline(); });
 
   // Register the target library analysis directly and give it a customized
   // preset TLI.
   Triple TargetTriple(TheModule->getTargetTriple());
-  std::unique_ptr<TargetLibraryInfoImpl> TLII(createTLII(TargetTriple));
+  std::unique_ptr<TargetLibraryInfoImpl> TLII(
+      createTLII(TargetTriple, CodeGenOpts));
   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 
   // Register all the basic analyses with the managers.
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);

clang/lib/CodeGen/CGCall.cpp

if (llvm::is_contained(NBA->builtinNames(), "*")) {
     FuncAttrs.addAttribute("no-builtins");
     return;
   }
 
   // And last, add the rest of the builtin names.
   llvm::for_each(NBA->builtinNames(), AddNoBuiltinAttr);
 }
 
-static void addVectLibAttributes(llvm::AttrBuilder &FuncAttrs,
-                                 const CodeGenOptions &CodeGenOpts) {
-  StringRef AttributeName = "veclib";
-  switch (CodeGenOpts.getVecLib()) {
-  case CodeGenOptions::Accelerate:
-    FuncAttrs.addAttribute(AttributeName, "Accelerate");
-    break;
-  case CodeGenOptions::MASSV:
-    FuncAttrs.addAttribute(AttributeName, "MASSV");
-    break;
-  case CodeGenOptions::SVML:
-    FuncAttrs.addAttribute(AttributeName, "SVML");
-    break;
-  case CodeGenOptions::NoLibrary:
-    break;
-  }
-}
-
 void CodeGenModule::ConstructAttributeList(
     StringRef Name, const CGFunctionInfo &FI, CGCalleeInfo CalleeInfo,
     llvm::AttributeList &AttrList, unsigned &CallingConv, bool AttrOnCallSite) {
   llvm::AttrBuilder FuncAttrs;
   llvm::AttrBuilder RetAttrs;
 
   CallingConv = FI.getEffectiveCallingConvention();
   if (FI.isNoReturn())
void CodeGenModule::ConstructAttributeList(
   // Attach "no-builtins" attributes to:
   // * call sites: both `nobuiltin` and "no-builtins" or "no-builtin-<name>".
   // * definitions: "no-builtins" or "no-builtin-<name>" only.
   // The attributes can come from:
   // * LangOpts: -ffreestanding, -fno-builtin, -fno-builtin-<name>
   // * FunctionDecl attributes: __attribute__((no_builtin(...)))
   addNoBuiltinAttributes(FuncAttrs, getLangOpts(), NBA);
 
-  // Attach "veclib" attribute to function based on '-fveclib' setting.
-  addVectLibAttributes(FuncAttrs, getCodeGenOpts());
-
   ConstructDefaultFnAttrList(Name, HasOptnone, AttrOnCallSite, FuncAttrs);
 
   // This must run after constructing the default function attribute list
   // to ensure that the speculative load hardening attribute is removed
   // in the case where the -mspeculative-load-hardening flag was passed.
   if (TargetDecl) {
     if (TargetDecl->hasAttr<NoSpeculativeLoadHardeningAttr>())
       FuncAttrs.removeAttribute(llvm::Attribute::SpeculativeLoadHardening);

clang/test/CodeGen/libcalls-veclib.c

-// RUN: %clang_cc1 -S -emit-llvm -fveclib=SVML -o - %s | FileCheck --check-prefixes=SVML %s
-// RUN: %clang_cc1 -S -emit-llvm -fveclib=Accelerate -o - %s | FileCheck --check-prefixes=ACCELERATE %s
-// RUN: %clang_cc1 -S -emit-llvm -fveclib=MASSV -o - %s | FileCheck --check-prefixes=MASSV %s
-// RUN: %clang_cc1 -S -emit-llvm -fveclib=none -o - %s | FileCheck --check-prefixes=NOLIB %s
-// RUN: %clang_cc1 -S -emit-llvm -o - %s | FileCheck --check-prefixes=NOLIB %s
-
-int main() {
-  return 0;
-}
-
-// SVML: "veclib"="SVML"
-// ACCELERATE: "veclib"="Accelerate"
-// MASSV: "veclib"="MASSV"
-// NOLIB-NOT: "veclib"
 

llvm/include/llvm/Analysis/TargetLibraryInfo.h

 ///
 /// This class constructs tables that hold the target library information and
 /// make it available. However, it is somewhat expensive to compute and only
 /// depends on the triple. So users typically interact with the \c
 /// TargetLibraryInfo wrapper below.
 class TargetLibraryInfoImpl {
   friend class TargetLibraryInfo;
 
-public:
-  /// 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 {
-    Accelerate, // Use Accelerate framework.
-    MASSV,      // IBM MASS vector library.
-    SVML,       // Intel short vector math library.
-    NumVecLibs, // Number of supported vector libraries.
-    NoLibrary   // Don't use any vector library.
-  };
-
-private:
   unsigned char AvailableArray[(NumLibFuncs+3)/4];
   llvm::DenseMap<unsigned, std::string> CustomNames;
   static StringLiteral const StandardNames[NumLibFuncs];
   bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
 
   enum AvailabilityState {
     StandardName = 3, // (memset to all ones)
     CustomName = 1,
     Unavailable = 0  // (memset to all zeros)
   };
   void setState(LibFunc F, AvailabilityState State) {
     AvailableArray[F/4] &= ~(3 << 2*(F&3));
     AvailableArray[F/4] |= State << 2*(F&3);
   }
   AvailabilityState getState(LibFunc F) const {
     return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
   }
 
-  /// Vector library descriptor for all supported ones.
-  struct VectorLibraryDescriptors {
-    /// 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;
-  } VecLibDescs[NumVecLibs];
 
   /// Return true if the function type FTy is valid for the library function
   /// F, regardless of whether the function is available.
   bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,
                               const DataLayout *DL) const;
 
-  /// Add a set of scalar -> vector mappings, queryable via
-  /// getVectorizedFunction and getScalarizedFunction.
-  void addVectorizableFunctions(ArrayRef<VecDesc> Fns,
-                                VectorLibraryDescriptors &VetLibDescs);
-
-  /// Calls addVectorizableFunctionsFromVecLib with a known preset of functions
-  /// for the given vector library.
-  void addVectorizableFunctionsFromVecLib(enum VectorLibrary VecLib,
-                                          VectorLibraryDescriptors &VetLibDesc);
-
 public:
+  /// 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.
+    MASSV,      // IBM MASS vector library.
+    SVML        // Intel short vector math library.
+  };
+
   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);
void setAvailableWithName(LibFunc F, StringRef Name) {
     }
   }
 
   /// Disables all builtins.
   ///
   /// This can be used for options like -fno-builtin.
   void disableAllFunctions();
 
-  /// Populate VectorLibraryDescriptors for all supported vector libraries.
-  void addAllVectorizableFunctions();
+  /// 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);
 
   /// Return true if the function F has a vector equivalent with vectorization
   /// factor VF.
-  bool isFunctionVectorizable(StringRef F, unsigned VF,
-                              VectorLibrary vecLib) const {
-    return !getVectorizedFunction(F, VF, vecLib).empty();
+  bool isFunctionVectorizable(StringRef F, unsigned VF) const {
+    return !getVectorizedFunction(F, VF).empty();
   }
 
   /// Return true if the function F has a vector equivalent with any
   /// vectorization factor.
-  bool isFunctionVectorizable(StringRef F, VectorLibrary vecLib) const;
+  bool isFunctionVectorizable(StringRef F) const;
 
   /// Return the name of the equivalent of F, vectorized with factor VF. If no
   /// such mapping exists, return the empty string.
-  StringRef getVectorizedFunction(StringRef F, unsigned VF,
-                                  VectorLibrary vecLib) const;
+  StringRef getVectorizedFunction(StringRef F, unsigned VF) const;
 
   /// Return true if the function F has a scalar equivalent, and set VF to be
   /// the vectorization factor.
-  bool isFunctionScalarizable(StringRef F, unsigned &VF,
-                              VectorLibrary vecLib) const {
-    return !getScalarizedFunction(F, VF, vecLib).empty();
+  bool isFunctionScalarizable(StringRef F, unsigned &VF) const {
+    return !getScalarizedFunction(F, VF).empty();
   }
 
   /// Return the name of the equivalent of F, scalarized. If no such mapping
   /// exists, return the empty string.
   ///
   /// Set VF to the vectorization factor.
-  StringRef getScalarizedFunction(StringRef F, unsigned &VF,
-                                  VectorLibrary vecLib) const;
+  StringRef getScalarizedFunction(StringRef F, unsigned &VF) const;
 
   /// Set to true iff i32 parameters to library functions should have signext
   /// or zeroext attributes if they correspond to C-level int or unsigned int,
   /// respectively.
   void setShouldExtI32Param(bool Val) {
     ShouldExtI32Param = Val;
   }
 
public:
   }
 
   /// Returns the size of the wchar_t type in bytes or 0 if the size is unknown.
   /// This queries the 'wchar_size' metadata.
   unsigned getWCharSize(const Module &M) const;
 
   /// Returns the largest vectorization factor used in the list of
   /// vector functions.
-  unsigned getWidestVF(StringRef ScalarF, VectorLibrary vecLib) const;
+  unsigned getWidestVF(StringRef ScalarF) const;
 };
 
 /// Provides information about what library functions are available for
 /// the current target.
 ///
 /// This both allows optimizations to handle them specially and frontends to
 /// disable such optimizations through -fno-builtin etc.
 class TargetLibraryInfo {
   friend class TargetLibraryAnalysis;
   friend class TargetLibraryInfoWrapperPass;
 
   /// The global (module level) TLI info.
   const TargetLibraryInfoImpl *Impl;
 
-  /// Vector library available for vectorization.
-  TargetLibraryInfoImpl::VectorLibrary VectLibrary =
-      TargetLibraryInfoImpl::NoLibrary;
-
   /// Support for -fno-builtin* options as function attributes, overrides
   /// information in global TargetLibraryInfoImpl.
   BitVector OverrideAsUnavailable;
 
-  TargetLibraryInfoImpl::VectorLibrary
-  getVecLibFromName(const StringRef &VecLibName) {
-    if (VecLibName == "Accelerate")
-      return TargetLibraryInfoImpl::Accelerate;
-    else if (VecLibName == "MASSV")
-      return TargetLibraryInfoImpl::MASSV;
-    else if (VecLibName == "SVML")
-      return TargetLibraryInfoImpl::SVML;
-    return TargetLibraryInfoImpl::NoLibrary;
-  }
-
 public:
   explicit TargetLibraryInfo(const TargetLibraryInfoImpl &Impl,
-                             Optional<const Function *> F = None);
+                             Optional<const Function *> F = None)
+      : Impl(&Impl), OverrideAsUnavailable(NumLibFuncs) {
+    if (!F)
+      return;
+    if ((*F)->hasFnAttribute("no-builtins"))
+      disableAllFunctions();
+    else {
+      // Disable individual libc/libm calls in TargetLibraryInfo.
+      LibFunc LF;
+      AttributeSet FnAttrs = (*F)->getAttributes().getFnAttributes();
+      for (const Attribute &Attr : FnAttrs) {
+        if (!Attr.isStringAttribute())
+          continue;
+        auto AttrStr = Attr.getKindAsString();
+        if (!AttrStr.consume_front("no-builtin-"))
+          continue;
+        if (getLibFunc(AttrStr, LF))
+          setUnavailable(LF);
+      }
+    }
+  }
 
   // Provide value semantics.
   TargetLibraryInfo(const TargetLibraryInfo &TLI)
-      : Impl(TLI.Impl), VectLibrary(TLI.VectLibrary),
-        OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
+      : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
   TargetLibraryInfo(TargetLibraryInfo &&TLI)
-      : Impl(TLI.Impl), VectLibrary(TLI.VectLibrary),
-        OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
+      : Impl(TLI.Impl), OverrideAsUnavailable(TLI.OverrideAsUnavailable) {}
   TargetLibraryInfo &operator=(const TargetLibraryInfo &TLI) {
     Impl = TLI.Impl;
-    VectLibrary = TLI.VectLibrary;
     OverrideAsUnavailable = TLI.OverrideAsUnavailable;
     return *this;
   }
   TargetLibraryInfo &operator=(TargetLibraryInfo &&TLI) {
     Impl = TLI.Impl;
-    VectLibrary = TLI.VectLibrary;
     OverrideAsUnavailable = TLI.OverrideAsUnavailable;
     return *this;
   }
 
   /// Determine whether a callee with the given TLI can be inlined into
-  /// caller with this TLI, based on 'nobuiltin', `veclib` attributes.
-  /// When requested, allow inlining into a caller with a superset of the
-  /// callee's attributes, which is conservatively correct.
+  /// caller with this TLI, based on 'nobuiltin' attributes. When requested,
+  /// allow inlining into a caller with a superset of the callee's nobuiltin
+  /// attributes, which is conservatively correct.
   bool areInlineCompatible(const TargetLibraryInfo &CalleeTLI,
                            bool AllowCallerSuperset) const {
     if (!AllowCallerSuperset)
-      return VectLibrary == CalleeTLI.VectLibrary &&
-             OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;
+      return OverrideAsUnavailable == CalleeTLI.OverrideAsUnavailable;
     BitVector B = OverrideAsUnavailable;
     B |= CalleeTLI.OverrideAsUnavailable;
-    // We can inline if the union of the caller and callee's attributes
-    // is no stricter than the caller's attributes.
-    bool VecLibCompatible =
-        (VectLibrary == CalleeTLI.VectLibrary) ||
-        CalleeTLI.VectLibrary == TargetLibraryInfoImpl::NoLibrary;
-    return B == OverrideAsUnavailable && VecLibCompatible;
+    // We can inline if the union of the caller and callee's nobuiltin
+    // attributes is no stricter than the caller's nobuiltin attributes.
+    return B == OverrideAsUnavailable;
   }
 
   /// Searches for a particular function name.
   ///
   /// If it is one of the known library functions, return true and set F to the
   /// corresponding value.
   bool getLibFunc(StringRef funcName, LibFunc &F) const {
     return Impl->getLibFunc(funcName, F);
TargetLibraryInfoImpl::AvailabilityState getState(LibFunc F) const {
     return Impl->getState(F);
   }
 
   /// Tests whether a library function is available.
   bool has(LibFunc F) const {
     return getState(F) != TargetLibraryInfoImpl::Unavailable;
   }
   bool isFunctionVectorizable(StringRef F, unsigned VF) const {
-    return Impl->isFunctionVectorizable(F, VF, VectLibrary);
+    return Impl->isFunctionVectorizable(F, VF);
   }
   bool isFunctionVectorizable(StringRef F) const {
-    return Impl->isFunctionVectorizable(F, VectLibrary);
+    return Impl->isFunctionVectorizable(F);
   }
   StringRef getVectorizedFunction(StringRef F, unsigned VF) const {
-    return Impl->getVectorizedFunction(F, VF, VectLibrary);
+    return Impl->getVectorizedFunction(F, VF);
   }
 
   /// Tests if the function is both available and a candidate for optimized code
   /// generation.
   bool hasOptimizedCodeGen(LibFunc F) const {
     if (getState(F) == TargetLibraryInfoImpl::Unavailable)
       return false;
     switch (F) {
public:
   }
   bool invalidate(Function &, const PreservedAnalyses &,
                   FunctionAnalysisManager::Invalidator &) {
     return false;
   }
   /// Returns the largest vectorization factor used in the list of
   /// vector functions.
   unsigned getWidestVF(StringRef ScalarF) const {
-    return Impl->getWidestVF(ScalarF, VectLibrary);
+    return Impl->getWidestVF(ScalarF);
   }
 
   /// Check if the function "F" is listed in a library known to LLVM.
   bool isKnownVectorFunctionInLibrary(StringRef F) const {
     return this->isFunctionVectorizable(F);
   }
 };
 

llvm/lib/Analysis/InlineCost.cpp

cl::desc("Minimum block frequency, expressed as a multiple of caller's "
              "entry frequency, for a callsite to be hot in the absence of "
              "profile information."));
 
 static cl::opt<bool> OptComputeFullInlineCost(
     "inline-cost-full", cl::Hidden, cl::init(false), cl::ZeroOrMore,
     cl::desc("Compute the full inline cost of a call site even when the cost "
              "exceeds the threshold."));
 
-static cl::opt<bool> InlineCallerSupersetTLI(
-    "inline-caller-superset-tli", cl::Hidden, cl::init(true), cl::ZeroOrMore,
-    cl::desc("Allow inlining when caller has a superset of callee's TLI "
+static cl::opt<bool> InlineCallerSupersetNoBuiltin(
+    "inline-caller-superset-nobuiltin", cl::Hidden, cl::init(true),
+    cl::ZeroOrMore,
+    cl::desc("Allow inlining when caller has a superset of callee's nobuiltin "
              "attributes."));
 
 namespace {
 class InlineCostCallAnalyzer;
 
 // This struct is used to store information about inline cost of a
 // particular instruction
 struct InstructionCostDetail {
static bool functionsHaveCompatibleAttributes(
     function_ref<const TargetLibraryInfo &(Function &)> &GetTLI) {
   // Note that CalleeTLI must be a copy not a reference. The legacy pass manager
   // caches the most recently created TLI in the TargetLibraryInfoWrapperPass
   // object, and always returns the same object (which is overwritten on each
   // GetTLI call). Therefore we copy the first result.
   auto CalleeTLI = GetTLI(*Callee);
   return TTI.areInlineCompatible(Caller, Callee) &&
          GetTLI(*Caller).areInlineCompatible(CalleeTLI,
-                                             InlineCallerSupersetTLI) &&
+                                             InlineCallerSupersetNoBuiltin) &&
          AttributeFuncs::areInlineCompatible(*Caller, *Callee);
 }
 
 int llvm::getCallsiteCost(CallBase &Call, const DataLayout &DL) {
   int Cost = 0;
   for (unsigned I = 0, E = Call.arg_size(); I != E; ++I) {
     if (Call.isByValArgument(I)) {
       // We approximate the number of loads and stores needed by dividing the

llvm/lib/Analysis/TargetLibraryInfo.cpp

static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
   // optimizations, so this situation should be fixed.
   if (T.isNVPTX()) {
     TLI.disableAllFunctions();
     TLI.setAvailable(LibFunc_nvvm_reflect);
   } else {
     TLI.setUnavailable(LibFunc_nvvm_reflect);
   }
 
-  TLI.addAllVectorizableFunctions();
+  TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
   // Default to everything being available.
   memset(AvailableArray, -1, sizeof(AvailableArray));
 
   initialize(*this, Triple(), StandardNames);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
   // Default to everything being available.
   memset(AvailableArray, -1, sizeof(AvailableArray));
 
   initialize(*this, T, StandardNames);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)
     : CustomNames(TLI.CustomNames), ShouldExtI32Param(TLI.ShouldExtI32Param),
       ShouldExtI32Return(TLI.ShouldExtI32Return),
       ShouldSignExtI32Param(TLI.ShouldSignExtI32Param) {
   memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
-  for (unsigned i = 0; i < NumVecLibs; i++)
-    VecLibDescs[i] = TLI.VecLibDescs[i];
+  VectorDescs = TLI.VectorDescs;
+  ScalarDescs = TLI.ScalarDescs;
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
     : CustomNames(std::move(TLI.CustomNames)),
       ShouldExtI32Param(TLI.ShouldExtI32Param),
       ShouldExtI32Return(TLI.ShouldExtI32Return),
       ShouldSignExtI32Param(TLI.ShouldSignExtI32Param) {
   std::move(std::begin(TLI.AvailableArray), std::end(TLI.AvailableArray),
             AvailableArray);
-  for (unsigned i = 0; i < NumVecLibs; i++)
-    VecLibDescs[i] = TLI.VecLibDescs[i];
+  VectorDescs = TLI.VectorDescs;
+  ScalarDescs = TLI.ScalarDescs;
 }
 
 TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const TargetLibraryInfoImpl &TLI) {
   CustomNames = TLI.CustomNames;
   ShouldExtI32Param = TLI.ShouldExtI32Param;
   ShouldExtI32Return = TLI.ShouldExtI32Return;
   ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
   memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));

 static bool compareWithScalarFnName(const VecDesc &LHS, StringRef S) {
   return LHS.ScalarFnName < S;
 }
 
 static bool compareWithVectorFnName(const VecDesc &LHS, StringRef S) {
   return LHS.VectorFnName < S;
 }
 
-void TargetLibraryInfoImpl::addAllVectorizableFunctions() {
-  addVectorizableFunctionsFromVecLib(Accelerate, VecLibDescs[Accelerate]);
-  addVectorizableFunctionsFromVecLib(MASSV, VecLibDescs[MASSV]);
-  addVectorizableFunctionsFromVecLib(SVML, VecLibDescs[SVML]);
-}
-
-void TargetLibraryInfoImpl::addVectorizableFunctions(
-    ArrayRef<VecDesc> Fns, VectorLibraryDescriptors &VecLibDesc) {
-  auto &VectorDescs = VecLibDesc.VectorDescs;
-  auto &ScalarDescs = VecLibDesc.ScalarDescs;
+void TargetLibraryInfoImpl::addVectorizableFunctions(ArrayRef<VecDesc> Fns) {
   VectorDescs.insert(VectorDescs.end(), Fns.begin(), Fns.end());
   llvm::sort(VectorDescs, compareByScalarFnName);
 
   ScalarDescs.insert(ScalarDescs.end(), Fns.begin(), Fns.end());
   llvm::sort(ScalarDescs, compareByVectorFnName);
 }
 
 void TargetLibraryInfoImpl::addVectorizableFunctionsFromVecLib(
-    enum VectorLibrary VecLib, VectorLibraryDescriptors &VetLibDesc) {
+    enum VectorLibrary VecLib) {
   switch (VecLib) {
   case Accelerate: {
     const VecDesc VecFuncs[] = {
     #define TLI_DEFINE_ACCELERATE_VECFUNCS
     #include "llvm/Analysis/VecFuncs.def"
     };
-    addVectorizableFunctions(VecFuncs, VetLibDesc);
+    addVectorizableFunctions(VecFuncs);
     break;
   }
   case MASSV: {
     const VecDesc VecFuncs[] = {
     #define TLI_DEFINE_MASSV_VECFUNCS
     #include "llvm/Analysis/VecFuncs.def"
     };
-    addVectorizableFunctions(VecFuncs, VetLibDesc);
+    addVectorizableFunctions(VecFuncs);
     break;
   }
   case SVML: {
     const VecDesc VecFuncs[] = {
     #define TLI_DEFINE_SVML_VECFUNCS
     #include "llvm/Analysis/VecFuncs.def"
     };
-    addVectorizableFunctions(VecFuncs, VetLibDesc);
+    addVectorizableFunctions(VecFuncs);
     break;
   }
-  default:
-    llvm_unreachable("Unexpected vector library");
+  case NoLibrary:
     break;
   }
 }
 
-bool TargetLibraryInfoImpl::isFunctionVectorizable(StringRef funcName,
-                                                   VectorLibrary vecLib) const {
+bool TargetLibraryInfoImpl::isFunctionVectorizable(StringRef funcName) const {
   funcName = sanitizeFunctionName(funcName);
-  if (funcName.empty() || vecLib >= NumVecLibs)
+  if (funcName.empty())
     return false;
 
-  auto &VectorDescs = VecLibDescs[vecLib].VectorDescs;
   std::vector<VecDesc>::const_iterator I =
       llvm::lower_bound(VectorDescs, funcName, compareWithScalarFnName);
   return I != VectorDescs.end() && StringRef(I->ScalarFnName) == funcName;
 }
 
-StringRef
-TargetLibraryInfoImpl::getVectorizedFunction(StringRef F, unsigned VF,
-                                             VectorLibrary vecLib) const {
+StringRef TargetLibraryInfoImpl::getVectorizedFunction(StringRef F,
+                                                       unsigned VF) const {
   F = sanitizeFunctionName(F);
-  if (F.empty() || vecLib >= NumVecLibs)
+  if (F.empty())
     return F;
-  auto &VectorDescs = VecLibDescs[vecLib].VectorDescs;
   std::vector<VecDesc>::const_iterator I =
       llvm::lower_bound(VectorDescs, F, compareWithScalarFnName);
   while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == F) {
     if (I->VectorizationFactor == VF)
       return I->VectorFnName;
     ++I;
   }
   return StringRef();
 }
 
-StringRef
-TargetLibraryInfoImpl::getScalarizedFunction(StringRef F, unsigned &VF,
-                                             VectorLibrary vecLib) const {
+StringRef TargetLibraryInfoImpl::getScalarizedFunction(StringRef F,
+                                                       unsigned &VF) const {
   F = sanitizeFunctionName(F);
-  if (F.empty() || vecLib >= NumVecLibs)
+  if (F.empty())
     return F;
 
-  auto &VectorDescs = VecLibDescs[vecLib].VectorDescs;
-  auto &ScalarDescs = VecLibDescs[vecLib].ScalarDescs;
   std::vector<VecDesc>::const_iterator I =
       llvm::lower_bound(ScalarDescs, F, compareWithVectorFnName);
   if (I == VectorDescs.end() || StringRef(I->VectorFnName) != F)
     return StringRef();
   VF = I->VectorizationFactor;
   return I->ScalarFnName;
 }
 
-TargetLibraryInfo::TargetLibraryInfo(const TargetLibraryInfoImpl &Impl,
-                                     Optional<const Function *> F)
-    : Impl(&Impl), OverrideAsUnavailable(NumLibFuncs) {
-  if (!F)
-    return;
-
-  StringRef VectLib = (*F)->getFnAttribute("veclib").getValueAsString();
-  if (!VectLib.empty())
-    VectLibrary = getVecLibFromName(VectLib);
-  else
-    VectLibrary = ClVectorLibrary;
-
-  if ((*F)->hasFnAttribute("no-builtins"))
-    disableAllFunctions();
-  else {
-    // Disable individual libc/libm calls in TargetLibraryInfo.
-    LibFunc LF;
-    AttributeSet FnAttrs = (*F)->getAttributes().getFnAttributes();
-    for (const Attribute &Attr : FnAttrs) {
-      if (!Attr.isStringAttribute())
-        continue;
-      auto AttrStr = Attr.getKindAsString();
-      if (!AttrStr.consume_front("no-builtin-"))
-        continue;
-      if (getLibFunc(AttrStr, LF))
-        setUnavailable(LF);
-    }
-  }
-}
-
 TargetLibraryInfo TargetLibraryAnalysis::run(const Function &F,
                                              FunctionAnalysisManager &) {
   if (!BaselineInfoImpl)
     BaselineInfoImpl =
         TargetLibraryInfoImpl(Triple(F.getParent()->getTargetTriple()));
   return TargetLibraryInfo(*BaselineInfoImpl, &F);
 }
 

 
 // Register the basic pass.
 INITIALIZE_PASS(TargetLibraryInfoWrapperPass, "targetlibinfo",
                 "Target Library Information", false, true)
 char TargetLibraryInfoWrapperPass::ID = 0;
 
 void TargetLibraryInfoWrapperPass::anchor() {}
 
-unsigned TargetLibraryInfoImpl::getWidestVF(StringRef ScalarF,
-                                            VectorLibrary vecLib) const {
+unsigned TargetLibraryInfoImpl::getWidestVF(StringRef ScalarF) const {
   ScalarF = sanitizeFunctionName(ScalarF);
-  if (ScalarF.empty() || vecLib >= NumVecLibs)
+  if (ScalarF.empty())
     return 1;
 
   unsigned VF = 1;
-  auto &VectorDescs = VecLibDescs[vecLib].VectorDescs;
   std::vector<VecDesc>::const_iterator I =
       llvm::lower_bound(VectorDescs, ScalarF, compareWithScalarFnName);
   while (I != VectorDescs.end() && StringRef(I->ScalarFnName) == ScalarF) {
     if (I->VectorizationFactor > VF)
       VF = I->VectorizationFactor;
     ++I;
   }
   return VF;
 }

llvm/test/Transforms/Inline/inline-no-builtin-compatible.ll

 ; Test to ensure no inlining is allowed into a caller with fewer nobuiltin attributes.
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -inline | FileCheck %s
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s
 
 ; Make sure we don't inline callees into a caller with a superset of the
-; no builtin attributes when -inline-caller-superset-tli=false.
-; RUN: opt < %s -inline-caller-superset-tli=false -mtriple=x86_64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s --check-prefix=NOSUPERSET
+; no builtin attributes when -inline-caller-superset-nobuiltin=false.
+; RUN: opt < %s -inline-caller-superset-nobuiltin=false -mtriple=x86_64-unknown-linux-gnu -S -passes='cgscc(inline)' | FileCheck %s --check-prefix=NOSUPERSET
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @allbuiltins() {
 entry:
   %call = call i32 (...) @externalfunc()
   ret i32 %call

llvm/test/Transforms/Inline/veclib-compat.ll

-; RUN: opt < %s -inline -inline-caller-superset-tli=true -S | FileCheck %s --check-prefixes=COMMON
-; RUN: opt < %s -passes='cgscc(inline)' -inline-caller-superset-tli=true -S | FileCheck %s --check-prefixes=COMMON
-; RUN: opt < %s -inline -inline-caller-superset-tli=false -S | FileCheck %s --check-prefixes=NOSUPERSET,COMMON
-; RUN: opt < %s -passes='cgscc(inline)' -inline-caller-superset-tli=false -S | FileCheck %s --check-prefixes=NOSUPERSET,COMMON
-
-
-
-define i32 @callee_svml(i8 %X) #0 {
-entry:
-  ret i32 1
-}
-
-define i32 @callee_massv(i8 %X) #1 {
-entry:
-  ret i32 1
-}
-
-define i32 @callee_nolibrary(i8 %X) {
-entry:
-  ret i32 1
-}
-
-define i32 @caller_svml() #0 {
-; COMMON-LABEL: define i32 @caller_svml()
-entry:
-  %rslt = call i32 @callee_massv(i8 123)
-; COMMON: call i32 @callee_massv
-  %tmp1 = call i32 @callee_nolibrary(i8 123)
-; NOSUPERSET: call i32 @callee_nolibrary
-  %tmp2 = call i32 @callee_svml(i8 123)
-; COMMON-NOT: call
-  ret i32 %rslt
-}
-
-define i32 @caller_nolibrary() {
-; COMMON-LABEL: define i32 @caller_nolibrary()
-entry:
-  %rslt = call i32 @callee_svml(i8 123)
-; COMMON: call i32 @callee_svml
-  %tmp1 = call i32 @callee_massv(i8 123)
-; COMMON: call i32 @callee_massv
-  %tmp2 = call i32 @callee_nolibrary(i8 123)
-; COMMON-NOT: call
-  ret i32 %rslt
-}
-
-attributes #0 = { "veclib"="SVML" }
-attributes #1 = { "veclib"="MASSV" }