[MemProf] Make hasSingleAllocType helper non-static

[tejohnson]

Summary

As suggested in D140908, make the hasSingleAllocType helper non-static
so that it can be used in other files. Add unit testing.

[snehasish]

lgtm

llvm/include/llvm/Analysis/MemoryProfileInfo.h

 MDNode *buildCallstackMetadata(ArrayRef<uint64_t> CallStack, LLVMContext &Ctx);
 
 /// Returns the stack node from an MIB metadata node.
 MDNode *getMIBStackNode(const MDNode *MIB);
 
 /// Returns the allocation type from an MIB metadata node.
 AllocationType getMIBAllocType(const MDNode *MIB);
 
+/// True if the AllocTypes bitmask contains just a single type.
+bool hasSingleAllocType(uint8_t AllocTypes);
+
 /// Class to build a trie of call stack contexts for a particular profiled
 /// allocation call, along with their associated allocation types.
 /// The allocation will be at the root of the trie, which is then used to
 /// compute the minimum lists of context ids needed to associate a call context
 /// with a single allocation type.
 class CallStackTrie {
 private:
   struct CallStackTrieNode {

llvm/lib/Analysis/MemoryProfileInfo.cpp

 
 static void addAllocTypeAttribute(LLVMContext &Ctx, CallBase *CI,
                                   AllocationType AllocType) {
   auto AllocTypeString = getAllocTypeAttributeString(AllocType);
   auto A = llvm::Attribute::get(Ctx, "memprof", AllocTypeString);
   CI->addFnAttr(A);
 }
 
-static bool hasSingleAllocType(uint8_t AllocTypes) {
+bool llvm::memprof::hasSingleAllocType(uint8_t AllocTypes) {
   const unsigned NumAllocTypes = llvm::popcount(AllocTypes);
   assert(NumAllocTypes != 0);
   return NumAllocTypes == 1;
 }
 
 void CallStackTrie::addCallStack(AllocationType AllocType,
                                  ArrayRef<uint64_t> StackIds) {
   bool First = true;

llvm/unittests/Analysis/MemoryProfileInfoTest.cpp

TEST_F(MemoryProfileInfoTest, GetAllocType) {
   // Short lived with less accesses per byte than threshold is not cold.
   EXPECT_EQ(
       getAllocType(/*MaxAccessCount=*/MemProfAccessesPerByteColdThreshold - 1,
                    /*MinSize=*/1,
                    /*MinLifetime=*/MemProfMinLifetimeColdThreshold * 1000 - 1),
       AllocationType::NotCold);
 }
 
+// Test the hasSingleAllocType helper.
+TEST_F(MemoryProfileInfoTest, SingleAllocType) {
+  uint8_t NotCold = (uint8_t)AllocationType::NotCold;
+  uint8_t Cold = (uint8_t)AllocationType::Cold;
+  EXPECT_TRUE(hasSingleAllocType(NotCold));
+  EXPECT_TRUE(hasSingleAllocType(Cold));
+  EXPECT_FALSE(hasSingleAllocType(NotCold | Cold));
+}
+
 // Test buildCallstackMetadata helper.
 TEST_F(MemoryProfileInfoTest, BuildCallStackMD) {
   LLVMContext C;
   MDNode *CallStack = buildCallstackMetadata({1, 2, 3}, C);
   ASSERT_EQ(CallStack->getNumOperands(), 3u);
   unsigned ExpectedId = 1;
   for (auto &Op : CallStack->operands()) {
     auto *StackId = mdconst::dyn_extract<ConstantInt>(Op);