[instrprof][NFC] Refactor out the common logic for getProfileKind.

[snehasish]

Summary

The logic for getProfileKind for RawInstrProfReader and
InstrProfReaderIndex is similar. To avoid duplication, move the logic
from the header to InstrProfReader.cpp and introduce a static method
which implements the common code.

[ellis]

LGTM

llvm/include/llvm/ProfileData/InstrProfReader.h

bool hasSingleByteCoverage() const override {
     return (Version & VARIANT_MASK_BYTE_COVERAGE) != 0;
   }
 
   bool functionEntryOnly() const override {
     return (Version & VARIANT_MASK_FUNCTION_ENTRY_ONLY) != 0;
   }
 
   /// Returns a BitsetEnum describing the attributes of the raw instr profile.
-  InstrProfKind getProfileKind() const override {
-    InstrProfKind ProfileKind = InstrProfKind::Unknown;
-    if (Version & VARIANT_MASK_IR_PROF) {
-      ProfileKind |= InstrProfKind::IR;
-    }
-    if (Version & VARIANT_MASK_CSIR_PROF) {
-      ProfileKind |= InstrProfKind::CS;
-    }
-    if (Version & VARIANT_MASK_INSTR_ENTRY) {
-      ProfileKind |= InstrProfKind::BB;
-    }
-    if (Version & VARIANT_MASK_BYTE_COVERAGE) {
-      ProfileKind |= InstrProfKind::SingleByteCoverage;
-    }
-    if (Version & VARIANT_MASK_FUNCTION_ENTRY_ONLY) {
-      ProfileKind |= InstrProfKind::FunctionEntryOnly;
-    }
-    return ProfileKind;
-  }
+  InstrProfKind getProfileKind() const override;
 
   InstrProfSymtab &getSymtab() override {
     assert(Symtab.get());
     return *Symtab.get();
   }
 
 private:
   Error createSymtab(InstrProfSymtab &Symtab);
public:
   bool hasSingleByteCoverage() const override {
     return (FormatVersion & VARIANT_MASK_BYTE_COVERAGE) != 0;
   }
 
   bool functionEntryOnly() const override {
     return (FormatVersion & VARIANT_MASK_FUNCTION_ENTRY_ONLY) != 0;
   }
 
-  InstrProfKind getProfileKind() const override {
-    InstrProfKind ProfileKind = InstrProfKind::Unknown;
-    if (FormatVersion & VARIANT_MASK_IR_PROF) {
-      ProfileKind |= InstrProfKind::IR;
-    }
-    if (FormatVersion & VARIANT_MASK_CSIR_PROF) {
-      ProfileKind |= InstrProfKind::CS;
-    }
-    if (FormatVersion & VARIANT_MASK_INSTR_ENTRY) {
-      ProfileKind |= InstrProfKind::BB;
-    }
-    if (FormatVersion & VARIANT_MASK_BYTE_COVERAGE) {
-      ProfileKind |= InstrProfKind::SingleByteCoverage;
-    }
-    if (FormatVersion & VARIANT_MASK_FUNCTION_ENTRY_ONLY) {
-      ProfileKind |= InstrProfKind::FunctionEntryOnly;
-    }
-    return ProfileKind;
-  }
+  InstrProfKind getProfileKind() const override;
 
   Error populateSymtab(InstrProfSymtab &Symtab) override {
     return Symtab.create(HashTable->keys());
   }
 };
 
 /// Name matcher supporting fuzzy matching of symbol names to names in profiles.
 class InstrProfReaderRemapper {

llvm/lib/ProfileData/InstrProfReader.cpp

 #include <limits>
 #include <memory>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
+// Extracts the variant information from the top 8 bits in the version and
+// returns an enum specifying the variants present.
+static InstrProfKind getProfileKindFromVersion(uint64_t Version) {
+  InstrProfKind ProfileKind = InstrProfKind::Unknown;
+  if (Version & VARIANT_MASK_IR_PROF) {
+    ProfileKind |= InstrProfKind::IR;
+  }
+  if (Version & VARIANT_MASK_CSIR_PROF) {
+    ProfileKind |= InstrProfKind::CS;
+  }
+  if (Version & VARIANT_MASK_INSTR_ENTRY) {
+    ProfileKind |= InstrProfKind::BB;
+  }
+  if (Version & VARIANT_MASK_BYTE_COVERAGE) {
+    ProfileKind |= InstrProfKind::SingleByteCoverage;
+  }
+  if (Version & VARIANT_MASK_FUNCTION_ENTRY_ONLY) {
+    ProfileKind |= InstrProfKind::FunctionEntryOnly;
+  }
+  return ProfileKind;
+}
+
 static Expected<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(const Twine &Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Path, /*IsText=*/true);
   if (std::error_code EC = BufferOrErr.getError())
     return errorCodeToError(EC);
   return std::move(BufferOrErr.get());
 }
Error TextInstrProfReader::readNextRecord(NamedInstrProfRecord &Record) {
   // Check if value profile data exists and read it if so.
   if (Error E = readValueProfileData(Record))
     return error(std::move(E));
 
   return success();
 }
 
 template <class IntPtrT>
+InstrProfKind RawInstrProfReader<IntPtrT>::getProfileKind() const {
+  return getProfileKindFromVersion(Version);
+}
+
+template <class IntPtrT>
 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
   if (DataBuffer.getBufferSize() < sizeof(uint64_t))
     return false;
   uint64_t Magic =
     *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
   return RawInstrProf::getMagic<IntPtrT>() == Magic ||
          sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
 }
InstrProfReaderIndex<HashTableImpl>::InstrProfReaderIndex(
     uint64_t Version) {
   FormatVersion = Version;
   HashTable.reset(HashTableImpl::Create(
       Buckets, Payload, Base,
       typename HashTableImpl::InfoType(HashType, Version)));
   RecordIterator = HashTable->data_begin();
 }
 
+template <typename HashTableImpl>
+InstrProfKind InstrProfReaderIndex<HashTableImpl>::getProfileKind() const {
+  return getProfileKindFromVersion(FormatVersion);
+}
+
 namespace {
 /// A remapper that does not apply any remappings.
 class InstrProfReaderNullRemapper : public InstrProfReaderRemapper {
   InstrProfReaderIndexBase &Underlying;
 
 public:
   InstrProfReaderNullRemapper(InstrProfReaderIndexBase &Underlying)
       : Underlying(Underlying) {}