CoverageMapping: Reader - update for the modified profile data format by add function's hash to coverage function records.

[arphaman]

Summary

Recently, the profile data format was updated to allow for multiple functions with the same name. The updated indexing api requires the code coverage tool to know the function's hash as well as the function's name to get the execution counts for a function. This patch updates the CoverageMappingReader which now also stores function hashes in function records.

[arphaman]

Closed by commit rL216207 (authored by @arphaman).

llvm/trunk/include/llvm/ProfileData/CoverageMappingReader.h

 namespace llvm {
 namespace coverage {
 
 class ObjectFileCoverageMappingReader;
 
 /// \brief Coverage mapping information for a single function.
 struct CoverageMappingRecord {
   StringRef FunctionName;
+  uint64_t FunctionHash;
   ArrayRef<StringRef> Filenames;
   ArrayRef<CounterExpression> Expressions;
   ArrayRef<CounterMappingRegion> MappingRegions;
 };
 
 /// \brief A file format agnostic iterator over coverage mapping data.
 class CoverageMappingIterator
     : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> {

 
 /// \brief Reader for the coverage mapping data that is emitted by the
 /// frontend and stored in an object file.
 class ObjectFileCoverageMappingReader {
 public:
   struct ProfileMappingRecord {
     CoverageMappingVersion Version;
     StringRef FunctionName;
+    uint64_t FunctionHash;
     StringRef CoverageMapping;
     size_t FilenamesBegin;
     size_t FilenamesSize;
 
     ProfileMappingRecord(CoverageMappingVersion Version, StringRef FunctionName,
-                         StringRef CoverageMapping, size_t FilenamesBegin,
-                         size_t FilenamesSize)
+                         uint64_t FunctionHash, StringRef CoverageMapping,
+                         size_t FilenamesBegin, size_t FilenamesSize)
         : Version(Version), FunctionName(FunctionName),
-          CoverageMapping(CoverageMapping), FilenamesBegin(FilenamesBegin),
-          FilenamesSize(FilenamesSize) {}
+          FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
+          FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
   };
 
 private:
   std::error_code LastError;
   object::OwningBinary<object::ObjectFile> Object;
   std::vector<StringRef> Filenames;
   std::vector<ProfileMappingRecord> MappingRecords;
   size_t CurrentRecord;

llvm/trunk/lib/ProfileData/CoverageMappingReader.cpp

 
 namespace {
 /// \brief The coverage mapping data for a single function.
 /// It points to the function's name.
 template <typename IntPtrT> struct CoverageMappingFunctionRecord {
   IntPtrT FunctionNamePtr;
   uint32_t FunctionNameSize;
   uint32_t CoverageMappingSize;
+  uint64_t FunctionHash;
 };
 
 /// \brief The coverage mapping data for a single translation unit.
 /// It points to the array of function coverage mapping records and the encoded
 /// filenames array.
 template <typename IntPtrT> struct CoverageMappingTURecord {
   uint32_t FunctionRecordsSize;
   uint32_t FilenamesSize;
for (unsigned I = 0; I < TU->FunctionRecordsSize; ++I) {
         continue;
       UniqueFunctionMappingData.insert(MappingRecord.FunctionNamePtr);
       StringRef FunctionName;
       if (auto Err = ProfileNamesData.get(MappingRecord.FunctionNamePtr,
                                           MappingRecord.FunctionNameSize,
                                           FunctionName))
         return Err;
       Records.push_back(ObjectFileCoverageMappingReader::ProfileMappingRecord(
-          Version, FunctionName, Mapping, FilenamesBegin,
-          Filenames.size() - FilenamesBegin));
+          Version, FunctionName, MappingRecord.FunctionHash, Mapping,
+          FilenamesBegin, Filenames.size() - FilenamesBegin));
     }
   }
 
   return instrprof_error::success;
 }
 
 std::error_code ObjectFileCoverageMappingReader::readHeader() {
   ObjectFile *OF = Object.getBinary().get();
ObjectFileCoverageMappingReader::readNextRecord(CoverageMappingRecord &Record) {
   MappingRegions.clear();
   auto &R = MappingRecords[CurrentRecord];
   RawCoverageMappingReader Reader(
       R.FunctionName, R.CoverageMapping,
       makeArrayRef(Filenames.data() + R.FilenamesBegin, R.FilenamesSize),
       FunctionsFilenames, Expressions, MappingRegions);
   if (auto Err = Reader.read(Record))
     return Err;
+  Record.FunctionHash = R.FunctionHash;
   ++CurrentRecord;
   return success();
 }