!163 [Propeller] Match the hash value of BB to adapt to source drift

From: @xiajingze 
Reviewed-by: @liyunfei33 
Signed-off-by: @liyunfei33

Author: openeuler-ci-bot

llvm/include/llvm/CodeGen/BasicBlockSectionsProfileReader.h

@@ -28,11 +28,14 @@
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 namespace llvm {
 
+extern cl::opt<bool> BBSectionsMatchHash;
+
 // This struct represents the cluster information for a machine basic block,
 // which is specifed by a unique ID (`MachineBasicBlock::BBID`).
 struct BBClusterInfo {
@@ -65,13 +68,22 @@ template <> struct DenseMapInfo<UniqueBBID> {
     return UniqueBBID{TombstoneKey, TombstoneKey};
   }
   static unsigned getHashValue(const UniqueBBID &Val) {
+    if (BBSectionsMatchHash) {
+      std::pair<uint64_t, unsigned> PairVal =
+          std::make_pair(Val.Hash, Val.CloneID);
+      return DenseMapInfo<std::pair<uint64_t, unsigned>>::getHashValue(PairVal);
+    }
     std::pair<unsigned, unsigned> PairVal =
         std::make_pair(Val.BaseID, Val.CloneID);
     return DenseMapInfo<std::pair<unsigned, unsigned>>::getHashValue(PairVal);
   }
   static bool isEqual(const UniqueBBID &LHS, const UniqueBBID &RHS) {
+    if (BBSectionsMatchHash) {
+      return DenseMapInfo<uint64_t>::isEqual(LHS.Hash, RHS.Hash) &&
+             DenseMapInfo<unsigned>::isEqual(LHS.CloneID, RHS.CloneID);
+    }
     return DenseMapInfo<unsigned>::isEqual(LHS.BaseID, RHS.BaseID) &&
-           DenseMapInfo<unsigned>::isEqual(LHS.CloneID, RHS.CloneID);
+            DenseMapInfo<unsigned>::isEqual(LHS.CloneID, RHS.CloneID);
   }
 };
 

llvm/include/llvm/CodeGen/MachineBasicBlock.h

@@ -100,6 +100,7 @@ template <> struct DenseMapInfo<MBBSectionID> {
 // the basic block sections profile.
 struct UniqueBBID {
   unsigned BaseID;
+  uint64_t Hash;
   unsigned CloneID;
 };
 
@@ -677,9 +678,13 @@ class MachineBasicBlock
 
   std::optional<UniqueBBID> getBBID() const { return BBID; }
 
+  uint64_t getHash() const { return BBID->Hash; }
+
   /// Returns the section ID of this basic block.
   MBBSectionID getSectionID() const { return SectionID; }
 
+  void setHash(uint64_t Hash) { BBID->Hash = Hash; }
+
   /// Sets the fixed BBID of this basic block.
   void setBBID(const UniqueBBID &V) {
     assert(!BBID.has_value() && "Cannot change BBID.");

llvm/include/llvm/Object/ELFTypes.h

@@ -910,9 +910,11 @@ struct BBAddrMap {
     uint32_t Size = 0;   // Size of the basic block.
     Metadata MD = {false, false, false, false,
                    false}; // Metdata for this basic block.
+    uint64_t Hash = 0;     // Hash value of the basic block.
 
-    BBEntry(uint32_t ID, uint32_t Offset, uint32_t Size, Metadata MD)
-        : ID(ID), Offset(Offset), Size(Size), MD(MD){};
+    BBEntry(uint32_t ID, uint32_t Offset, uint32_t Size, Metadata MD,
+            uint64_t Hash)
+        : ID(ID), Offset(Offset), Size(Size), MD(MD), Hash(Hash){};
 
     bool operator==(const BBEntry &Other) const {
       return ID == Other.ID && Offset == Other.Offset && Size == Other.Size &&

llvm/include/llvm/ObjectYAML/ELFYAML.h

@@ -162,6 +162,7 @@ struct BBAddrMapEntry {
     llvm::yaml::Hex64 AddressOffset;
     llvm::yaml::Hex64 Size;
     llvm::yaml::Hex64 Metadata;
+    llvm::yaml::Hex64 Hash;
   };
   uint8_t Version;
   llvm::yaml::Hex8 Feature;

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

@@ -1425,6 +1425,8 @@ void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
     emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol);
     // Emit the Metadata.
     OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
+    OutStreamer->AddComment("hash value");
+    OutStreamer->emitULEB128IntValue(MBB.getHash());
     PrevMBBEndSymbol = MBB.getEndSymbol();
   }
 

llvm/lib/CodeGen/BasicBlockPathCloning.cpp

@@ -56,7 +56,8 @@ MachineBasicBlock *CloneMachineBasicBlock(MachineBasicBlock &OrigBB,
   auto TII = MF.getSubtarget().getInstrInfo();
   // Create the clone block and set its BBID based on the original block.
   MachineBasicBlock *CloneBB = MF.CreateMachineBasicBlock(
-      OrigBB.getBasicBlock(), UniqueBBID{OrigBB.getBBID()->BaseID, CloneID});
+      OrigBB.getBasicBlock(), UniqueBBID{OrigBB.getBBID()->BaseID,
+                                         OrigBB.getBBID()->Hash, CloneID});
   MF.push_back(CloneBB);
 
   // Copy the instructions.

llvm/lib/CodeGen/BasicBlockSections.cpp

@@ -70,13 +70,15 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/CodeGen/BasicBlockSectionUtils.h"
 #include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/InitializePasses.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/Target/TargetMachine.h"
 #include <optional>
 
@@ -289,12 +291,43 @@ bool llvm::hasInstrProfHashMismatch(MachineFunction &MF) {
   return false;
 }
 
+void computeBBHash(MachineFunction &MF) {
+  for (auto &MBB : MF) {
+    llvm::hash_code Hash = llvm::hash_value(0);
+    for (const MachineInstr &MI : MBB) {
+      if (MI.isPseudo() || MI.isDebugOrPseudoInstr())
+        continue;
+      if (MI.isUnconditionalBranch())
+        continue;
+      Hash = llvm::hash_combine(Hash, MI.getOpcode());
+
+      for (const MachineOperand &MO : MI.operands()) {
+        if (MO.isReg()) {
+          Hash = llvm::hash_combine(Hash, MO.getReg());
+        } else if (MO.isImm()) {
+          Hash = llvm::hash_combine(Hash, MO.getImm());
+        } else if (MO.isCImm()) {
+          Hash = llvm::hash_combine(Hash, MO.getCImm()->getZExtValue());
+        } else if (MO.isFPImm()) {
+          Hash = llvm::hash_combine(Hash, MO.getFPImm()->getValueAPF().bitcastToAPInt().getZExtValue());
+        } else if (MO.isGlobal()) {
+          Hash = llvm::hash_combine(Hash, MO.getGlobal()->getName());
+        } else if (MO.isSymbol()) {
+          Hash = llvm::hash_combine(Hash, MO.getSymbolName());
+        }
+      }
+    }
+    MBB.setHash(Hash);
+  }
+}
+
 // Identify, arrange, and modify basic blocks which need separate sections
 // according to the specification provided by the -fbasic-block-sections flag.
 bool BasicBlockSections::handleBBSections(MachineFunction &MF) {
   auto BBSectionsType = MF.getTarget().getBBSectionsType();
   if (BBSectionsType == BasicBlockSection::None)
     return false;
+  computeBBHash(MF);
 
   // Check for source drift. If the source has changed since the profiles
   // were obtained, optimizing basic blocks might be sub-optimal.
@@ -384,6 +417,7 @@ bool BasicBlockSections::handleBBAddrMap(MachineFunction &MF) {
     return false;
   if (!MF.getTarget().Options.BBAddrMap)
     return false;
+  computeBBHash(MF);
   MF.RenumberBlocks();
   return true;
 }

llvm/lib/CodeGen/BasicBlockSectionsProfileReader.cpp

@@ -30,6 +30,13 @@
 
 using namespace llvm;
 
+namespace llvm {
+cl::opt<bool> BBSectionsMatchHash(
+    "bbsections-match-hash",
+    cl::desc("This matches basic blocks by hash to fit source drift"),
+    cl::init(false), cl::Hidden);
+}
+
 char BasicBlockSectionsProfileReaderWrapperPass::ID = 0;
 INITIALIZE_PASS(BasicBlockSectionsProfileReaderWrapperPass,
                 "bbsections-profile-reader",
@@ -41,18 +48,29 @@ BasicBlockSectionsProfileReader::parseUniqueBBID(StringRef S) const {
   SmallVector<StringRef, 2> Parts;
   S.split(Parts, '.');
   if (Parts.size() > 2)
-    return createProfileParseError(Twine("unable to parse basic block id: '") +
+    return createProfileParseError(Twine("unable to parse unique basic block id: '") +
                                    S + "'");
-  unsigned long long BaseBBID;
-  if (getAsUnsignedInteger(Parts[0], 10, BaseBBID))
+  SmallVector<StringRef, 2> IdAndHash;
+  Parts[0].split(IdAndHash, '-');
+  if (IdAndHash.size() > 2)
+    return createProfileParseError(Twine("unable to parse basic block id and hash: '") +
+                                   Parts[0] + "'");
+  unsigned long long BaseBBID = 0;
+  if (getAsUnsignedInteger(IdAndHash[0], 10, BaseBBID))
     return createProfileParseError(
-        Twine("unable to parse BB id: '" + Parts[0]) +
+        Twine("unable to parse BB id: '" + IdAndHash[0]) +
         "': unsigned integer expected");
+  unsigned long long BBHash = 0;
+  if (IdAndHash.size() > 1 && getAsUnsignedInteger(IdAndHash[1], 16, BBHash))
+    return createProfileParseError(
+        Twine("unable to parse BB hash: '" + IdAndHash[1]) +
+        "': hex unsigned integer expected");
   unsigned long long CloneID = 0;
   if (Parts.size() > 1 && getAsUnsignedInteger(Parts[1], 10, CloneID))
     return createProfileParseError(Twine("unable to parse clone id: '") +
                                    Parts[1] + "': unsigned integer expected");
   return UniqueBBID{static_cast<unsigned>(BaseBBID),
+                    static_cast<uint64_t>(BBHash),
                     static_cast<unsigned>(CloneID)};
 }
 

llvm/lib/Object/ELF.cpp

@@ -858,6 +858,7 @@ decodeBBAddrMapImpl(const ELFFile<ELFT> &EF,
         uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
         uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
         uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
+        uint64_t Hash = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr);
         if (Version >= 1) {
           // Offset is calculated relative to the end of the previous BB.
           Offset += PrevBBEndOffset;
@@ -869,7 +870,7 @@ decodeBBAddrMapImpl(const ELFFile<ELFT> &EF,
           MetadataDecodeErr = MetadataOrErr.takeError();
           break;
         }
-        BBEntries.push_back({ID, Offset, Size, *MetadataOrErr});
+        BBEntries.push_back({ID, Offset, Size, *MetadataOrErr, Hash});
       }
       TotalNumBlocks += BBEntries.size();
       BBRangeEntries.push_back({RangeBaseAddress, std::move(BBEntries)});

llvm/lib/ObjectYAML/ELFEmitter.cpp

@@ -1509,6 +1509,7 @@ void ELFState<ELFT>::writeSectionContent(
         SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset);
         SHeader.sh_size += CBA.writeULEB128(BBE.Size);
         SHeader.sh_size += CBA.writeULEB128(BBE.Metadata);
+        SHeader.sh_size += CBA.writeULEB128(BBE.Hash);
       }
     }
     if (!PGOAnalyses)