saving changes to compare with main branch

Author: Andres Wearden

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

@@ -993,17 +993,24 @@ class CoverageMapping {
   std::vector<FunctionRecord> Functions;
   DenseMap<size_t, SmallVector<unsigned, 0>> FilenameHash2RecordIndices;
   std::vector<std::pair<std::string, uint64_t>> FuncHashMismatches;
+  StringRef Arch;
 
   std::optional<bool> SingleByteCoverage;
 
   CoverageMapping() = default;
 
   // Load coverage records from readers.
   static Error loadFromReaders(
-      ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
-      std::optional<std::reference_wrapper<IndexedInstrProfReader>>
-          &ProfileReader,
-      CoverageMapping &Coverage);
+    ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
+    std::optional<std::reference_wrapper<IndexedInstrProfReader>>
+        &ProfileReader,
+    CoverageMapping &Coverage, StringRef Arch);
+  
+  static Error loadFromReaders(
+    ArrayRef<std::unique_ptr<CoverageMappingReader>> CoverageReaders,
+    std::optional<std::reference_wrapper<IndexedInstrProfReader>>
+        &ProfileReader,
+    CoverageMapping &Coverage);
 
   // Load coverage records from file.
   static Error
@@ -1018,6 +1025,8 @@ class CoverageMapping {
       const CoverageMappingRecord &Record,
       const std::optional<std::reference_wrapper<IndexedInstrProfReader>>
           &ProfileReader);
+  
+  Error loadFunctionRecord(const CoverageMappingRecord &Record, const std::optional<std::reference_wrapper<IndexedInstrProfReader>> &ProfileReader, const std::string &Arch);
 
   /// 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
@@ -1027,6 +1036,13 @@ class CoverageMapping {
   getImpreciseRecordIndicesForFilename(StringRef Filename) const;
 
 public:
+
+  const StringRef &getArchitecture() const { return Arch; }
+
+  void setArchitecture(StringRef NewArch){
+    Arch = StringRef(NewArch);
+  }
+
   CoverageMapping(const CoverageMapping &) = delete;
   CoverageMapping &operator=(const CoverageMapping &) = delete;
 
@@ -1234,8 +1250,9 @@ uint64_t getFuncNameRef(const FuncRecordTy *Record) {
 /// a hash.
 template <class FuncRecordTy, llvm::endianness Endian>
 Error getFuncNameViaRef(const FuncRecordTy *Record,
-                        InstrProfSymtab &ProfileNames, StringRef &FuncName) {
+                        InstrProfSymtab &ProfileNames, StringRef &FuncName, StringRef Arch = "") {
   uint64_t NameRef = getFuncNameRef<FuncRecordTy, Endian>(Record);
+  ProfileNames.setArchitecture(Arch.str());
   FuncName = ProfileNames.getFuncOrVarName(NameRef);
   return Error::success();
 }
@@ -1285,7 +1302,7 @@ struct CovMapFunctionRecordV1 {
 
   /// Return the PGO name of the function.
   template <llvm::endianness Endian>
-  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName, StringRef Arch = "") const {
     IntPtrT NameRef = getFuncNameRef<Endian>();
     uint32_t NameS = support::endian::byte_swap<uint32_t, Endian>(NameSize);
     FuncName = ProfileNames.getFuncName(NameRef, NameS);
@@ -1334,7 +1351,7 @@ struct CovMapFunctionRecordV2 {
   }
 
   template <llvm::endianness Endian>
-  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName, StringRef Arch = "") const {
     return accessors::getFuncNameViaRef<ThisT, Endian>(this, ProfileNames,
                                                        FuncName);
   }
@@ -1378,9 +1395,9 @@ struct CovMapFunctionRecordV3 {
   }
 
   template <llvm::endianness Endian>
-  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName, StringRef Arch = "") const {
     return accessors::getFuncNameViaRef<ThisT, Endian>(this, ProfileNames,
-                                                       FuncName);
+                                                       FuncName, Arch);
   }
 
   /// Get the filename set reference.

llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h

@@ -39,6 +39,12 @@ struct CoverageMappingRecord {
   ArrayRef<StringRef> Filenames;
   ArrayRef<CounterExpression> Expressions;
   ArrayRef<CounterMappingRegion> MappingRegions;
+  StringRef Arch;
+
+  const StringRef &getArchitecture() const { return Arch; }
+  void setArchitecture(StringRef NewArch){
+    Arch = StringRef(NewArch);
+  }
 };
 
 /// A file format agnostic iterator over coverage mapping data.
@@ -191,6 +197,7 @@ class LLVM_ABI BinaryCoverageReader : public CoverageMappingReader {
   std::vector<StringRef> FunctionsFilenames;
   std::vector<CounterExpression> Expressions;
   std::vector<CounterMappingRegion> MappingRegions;
+  StringRef Arch;
 
   // Used to tie the lifetimes of coverage function records to the lifetime of
   // this BinaryCoverageReader instance. Needed to support the format change in
@@ -223,7 +230,7 @@ class LLVM_ABI BinaryCoverageReader : public CoverageMappingReader {
       StringRef Coverage, FuncRecordsStorage &&FuncRecords,
       CoverageMapCopyStorage &&CoverageMap,
       std::unique_ptr<InstrProfSymtab> ProfileNamesPtr, uint8_t BytesInAddress,
-      llvm::endianness Endian, StringRef CompilationDir = "");
+      llvm::endianness Endian, StringRef CompilationDir = "", StringRef Arch = "");
 
   Error readNextRecord(CoverageMappingRecord &Record) override;
 };

llvm/include/llvm/ProfileData/InstrProf.h

@@ -636,22 +636,23 @@ class InstrProfSymtab {
   // Map the MD5 of the symbol name to the name.
   Error addSymbolName(StringRef SymbolName) {
     StringRef FuncName;
-    StringRef ArchName;
+    StringRef ArchName = "";
     std::tie(FuncName, ArchName) = SymbolName.split(":");
     if (SymbolName.empty())
       return make_error<InstrProfError>(instrprof_error::malformed,
                                         "symbol name is empty");
 
     // Insert into NameTab so that MD5NameMap (a vector that will be sorted)
     // won't have duplicated entries in the first place.
-    
     uint64_t HashValue = IndexedInstrProf::ComputeHash(FuncName);
-    std::string HashStr = std::to_string(HashValue);
-    std::string CombinedStr = HashStr + ":" + ArchName.str();
-    llvm::StringRef HashRef(CombinedStr);
-    HashValue = IndexedInstrProf::ComputeHash(HashRef);
-
-    printf("Hash Value for %.*s: %" PRIu64 "\n", static_cast<int>(SymbolName.size()), SymbolName.data(), HashValue);
+    llvm::StringRef HashRef(FuncName);
+    if(!ArchName.empty()){
+      std::string HashStr = std::to_string(HashValue);
+      std::string CombinedStr = HashStr + ":" + ArchName.str();
+      HashRef = CombinedStr;
+      HashValue = IndexedInstrProf::ComputeHash(HashRef);
+    }
+    printf("Hash Value for %.*s %" PRIu64 "\n", static_cast<int>(SymbolName.size()), SymbolName.data(), HashValue);
     auto Ins = NameTab.insert(FuncName);
     printf("mapped value for %" PRIu64 " hash: %.*s\n", HashValue, static_cast<int>(Ins.first->getKey().size()), Ins.first->getKey().data());
     if (Ins.second) {
@@ -786,13 +787,14 @@ StringRef InstrProfSymtab::getFuncOrVarNameIfDefined(uint64_t MD5Hash) {
 StringRef InstrProfSymtab::getFuncOrVarName(uint64_t MD5Hash) {
   finalizeSymtab();
   std::string TempMD5HashStr = std::to_string(MD5Hash);
-  std::string CombinedHashStr = TempMD5HashStr + ":" + Architecture;
-  llvm::StringRef CombinedHashRef(CombinedHashStr);
-  uint64_t NewMD5Hash = IndexedInstrProf::ComputeHash(CombinedHashRef);
-  auto Result = llvm::lower_bound(MD5NameMap, NewMD5Hash,
-                                  [](const std::pair<uint64_t, StringRef> &LHS,
-                                     uint64_t RHS) { return LHS.first < RHS; });
-  if (Result != MD5NameMap.end() && Result->first == NewMD5Hash)
+  if(!Architecture.empty()){
+    std::string CombinedHashStr = TempMD5HashStr + ":" + Architecture;
+    llvm::StringRef CombinedHashRef(CombinedHashStr);
+    MD5Hash = IndexedInstrProf::ComputeHash(CombinedHashRef);
+  }
+  auto Result = llvm::lower_bound(MD5NameMap, MD5Hash, [](const std::pair<uint64_t, StringRef> &LHS, uint64_t RHS) { return LHS.first < RHS; });
+  llvm::errs() << "Architecture: " << (!Architecture.empty() ? Architecture : "No Specified Architecture") << ": " << Result->second<< ": " << "Result->first: " << Result->first << " vs. MD5hash: " << MD5Hash << "\n";
+  if (Result != MD5NameMap.end() && Result->first == MD5Hash)
     return Result->second;
   return StringRef();
 }

llvm/include/llvm/ProfileData/InstrProfReader.h

@@ -875,6 +875,10 @@ class LLVM_ABI IndexedInstrProfReader : public InstrProfReader {
   create(const Twine &Path, vfs::FileSystem &FS,
          const Twine &RemappingPath = "");
 
+  static Expected<std::unique_ptr<IndexedInstrProfReader>>
+  create(const Twine &Path, vfs::FileSystem &FS,
+        const std::string &Arch, const Twine &RemappingPath = "");
+
   static Expected<std::unique_ptr<IndexedInstrProfReader>>
   create(std::unique_ptr<MemoryBuffer> Buffer,
          std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr);