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

Add the BB Hash to the generated `.llvm_bb_addr_map` section. The
Propeller tool reads it and write to the output file. When building
updated code, llvm matches the file with the current BB Hash and
generates BBCluster based on the Hash matching results. This feature is
controlled by the `bbsections-match-hash` option and is disabled by
default.

Author: XiaShark

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)