added new way of hashing the functions so they are more consistent with hashes from .profraw file

Author: Andres Wearden

llvm/include/llvm/ProfileData/InstrProf.h

@@ -644,13 +644,19 @@ class InstrProfSymtab {
 
     // 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(SymbolName);
+    
+    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);
     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) {
       MD5NameMap.push_back(std::make_pair(
-          IndexedInstrProf::ComputeHash(SymbolName), Ins.first->getKey()));
+          IndexedInstrProf::ComputeHash(HashRef), Ins.first->getKey()));
       Sorted = false;
     }
     return Error::success();
@@ -779,10 +785,14 @@ StringRef InstrProfSymtab::getFuncOrVarNameIfDefined(uint64_t MD5Hash) {
 
 StringRef InstrProfSymtab::getFuncOrVarName(uint64_t MD5Hash) {
   finalizeSymtab();
-  auto Result = llvm::lower_bound(MD5NameMap, MD5Hash,
+  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 == MD5Hash)
+  if (Result != MD5NameMap.end() && Result->first == NewMD5Hash)
     return Result->second;
   return StringRef();
 }

llvm/include/llvm/ProfileData/InstrProfWriter.h

@@ -114,6 +114,11 @@ class InstrProfWriter {
   /// summed. Optionally scale counts by \p Weight.
   LLVM_ABI void addRecord(NamedInstrProfRecord &&I, uint64_t Weight,
                           function_ref<void(Error)> Warn);
+  LLVM_ABI void addRecord(StringRef Name, uint64_t Hash,
+                                InstrProfRecord &&I, uint64_t Weight,
+                                function_ref<void(Error)> Warn, const std::string &Architecture);
+  void addRecord(NamedInstrProfRecord &&I, uint64_t Weight, const std::string &Architecture,
+                                function_ref<void(Error)> Warn);
   void addRecord(NamedInstrProfRecord &&I, function_ref<void(Error)> Warn) {
     addRecord(std::move(I), 1, Warn);
   }

llvm/lib/ProfileData/InstrProf.cpp

@@ -320,6 +320,8 @@ std::string getPGOFuncName(StringRef Name, GlobalValue::LinkageTypes Linkage,
     else
       NewName = NewName.insert(0, FileName.str() + ":");
   }
+
+  
   return NewName;
 }
 
@@ -606,7 +608,6 @@ Error readAndDecodeStrings(StringRef NameStrings,
     SmallVector<StringRef, 0> Names;
     StringRef ArchRef(Architecture); 
     NameStrings.split(Names, getInstrProfNameSeparator());
-    printf("=====================READER DATA====================");
     for (StringRef &Name : Names){
       std::string ConcHashString = Name.str() + ":" + ArchRef.str();
       printf("The string %s will get hashed and mapped to %s\n", ConcHashString.c_str(), Name.str().c_str());

llvm/lib/ProfileData/InstrProfWriter.cpp

@@ -153,11 +153,11 @@ void InstrProfWriter::setValueProfDataEndianness(llvm::endianness Endianness) {
 
 void InstrProfWriter::setOutputSparse(bool Sparse) { this->Sparse = Sparse; }
 
-void InstrProfWriter::addRecord(NamedInstrProfRecord &&I, uint64_t Weight,
+void InstrProfWriter::addRecord(NamedInstrProfRecord &&I, uint64_t Weight, const std::string &Architecture,
                                 function_ref<void(Error)> Warn) {
   auto Name = I.Name;
   auto Hash = I.Hash;
-  addRecord(Name, Hash, std::move(I), Weight, Warn);
+  addRecord(Name, Hash, std::move(I), Weight, Warn, Architecture);
 }
 
 void InstrProfWriter::overlapRecord(NamedInstrProfRecord &&Other,
@@ -216,6 +216,34 @@ void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
   Dest.sortValueData();
 }
 
+void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
+                                InstrProfRecord &&I, uint64_t Weight,
+                                function_ref<void(Error)> Warn, const std::string &Architecture) {
+  auto &ProfileDataMap = FunctionData[Name];
+  std::string HashStr = std::to_string(Hash) + ":" + Architecture;
+  llvm::StringRef HashRef(HashStr);
+  uint64_t NewHash = IndexedInstrProf::ComputeHash(HashRef);
+
+  auto [Where, NewFunc] = ProfileDataMap.try_emplace(NewHash);
+  InstrProfRecord &Dest = Where->second;
+
+  auto MapWarn = [&](instrprof_error E) {
+    Warn(make_error<InstrProfError>(E));
+  };
+
+  if (NewFunc) {
+    // We've never seen a function with this name and hash, add it.
+    Dest = std::move(I);
+    if (Weight > 1)
+      Dest.scale(Weight, 1, MapWarn);
+  } else {
+    // We're updating a function we've seen before.
+    Dest.merge(I, Weight, MapWarn);
+  }
+
+  Dest.sortValueData();
+}
+
 void InstrProfWriter::addMemProfRecord(
     const Function::GUID Id, const memprof::IndexedMemProfRecord &Record) {
   auto NewRecord = Record;

llvm/tools/llvm-profdata/llvm-profdata.cpp

@@ -862,7 +862,7 @@ loadInput(const WeightedFile &Input, SymbolRemapper *Remapper,
       I.Name = (*Remapper)(I.Name);
     const StringRef FuncName = I.Name;
     bool Reported = false;
-    WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
+    WC->Writer.addRecord(std::move(I), Input.Weight, Architecture, [&](Error E) {
       if (Reported) {
         consumeError(std::move(E));
         return;