[NFC] Simplify TargetLibraryInfo implementation

[gchatelet]

Summary

Use PackedBitVector instead of raw char array. This simplifies the implementation but also allocates on the heap instead of the stack; which is not ideal.
We could specialize PackedBitVector so it takes a SmallBitVector instead of the BitVector but looking at the implementation SmallBitVector is actually a TinyBitVector which can only pack a handful of bits.

At this point I'm not clear on the benefits of this patch. Feel free to push back.

[courbet]

This makes the code easier to read indeed, but this comes at the expense of allocations and less locality, so I would refrain from doing this unless we have a good reason.
Or: gather some data in the codebase as to whether a template-parametric SmallBitVector would find other usages, implement it, and use it here as a 3rd parameter to PackedBitVector.

Either way I don't have a strong opinion on the matter, but I'm pretty sure other people might, so please add other reviewers.

llvm/include/llvm/Analysis/TargetLibraryInfo.h

396

Do that in a separate patch ?

llvm/include/llvm/Analysis/TargetLibraryInfo.h

 //===-- TargetLibraryInfo.h - Library information ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 #define LLVM_ANALYSIS_TARGETLIBRARYINFO_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/PackedVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Pass.h"
 
 namespace llvm {

 ///
 /// 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;
 
-  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);
-  }
+
+  PackedVector<AvailabilityState, 2> Availability;
+  llvm::DenseMap<unsigned, std::string> CustomNames;
+  static StringLiteral const StandardNames[NumLibFuncs];
+  bool ShouldExtI32Param, ShouldExtI32Return, ShouldSignExtI32Param;
+
+  void setState(LibFunc F, AvailabilityState State) { Availability[F] = State; }
+  AvailabilityState getState(LibFunc F) const { return Availability[F]; }
 
   /// 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;
 
   /// Return true if the function type FTy is valid for the library function
class TargetLibraryInfoWrapperPass : public ImmutablePass {
   virtual void anchor();
 
 public:
   static char ID;
   TargetLibraryInfoWrapperPass();
   explicit TargetLibraryInfoWrapperPass(const Triple &T);
   explicit TargetLibraryInfoWrapperPass(const TargetLibraryInfoImpl &TLI);
 
-  TargetLibraryInfo &getTLI(const Function &F LLVM_ATTRIBUTE_UNUSED) {
+  TargetLibraryInfo &getTLI(const Function &F) {
+    (void)F;
     return TLI;
   }
-  const TargetLibraryInfo &
-  getTLI(const Function &F LLVM_ATTRIBUTE_UNUSED) const {
+  const TargetLibraryInfo &getTLI(const Function &F) const {
+    (void)F;
     return TLI;
   }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Analysis/TargetLibraryInfo.cpp

if (T.isNVPTX()) {
     TLI.setAvailable(LibFunc_nvvm_reflect);
   } else {
     TLI.setUnavailable(LibFunc_nvvm_reflect);
   }
 
   TLI.addVectorizableFunctionsFromVecLib(ClVectorLibrary);
 }
 
-TargetLibraryInfoImpl::TargetLibraryInfoImpl() {
-  // Default to everything being available.
-  memset(AvailableArray, -1, sizeof(AvailableArray));
-
+TargetLibraryInfoImpl::TargetLibraryInfoImpl() : Availability(NumLibFuncs) {
+  for (size_t I = 0; I < NumLibFuncs; ++I)
+    Availability[I] = AvailabilityState::StandardName;
   initialize(*this, Triple(), StandardNames);
 }
 
-TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T) {
-  // Default to everything being available.
-  memset(AvailableArray, -1, sizeof(AvailableArray));
-
+TargetLibraryInfoImpl::TargetLibraryInfoImpl(const Triple &T)
+    : Availability(NumLibFuncs) {
+  for (size_t I = 0; I < NumLibFuncs; ++I)
+    Availability[I] = AvailabilityState::StandardName;
   initialize(*this, T, StandardNames);
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(const TargetLibraryInfoImpl &TLI)
-    : CustomNames(TLI.CustomNames), ShouldExtI32Param(TLI.ShouldExtI32Param),
+    : Availability(TLI.Availability), CustomNames(TLI.CustomNames),
+      ShouldExtI32Param(TLI.ShouldExtI32Param),
       ShouldExtI32Return(TLI.ShouldExtI32Return),
       ShouldSignExtI32Param(TLI.ShouldSignExtI32Param) {
-  memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
   VectorDescs = TLI.VectorDescs;
   ScalarDescs = TLI.ScalarDescs;
 }
 
 TargetLibraryInfoImpl::TargetLibraryInfoImpl(TargetLibraryInfoImpl &&TLI)
-    : CustomNames(std::move(TLI.CustomNames)),
+    : Availability(std::move(TLI.Availability)),
+      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);
   VectorDescs = TLI.VectorDescs;
   ScalarDescs = TLI.ScalarDescs;
 }
 
 TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(const TargetLibraryInfoImpl &TLI) {
+  Availability = TLI.Availability;
   CustomNames = TLI.CustomNames;
   ShouldExtI32Param = TLI.ShouldExtI32Param;
   ShouldExtI32Return = TLI.ShouldExtI32Return;
   ShouldSignExtI32Param = TLI.ShouldSignExtI32Param;
-  memcpy(AvailableArray, TLI.AvailableArray, sizeof(AvailableArray));
   return *this;
 }
 
 TargetLibraryInfoImpl &TargetLibraryInfoImpl::operator=(TargetLibraryInfoImpl &&TLI) {
+  Availability = std::move(TLI.Availability);
   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);
   return *this;
 }
 
 static StringRef sanitizeFunctionName(StringRef funcName) {
   // Filter out empty names and names containing null bytes, those can't be in
   // our table.
   if (funcName.empty() || funcName.find('\0') != StringRef::npos)
     return StringRef();
bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl,
   
   const DataLayout *DL =
       FDecl.getParent() ? &FDecl.getParent()->getDataLayout() : nullptr;
   return getLibFunc(FDecl.getName(), F) &&
          isValidProtoForLibFunc(*FDecl.getFunctionType(), F, DL);
 }
 
 void TargetLibraryInfoImpl::disableAllFunctions() {
-  memset(AvailableArray, 0, sizeof(AvailableArray));
+  for (size_t I = 0; I < NumLibFuncs; ++I)
+    Availability[I] = AvailabilityState::Unavailable;
 }
 
 static bool compareByScalarFnName(const VecDesc &LHS, const VecDesc &RHS) {
   return LHS.ScalarFnName < RHS.ScalarFnName;
 }
 
 static bool compareByVectorFnName(const VecDesc &LHS, const VecDesc &RHS) {
   return LHS.VectorFnName < RHS.VectorFnName;