committing to save updates

Author: Andres Wearden

llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h

@@ -19,6 +19,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
@@ -375,6 +376,7 @@ struct CountedRegion : public CounterMappingRegion {
   uint64_t FalseExecutionCount;
   bool TrueFolded;
   bool FalseFolded;
+  StringRef ObjectFilename;
 
   CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount)
       : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
@@ -385,6 +387,12 @@ struct CountedRegion : public CounterMappingRegion {
       : CounterMappingRegion(R), ExecutionCount(ExecutionCount),
         FalseExecutionCount(FalseExecutionCount), TrueFolded(false),
         FalseFolded(false) {}
+  
+  CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount,
+          uint64_t FalseExecutionCount, StringRef ObjectFilename)
+: CounterMappingRegion(R), ExecutionCount(ExecutionCount),
+  FalseExecutionCount(FalseExecutionCount), TrueFolded(false),
+  FalseFolded(false), ObjectFilename(ObjectFilename) {}
 };
 
 /// MCDC Record grouping all information together.
@@ -731,9 +739,11 @@ struct FunctionRecord {
   std::vector<MCDCRecord> MCDCRecords;
   /// The number of times this function was executed.
   uint64_t ExecutionCount = 0;
+  /// The executable this function was compiled in
+  StringRef ObjectFilename;
 
-  FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
-      : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
+  FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames, StringRef ObjectFilename = "")
+      : Name(Name), Filenames(Filenames.begin(), Filenames.end()), ObjectFilename(ObjectFilename) {}
 
   FunctionRecord(FunctionRecord &&FR) = default;
   FunctionRecord &operator=(FunctionRecord &&) = default;
@@ -752,9 +762,10 @@ struct FunctionRecord {
       CountedBranchRegions.back().FalseFolded = Region.FalseCount.isZero();
       return;
     }
-    if (CountedRegions.empty())
+    if (CountedRegions.empty()){
       ExecutionCount = Count;
-    CountedRegions.emplace_back(Region, Count, FalseCount);
+    }
+    CountedRegions.emplace_back(Region, Count, FalseCount, ObjectFilename);
   }
 };
 
@@ -994,6 +1005,9 @@ class CoverageMapping {
   DenseMap<size_t, SmallVector<unsigned, 0>> FilenameHash2RecordIndices;
   std::vector<std::pair<std::string, uint64_t>> FuncHashMismatches;
   StringRef Arch;
+  DenseMap<std::pair<size_t, hash_code>, unsigned> RecordIndices;
+
+  std::map<std::pair<std::string, std::string>, std::vector<uint64_t>> AggregatedCounts;
 
   std::optional<bool> SingleByteCoverage;
 
@@ -1004,7 +1018,7 @@ class CoverageMapping {
     ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
     std::optional<std::reference_wrapper<IndexedInstrProfReader>>
         &ProfileReader,
-    CoverageMapping &Coverage, StringRef Arch);
+    CoverageMapping &Coverage, StringRef Arch, StringRef ObjectFilename = "");
 
   static Error loadFromReaders(
     ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
@@ -1018,15 +1032,15 @@ class CoverageMapping {
                std::optional<std::reference_wrapper<IndexedInstrProfReader>>
                    &ProfileReader,
                CoverageMapping &Coverage, bool &DataFound,
-               SmallVectorImpl<object::BuildID> *FoundBinaryIDs = nullptr);
+               SmallVectorImpl<object::BuildID> *FoundBinaryIDs = nullptr, StringRef ObjectFilename = "");
 
   /// Add a function record corresponding to \p Record.
   Error loadFunctionRecord(
       const CoverageMappingRecord &Record,
       const std::optional<std::reference_wrapper<IndexedInstrProfReader>>
-          &ProfileReader);
+          &ProfileReader, StringRef ObjectFilename = "");
 
-  Error loadFunctionRecord(const CoverageMappingRecord &Record, const std::optional<std::reference_wrapper<IndexedInstrProfReader>> &ProfileReader, const std::string &Arch);
+  Error loadFunctionRecord(const CoverageMappingRecord &Record, const std::optional<std::reference_wrapper<IndexedInstrProfReader>> &ProfileReader, const std::string &Arch, StringRef ObjectFilename = "");
 
   /// Look up the indices for function records which are at least partially
   /// defined in the specified file. This is guaranteed to return a superset of

llvm/include/llvm/ProfileData/InstrProf.h

@@ -635,9 +635,6 @@ class InstrProfSymtab {
 
   // Map the MD5 of the symbol name to the name.
   Error addSymbolName(StringRef SymbolName) {
-    // StringRef FuncName;
-    // StringRef ArchName = Architecture;
-    // std::tie(FuncName, ArchName) = SymbolName.split("#");
     if (SymbolName.empty())
       return make_error<InstrProfError>(instrprof_error::malformed,
                                         "symbol name is empty");
@@ -1075,6 +1072,7 @@ struct InstrProfRecord {
 struct NamedInstrProfRecord : InstrProfRecord {
   StringRef Name;
   uint64_t Hash;
+  StringRef Filename;
 
   // We reserve this bit as the flag for context sensitive profile record.
   static const int CS_FLAG_IN_FUNC_HASH = 60;

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

@@ -40,6 +40,7 @@
 #include <stack>
 #include <string>
 #include <system_error>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -975,7 +976,7 @@ class MCDCDecisionRecorder {
 Error CoverageMapping::loadFunctionRecord(
     const CoverageMappingRecord &Record,
     const std::optional<std::reference_wrapper<IndexedInstrProfReader>>
-        &ProfileReader) {
+        &ProfileReader, StringRef ObjectFilename) {
   StringRef OrigFuncName = Record.FunctionName;
   if (OrigFuncName.empty())
     return make_error<CoverageMapError>(coveragemap_error::malformed,
@@ -997,12 +998,10 @@ Error CoverageMapping::loadFunctionRecord(
 
   std::vector<uint64_t> Counts;
   if (ProfileReader) {
-    if (Error E = ProfileReader.value().get().getFunctionCounts(
-            Record.FunctionName, FuncArchHash, Counts)) {
+    if (Error E = ProfileReader.value().get().getFunctionCounts(Record.FunctionName, FuncArchHash, Counts)) {
       instrprof_error IPE = std::get<0>(InstrProfError::take(std::move(E)));
       if (IPE == instrprof_error::hash_mismatch) {
-        FuncHashMismatches.emplace_back(std::string(Record.FunctionName),
-                                        FuncArchHash);
+        FuncHashMismatches.emplace_back(std::string(Record.FunctionName), FuncArchHash);
         return Error::success();
       }
       if (IPE != instrprof_error::unknown_function)
@@ -1035,6 +1034,7 @@ Error CoverageMapping::loadFunctionRecord(
   } else {
     Bitmap = BitVector(getMaxBitmapSize(Record, false));
   }
+
   Ctx.setBitmap(std::move(Bitmap));
 
   assert(!Record.MappingRegions.empty() && "Function has no regions");
@@ -1049,7 +1049,7 @@ Error CoverageMapping::loadFunctionRecord(
     return Error::success();
 
   MCDCDecisionRecorder MCDCDecisions;
-  FunctionRecord Function(OrigFuncName, Record.Filenames);
+  FunctionRecord Function(OrigFuncName, Record.Filenames, ObjectFilename);
   for (const auto &Region : Record.MappingRegions) {
     // MCDCDecisionRegion should be handled first since it overlaps with
     // others inside.
@@ -1102,9 +1102,9 @@ Error CoverageMapping::loadFunctionRecord(
 
   // Don't create records for (filenames, function) pairs we've already seen.
   auto FilenamesHash = hash_combine_range(Record.Filenames);
-  if (!RecordProvenance[FilenamesHash].insert(hash_value(OrigFuncName)).second)
+  if (!RecordProvenance[FilenamesHash].insert(FuncArchHash).second){
     return Error::success();
-
+  }
   Functions.push_back(std::move(Function));
 
   // Performance optimization: keep track of the indices of the function records
@@ -1152,7 +1152,7 @@ Error CoverageMapping::loadFromReaders(
     ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
     std::optional<std::reference_wrapper<IndexedInstrProfReader>>
         &ProfileReader,
-    CoverageMapping &Coverage, StringRef Arch) {
+    CoverageMapping &Coverage, StringRef Arch, StringRef ObjectFilename) {
 
   Coverage.setArchitecture(Arch);
   assert(!Coverage.SingleByteCoverage || !ProfileReader ||
@@ -1165,7 +1165,7 @@ Error CoverageMapping::loadFromReaders(
       if (Error E = RecordOrErr.takeError())
         return E;
       const auto &Record = *RecordOrErr;
-      if (Error E = Coverage.loadFunctionRecord(Record, ProfileReader))
+      if (Error E = Coverage.loadFunctionRecord(Record, ProfileReader, ObjectFilename))
         return E;
     }
   }
@@ -1196,7 +1196,7 @@ Error CoverageMapping::loadFromFile(
     std::optional<std::reference_wrapper<IndexedInstrProfReader>>
         &ProfileReader,
     CoverageMapping &Coverage, bool &DataFound,
-    SmallVectorImpl<object::BuildID> *FoundBinaryIDs) {
+    SmallVectorImpl<object::BuildID> *FoundBinaryIDs, StringRef ObjectFilename) {
   auto CovMappingBufOrErr = MemoryBuffer::getFileOrSTDIN(
       Filename, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   if (std::error_code EC = CovMappingBufOrErr.getError())
@@ -1228,7 +1228,7 @@ Error CoverageMapping::loadFromFile(
                        }));
   }
   DataFound |= !Readers.empty();
-  if (Error E = loadFromReaders(Readers, ProfileReader, Coverage, Arch))
+  if (Error E = loadFromReaders(Readers, ProfileReader, Coverage, Arch, ObjectFilename))
     return createFileError(Filename, std::move(E));
   return Error::success();
 }
@@ -1262,14 +1262,20 @@ Expected<std::unique_ptr<CoverageMapping>> CoverageMapping::load(
     return Arches[Idx];
   };
 
+  //I beleive there is an error in this area of code, it's iterating through all arch's of the object files
+  // but its only filling *Coverage with last architecture it gets to
+
   SmallVector<object::BuildID> FoundBinaryIDs;
   for (const auto &File : llvm::enumerate(ObjectFilenames)) {
     if (Error E = loadFromFile(File.value(), GetArch(File.index()),
                                CompilationDir, ProfileReaderRef, *Coverage,
-                               DataFound, &FoundBinaryIDs))
+                               DataFound, &FoundBinaryIDs, ObjectFilenames[File.index()]))
       return std::move(E);
   }
 
+  //I beleive there is an error in this area of code, it's iterating through all arch's of the object files
+  // but its only filling *Coverage with last architecture it gets to
+
   if (BIDFetcher) {
     std::vector<object::BuildID> ProfileBinaryIDs;
     if (ProfileReader)
@@ -1508,19 +1514,24 @@ class SegmentBuilder {
   }
 
   /// Combine counts of regions which cover the same area.
+  //[(3:12, 10:1), (4:1, 6:7), (6:7, 8:1)]
   static ArrayRef<CountedRegion>
   combineRegions(MutableArrayRef<CountedRegion> Regions) {
     if (Regions.empty())
       return Regions;
+
+    
     auto Active = Regions.begin();
     auto End = Regions.end();
     for (auto I = Regions.begin() + 1; I != End; ++I) {
-      if (Active->startLoc() != I->startLoc() ||
-          Active->endLoc() != I->endLoc()) {
+      if (Active->startLoc() != I->startLoc() || Active->endLoc() != I->endLoc()) {
         // Shift to the next region.
         ++Active;
-        if (Active != I)
+        if (Active != I){
           *Active = *I;
+          // Active->ExecutionCount = 1;
+          // Active->Kind = CounterMappingRegion::CodeRegion;
+        }
         continue;
       }
       // Merge duplicate region.
@@ -1549,6 +1560,29 @@ class SegmentBuilder {
     SegmentBuilder Builder(Segments);
 
     sortNestedRegions(Regions);
+
+    for(auto *I = Regions.begin(); I != Regions.end(); ++I){
+      bool FoundMatchInOtherBinary = false;
+      for(auto *J = I + 1; J != Regions.end(); ++J){
+        if(I->ObjectFilename != J->ObjectFilename &&
+            J->Kind == CounterMappingRegion::SkippedRegion 
+            && I->Kind != CounterMappingRegion::SkippedRegion &&
+            J->startLoc() >= I->startLoc() && J->endLoc() <= I->endLoc()){
+          for(auto *K = J + 1; K != Regions.end(); ++K){
+            if(K->ObjectFilename == I->ObjectFilename &&
+              J->startLoc() == K->startLoc() && J->endLoc() == K->endLoc()){
+              FoundMatchInOtherBinary = true;
+            }
+          }
+          if(!FoundMatchInOtherBinary){
+            J->Kind = I->Kind;
+            J->ExecutionCount = I->ExecutionCount;
+          }
+        }
+      }
+    }
+    
+
     ArrayRef<CountedRegion> CombinedRegions = combineRegions(Regions);
 
     LLVM_DEBUG({

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

@@ -288,7 +288,7 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray(
           // Don't do anything when we have a code region with a zero counter.
           break;
         case CounterMappingRegion::SkippedRegion:
-          Kind = CounterMappingRegion::SkippedRegion;
+          Kind = CounterMappingRegion::SkippedRegion; //if you change this to "CodeRegion, then all skipped regions have counter of 0"
           break;
         case CounterMappingRegion::BranchRegion:
           // For a Branch Region, read two successive counters.
@@ -381,7 +381,6 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray(
         CounterMappingContext(Expressions).dump(C, dbgs());
       dbgs() << "\n";
     });
-
     auto CMR = CounterMappingRegion(
         C, C2, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
         LineStart + NumLines, ColumnEnd, Kind, Params);

llvm/lib/ProfileData/InstrProfWriter.cpp

@@ -15,7 +15,11 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/bit.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/IR/ProfileSummary.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/ProfileData/DataAccessProf.h"
 #include "llvm/ProfileData/IndexedMemProfData.h"
 #include "llvm/ProfileData/InstrProf.h"
@@ -216,16 +220,47 @@ void InstrProfWriter::overlapRecord(NamedInstrProfRecord &&Other,
 //   Dest.sortValueData();
 // }
 
+
+
+// #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+
+
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/Support/SHA1.h>
+#include <array>
+
+StringRef hashSourceFile(llvm::StringRef FilePath) {
+    auto FileOrErr = llvm::MemoryBuffer::getFile(FilePath);
+    if (!FileOrErr) {
+        llvm::errs() << "Error reading file: " << FilePath << "\n";
+        return "";
+    }
+
+    const auto &Buffer = *FileOrErr.get();
+    llvm::SHA1 Hasher;
+    Hasher.update(Buffer.getBuffer());
+
+    std::array<uint8_t, 20> Hash = Hasher.final();
+    
+    std::string HexStr = llvm::toHex(llvm::ArrayRef<uint8_t>(Hash));
+    llvm::StringRef HashRef(HexStr);
+    return HashRef;
+}
+
+
+
 void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
                                 InstrProfRecord &&I, uint64_t Weight,
                                 function_ref<void(Error)> Warn, StringRef Architecture) {
   auto &ProfileDataMap = FunctionData[Name];
+  StringRef SHAHash = hashSourceFile(Architecture);
+  llvm::errs() << "SHA Hashing: " << SHAHash << "\n";
   if(!Architecture.empty()){
     std::string HashStr = std::to_string(Hash) + ":" + Architecture.str();
     llvm::StringRef HashRef(HashStr);
     Hash = IndexedInstrProf::ComputeHash(HashRef);
   }
-
   auto [Where, NewFunc] = ProfileDataMap.try_emplace(Hash);
   InstrProfRecord &Dest = Where->second;